STY: Make PEP8 fixes in numpy/f2py

Decided to bite the bullet on this one. The code is certainly more
readable, so should be easier to fix if we need to.

15 files changed, 4047 insertions, 3233 deletions

diff --git a/numpy/f2py/__init__.py b/numpy/f2py/__init__.py
index ef4d54e9d..17a575927 100644
--- a/numpy/f2py/__init__.py
+++ b/numpy/f2py/__init__.py
@@ -15,11 +15,12 @@ from . import diagnose
 run_main = f2py2e.run_main
 main = f2py2e.main
 
+
 def compile(source,
-            modulename = 'untitled',
-            extra_args = '',
-            verbose = 1,
-            source_fn = None
+            modulename='untitled',
+            extra_args='',
+            verbose=1,
+            source_fn=None
             ):
     ''' Build extension module from processing source with f2py.
     Read the source of this function for more information.
@@ -35,9 +36,9 @@ def compile(source,
         f.write(source)
         f.flush()
 
-        args = ' -c -m %s %s %s'%(modulename, f.name, extra_args)
+        args = ' -c -m %s %s %s' % (modulename, f.name, extra_args)
         c = '%s -c "import numpy.f2py as f2py2e;f2py2e.main()" %s' % \
-                (sys.executable, args)
+            (sys.executable, args)
         s, o = exec_command(c)
     finally:
         f.close()
diff --git a/numpy/f2py/__main__.py b/numpy/f2py/__main__.py
index 11dbf5f52..8f6d25619 100644
--- a/numpy/f2py/__main__.py
+++ b/numpy/f2py/__main__.py
@@ -1,21 +1,23 @@
 # See http://cens.ioc.ee/projects/f2py2e/
-import os, sys
+import os
+import sys
 for mode in ["g3-numpy", "2e-numeric", "2e-numarray", "2e-numpy"]:
     try:
-        i=sys.argv.index("--"+mode)
+        i = sys.argv.index("--" + mode)
         del sys.argv[i]
         break
-    except ValueError: pass
-os.environ["NO_SCIPY_IMPORT"]="f2py"
-if mode=="g3-numpy":
+    except ValueError:
+        pass
+os.environ["NO_SCIPY_IMPORT"] = "f2py"
+if mode == "g3-numpy":
     sys.stderr.write("G3 f2py support is not implemented, yet.\\n")
     sys.exit(1)
-elif mode=="2e-numeric":
+elif mode == "2e-numeric":
     from f2py2e import main
-elif mode=="2e-numarray":
+elif mode == "2e-numarray":
     sys.argv.append("-DNUMARRAY")
     from f2py2e import main
-elif mode=="2e-numpy":
+elif mode == "2e-numpy":
     from numpy.f2py import main
 else:
     sys.stderr.write("Unknown mode: " + repr(mode) + "\\n")
diff --git a/numpy/f2py/auxfuncs.py b/numpy/f2py/auxfuncs.py
index d762aa7a5..9e6a393c3 100644
--- a/numpy/f2py/auxfuncs.py
+++ b/numpy/f2py/auxfuncs.py
@@ -56,8 +56,8 @@ f2py_version = __version__.version
 errmess = sys.stderr.write
 show = pprint.pprint
 
-options={}
-debugoptions=[]
+options = {}
+debugoptions = []
 wrapfuncs = 1
 
 
@@ -65,44 +65,57 @@ def outmess(t):
     if options.get('verbose', 1):
         sys.stdout.write(t)
 
+
 def debugcapi(var):
     return 'capi' in debugoptions
 
+
 def _isstring(var):
-    return 'typespec' in var and var['typespec']=='character' and (not isexternal(var))
+    return 'typespec' in var and var['typespec'] == 'character' and (not isexternal(var))
+
 
 def isstring(var):
     return _isstring(var) and not isarray(var)
 
+
 def ischaracter(var):
     return isstring(var) and 'charselector' not in var
 
+
 def isstringarray(var):
     return isarray(var) and _isstring(var)
 
+
 def isarrayofstrings(var):
     # leaving out '*' for now so that
     # `character*(*) a(m)` and `character a(m,*)`
     # are treated differently. Luckily `character**` is illegal.
-    return isstringarray(var) and var['dimension'][-1]=='(*)'
+    return isstringarray(var) and var['dimension'][-1] == '(*)'
+
 
 def isarray(var):
     return 'dimension' in var and (not isexternal(var))
 
+
 def isscalar(var):
     return not (isarray(var) or isstring(var) or isexternal(var))
 
+
 def iscomplex(var):
     return isscalar(var) and var.get('typespec') in ['complex', 'double complex']
 
+
 def islogical(var):
-    return isscalar(var) and var.get('typespec')=='logical'
+    return isscalar(var) and var.get('typespec') == 'logical'
+
 
 def isinteger(var):
-    return isscalar(var) and var.get('typespec')=='integer'
+    return isscalar(var) and var.get('typespec') == 'integer'
+
 
 def isreal(var):
-    return isscalar(var) and var.get('typespec')=='real'
+    return isscalar(var) and var.get('typespec') == 'real'
+
 
 def get_kind(var):
     try:
@@ -113,187 +126,221 @@ def get_kind(var):
         except KeyError:
             pass
 
+
 def islong_long(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') not in ['integer', 'logical']:
         return 0
-    return get_kind(var)=='8'
+    return get_kind(var) == '8'
+
 
 def isunsigned_char(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-1'
+    return get_kind(var) == '-1'
+
 
 def isunsigned_short(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-2'
+    return get_kind(var) == '-2'
+
 
 def isunsigned(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-4'
+    return get_kind(var) == '-4'
+
 
 def isunsigned_long_long(var):
     if not isscalar(var):
         return 0
     if var.get('typespec') != 'integer':
         return 0
-    return get_kind(var)=='-8'
+    return get_kind(var) == '-8'
+
 
 def isdouble(var):
     if not isscalar(var):
         return 0
-    if not var.get('typespec')=='real':
+    if not var.get('typespec') == 'real':
         return 0
-    return get_kind(var)=='8'
+    return get_kind(var) == '8'
+
 
 def islong_double(var):
     if not isscalar(var):
         return 0
-    if not var.get('typespec')=='real':
+    if not var.get('typespec') == 'real':
         return 0
-    return get_kind(var)=='16'
+    return get_kind(var) == '16'
+
 
 def islong_complex(var):
     if not iscomplex(var):
         return 0
-    return get_kind(var)=='32'
+    return get_kind(var) == '32'
+
 
 def iscomplexarray(var):
     return isarray(var) and var.get('typespec') in ['complex', 'double complex']
 
+
 def isint1array(var):
-    return isarray(var) and var.get('typespec')=='integer' \
-    and get_kind(var)=='1'
+    return isarray(var) and var.get('typespec') == 'integer' \
+        and get_kind(var) == '1'
+
 
 def isunsigned_chararray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-1'
+        and get_kind(var) == '-1'
+
 
 def isunsigned_shortarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-2'
+        and get_kind(var) == '-2'
+
 
 def isunsignedarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-4'
+        and get_kind(var) == '-4'
+
 
 def isunsigned_long_longarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='-8'
+        and get_kind(var) == '-8'
+
 
 def issigned_chararray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='1'
+        and get_kind(var) == '1'
+
 
 def issigned_shortarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='2'
+        and get_kind(var) == '2'
+
 
 def issigned_array(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='4'
+        and get_kind(var) == '4'
+
 
 def issigned_long_longarray(var):
     return isarray(var) and var.get('typespec') in ['integer', 'logical']\
-           and get_kind(var)=='8'
+        and get_kind(var) == '8'
+
 
 def isallocatable(var):
     return 'attrspec' in var and 'allocatable' in var['attrspec']
 
+
 def ismutable(var):
-    return not (not 'dimension' in var or isstring(var))
+    return not ('dimension' not in var or isstring(var))
+
 
 def ismoduleroutine(rout):
     return 'modulename' in rout
 
+
 def ismodule(rout):
-    return ('block' in rout and 'module'==rout['block'])
+    return ('block' in rout and 'module' == rout['block'])
+
 
 def isfunction(rout):
-    return ('block' in rout and 'function'==rout['block'])
+    return ('block' in rout and 'function' == rout['block'])
+
+# def isfunction_wrap(rout):
+# return wrapfuncs and (iscomplexfunction(rout) or isstringfunction(rout))
+# and (not isexternal(rout))
 
-#def isfunction_wrap(rout):
-#    return wrapfuncs and (iscomplexfunction(rout) or isstringfunction(rout)) and (not isexternal(rout))
 
 def isfunction_wrap(rout):
     if isintent_c(rout):
         return 0
     return wrapfuncs and isfunction(rout) and (not isexternal(rout))
 
+
 def issubroutine(rout):
-    return ('block' in rout and 'subroutine'==rout['block'])
+    return ('block' in rout and 'subroutine' == rout['block'])
+
 
 def issubroutine_wrap(rout):
     if isintent_c(rout):
         return 0
     return issubroutine(rout) and hasassumedshape(rout)
 
+
 def hasassumedshape(rout):
     if rout.get('hasassumedshape'):
         return True
     for a in rout['args']:
         for d in rout['vars'].get(a, {}).get('dimension', []):
-            if d==':':
+            if d == ':':
                 rout['hasassumedshape'] = True
                 return True
     return False
 
+
 def isroutine(rout):
     return isfunction(rout) or issubroutine(rout)
 
+
 def islogicalfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return islogical(rout['vars'][a])
     return 0
 
+
 def islong_longfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return islong_long(rout['vars'][a])
     return 0
 
+
 def islong_doublefunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return islong_double(rout['vars'][a])
     return 0
 
+
 def iscomplexfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return iscomplex(rout['vars'][a])
     return 0
 
+
 def iscomplexfunction_warn(rout):
     if iscomplexfunction(rout):
         outmess("""\
@@ -307,35 +354,43 @@ def iscomplexfunction_warn(rout):
         return 1
     return 0
 
+
 def isstringfunction(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return isstring(rout['vars'][a])
     return 0
 
+
 def hasexternals(rout):
     return 'externals' in rout and rout['externals']
 
+
 def isthreadsafe(rout):
     return 'f2pyenhancements' in rout and 'threadsafe' in rout['f2pyenhancements']
 
+
 def hasvariables(rout):
     return 'vars' in rout and rout['vars']
 
+
 def isoptional(var):
     return ('attrspec' in var and 'optional' in var['attrspec'] and 'required' not in var['attrspec']) and isintent_nothide(var)
 
+
 def isexternal(var):
     return ('attrspec' in var and 'external' in var['attrspec'])
 
+
 def isrequired(var):
     return not isoptional(var) and isintent_nothide(var)
 
+
 def isintent_in(var):
     if 'intent' not in var:
         return 1
@@ -353,46 +408,62 @@ def isintent_in(var):
         return 0
     return 1
 
+
 def isintent_inout(var):
     return 'intent' in var and ('inout' in var['intent'] or 'outin' in var['intent']) and 'in' not in var['intent'] and 'hide' not in var['intent'] and 'inplace' not in var['intent']
 
+
 def isintent_out(var):
     return 'out' in var.get('intent', [])
 
+
 def isintent_hide(var):
     return ('intent' in var and ('hide' in var['intent'] or ('out' in var['intent'] and 'in' not in var['intent'] and (not l_or(isintent_inout, isintent_inplace)(var)))))
 
+
 def isintent_nothide(var):
     return not isintent_hide(var)
 
+
 def isintent_c(var):
     return 'c' in var.get('intent', [])
 
 # def isintent_f(var):
 #     return not isintent_c(var)
 
+
 def isintent_cache(var):
     return 'cache' in var.get('intent', [])
 
+
 def isintent_copy(var):
     return 'copy' in var.get('intent', [])
 
+
 def isintent_overwrite(var):
     return 'overwrite' in var.get('intent', [])
 
+
 def isintent_callback(var):
     return 'callback' in var.get('intent', [])
 
+
 def isintent_inplace(var):
     return 'inplace' in var.get('intent', [])
 
+
 def isintent_aux(var):
     return 'aux' in var.get('intent', [])
 
+
 def isintent_aligned4(var):
     return 'aligned4' in var.get('intent', [])
+
+
 def isintent_aligned8(var):
     return 'aligned8' in var.get('intent', [])
+
+
 def isintent_aligned16(var):
     return 'aligned16' in var.get('intent', [])
 
@@ -406,34 +477,41 @@ isintent_dict = {isintent_in: 'INTENT_IN', isintent_inout: 'INTENT_INOUT',
                  isintent_aligned16: 'INTENT_ALIGNED16',
                  }
 
+
 def isprivate(var):
     return 'attrspec' in var and 'private' in var['attrspec']
 
+
 def hasinitvalue(var):
     return '=' in var
 
+
 def hasinitvalueasstring(var):
     if not hasinitvalue(var):
         return 0
     return var['='][0] in ['"', "'"]
 
+
 def hasnote(var):
     return 'note' in var
 
+
 def hasresultnote(rout):
     if not isfunction(rout):
         return 0
     if 'result' in rout:
-        a=rout['result']
+        a = rout['result']
     else:
-        a=rout['name']
+        a = rout['name']
     if a in rout['vars']:
         return hasnote(rout['vars'][a])
     return 0
 
+
 def hascommon(rout):
     return 'common' in rout
 
+
 def containscommon(rout):
     if hascommon(rout):
         return 1
@@ -443,6 +521,7 @@ def containscommon(rout):
                 return 1
     return 0
 
+
 def containsmodule(block):
     if ismodule(block):
         return 1
@@ -453,97 +532,119 @@ def containsmodule(block):
             return 1
     return 0
 
+
 def hasbody(rout):
     return 'body' in rout
 
+
 def hascallstatement(rout):
     return getcallstatement(rout) is not None
 
+
 def istrue(var):
     return 1
 
+
 def isfalse(var):
     return 0
 
+
 class F2PYError(Exception):
     pass
 
+
 class throw_error:
+
     def __init__(self, mess):
         self.mess = mess
+
     def __call__(self, var):
         mess = '\n\n  var = %s\n  Message: %s\n' % (var, self.mess)
         raise F2PYError(mess)
 
+
 def l_and(*f):
-    l, l2='lambda v', []
+    l, l2 = 'lambda v', []
     for i in range(len(f)):
-        l='%s,f%d=f[%d]'%(l, i, i)
-        l2.append('f%d(v)'%(i))
-    return eval('%s:%s'%(l, ' and '.join(l2)))
+        l = '%s,f%d=f[%d]' % (l, i, i)
+        l2.append('f%d(v)' % (i))
+    return eval('%s:%s' % (l, ' and '.join(l2)))
+
 
 def l_or(*f):
-    l, l2='lambda v', []
+    l, l2 = 'lambda v', []
     for i in range(len(f)):
-        l='%s,f%d=f[%d]'%(l, i, i)
-        l2.append('f%d(v)'%(i))
-    return eval('%s:%s'%(l, ' or '.join(l2)))
+        l = '%s,f%d=f[%d]' % (l, i, i)
+        l2.append('f%d(v)' % (i))
+    return eval('%s:%s' % (l, ' or '.join(l2)))
+
 
 def l_not(f):
     return eval('lambda v,f=f:not f(v)')
 
+
 def isdummyroutine(rout):
     try:
-        return rout['f2pyenhancements']['fortranname']==''
+        return rout['f2pyenhancements']['fortranname'] == ''
     except KeyError:
         return 0
 
+
 def getfortranname(rout):
     try:
         name = rout['f2pyenhancements']['fortranname']
-        if name=='':
+        if name == '':
             raise KeyError
         if not name:
-            errmess('Failed to use fortranname from %s\n'%(rout['f2pyenhancements']))
+            errmess('Failed to use fortranname from %s\n' %
+                    (rout['f2pyenhancements']))
             raise KeyError
     except KeyError:
         name = rout['name']
     return name
 
-def getmultilineblock(rout,blockname,comment=1,counter=0):
+
+def getmultilineblock(rout, blockname, comment=1, counter=0):
     try:
         r = rout['f2pyenhancements'].get(blockname)
     except KeyError:
         return
-    if not r: return
+    if not r:
+        return
     if counter > 0 and isinstance(r, str):
         return
     if isinstance(r, list):
-        if counter>=len(r): return
+        if counter >= len(r):
+            return
         r = r[counter]
-    if r[:3]=="'''":
+    if r[:3] == "'''":
         if comment:
-            r = '\t/* start ' + blockname + ' multiline ('+repr(counter)+') */\n' + r[3:]
+            r = '\t/* start ' + blockname + \
+                ' multiline (' + repr(counter) + ') */\n' + r[3:]
         else:
             r = r[3:]
-        if r[-3:]=="'''":
+        if r[-3:] == "'''":
             if comment:
-                r = r[:-3] + '\n\t/* end multiline ('+repr(counter)+')*/'
+                r = r[:-3] + '\n\t/* end multiline (' + repr(counter) + ')*/'
             else:
                 r = r[:-3]
         else:
-            errmess("%s multiline block should end with `'''`: %s\n" \
+            errmess("%s multiline block should end with `'''`: %s\n"
                     % (blockname, repr(r)))
     return r
 
+
 def getcallstatement(rout):
     return getmultilineblock(rout, 'callstatement')
 
-def getcallprotoargument(rout,cb_map={}):
+
+def getcallprotoargument(rout, cb_map={}):
     r = getmultilineblock(rout, 'callprotoargument', comment=0)
-    if r: return r
+    if r:
+        return r
     if hascallstatement(rout):
-        outmess('warning: callstatement is defined without callprotoargument\n')
+        outmess(
+            'warning: callstatement is defined without callprotoargument\n')
         return
     from .capi_maps import getctype
     arg_types, arg_types2 = [], []
@@ -554,7 +655,7 @@ def getcallprotoargument(rout,cb_map={}):
         if isintent_callback(var):
             continue
         if n in cb_map:
-            ctype = cb_map[n]+'_typedef'
+            ctype = cb_map[n] + '_typedef'
         else:
             ctype = getctype(var)
             if l_and(isintent_c, l_or(isscalar, iscomplex))(var):
@@ -563,174 +664,194 @@ def getcallprotoargument(rout,cb_map={}):
                 pass
                 #ctype = 'void*'
             else:
-                ctype = ctype+'*'
+                ctype = ctype + '*'
             if isstring(var) or isarrayofstrings(var):
                 arg_types2.append('size_t')
         arg_types.append(ctype)
 
-    proto_args = ','.join(arg_types+arg_types2)
+    proto_args = ','.join(arg_types + arg_types2)
     if not proto_args:
         proto_args = 'void'
-    #print proto_args
+    # print proto_args
     return proto_args
 
+
 def getusercode(rout):
     return getmultilineblock(rout, 'usercode')
 
+
 def getusercode1(rout):
     return getmultilineblock(rout, 'usercode', counter=1)
 
+
 def getpymethoddef(rout):
     return getmultilineblock(rout, 'pymethoddef')
 
+
 def getargs(rout):
-    sortargs, args=[], []
+    sortargs, args = [], []
     if 'args' in rout:
-        args=rout['args']
+        args = rout['args']
         if 'sortvars' in rout:
             for a in rout['sortvars']:
-                if a in args: sortargs.append(a)
+                if a in args:
+                    sortargs.append(a)
             for a in args:
                 if a not in sortargs:
                     sortargs.append(a)
-        else: sortargs=rout['args']
+        else:
+            sortargs = rout['args']
     return args, sortargs
 
+
 def getargs2(rout):
-    sortargs, args=[], rout.get('args', [])
-    auxvars = [a for a in rout['vars'].keys() if isintent_aux(rout['vars'][a])\
+    sortargs, args = [], rout.get('args', [])
+    auxvars = [a for a in rout['vars'].keys() if isintent_aux(rout['vars'][a])
                and a not in args]
     args = auxvars + args
     if 'sortvars' in rout:
         for a in rout['sortvars']:
-            if a in args: sortargs.append(a)
+            if a in args:
+                sortargs.append(a)
         for a in args:
             if a not in sortargs:
                 sortargs.append(a)
-    else: sortargs=auxvars + rout['args']
+    else:
+        sortargs = auxvars + rout['args']
     return args, sortargs
 
+
 def getrestdoc(rout):
     if 'f2pymultilines' not in rout:
         return None
     k = None
-    if rout['block']=='python module':
+    if rout['block'] == 'python module':
         k = rout['block'], rout['name']
     return rout['f2pymultilines'].get(k, None)
 
+
 def gentitle(name):
-    l=(80-len(name)-6)//2
-    return '/*%s %s %s*/'%(l*'*', name, l*'*')
+    l = (80 - len(name) - 6) // 2
+    return '/*%s %s %s*/' % (l * '*', name, l * '*')
+
 
 def flatlist(l):
     if isinstance(l, list):
-        return reduce(lambda x,y,f=flatlist:x+f(y), l, [])
+        return reduce(lambda x, y, f=flatlist: x + f(y), l, [])
     return [l]
 
+
 def stripcomma(s):
-    if s and s[-1]==',': return s[:-1]
+    if s and s[-1] == ',':
+        return s[:-1]
     return s
 
-def replace(str,d,defaultsep=''):
+
+def replace(str, d, defaultsep=''):
     if isinstance(d, list):
         return [replace(str, _m, defaultsep) for _m in d]
     if isinstance(str, list):
         return [replace(_m, d, defaultsep) for _m in str]
-    for k in 2*list(d.keys()):
-        if k=='separatorsfor':
+    for k in 2 * list(d.keys()):
+        if k == 'separatorsfor':
             continue
         if 'separatorsfor' in d and k in d['separatorsfor']:
-            sep=d['separatorsfor'][k]
+            sep = d['separatorsfor'][k]
         else:
-            sep=defaultsep
+            sep = defaultsep
         if isinstance(d[k], list):
-            str=str.replace('#%s#'%(k), sep.join(flatlist(d[k])))
+            str = str.replace('#%s#' % (k), sep.join(flatlist(d[k])))
         else:
-            str=str.replace('#%s#'%(k), d[k])
+            str = str.replace('#%s#' % (k), d[k])
     return str
 
+
 def dictappend(rd, ar):
     if isinstance(ar, list):
         for a in ar:
-            rd=dictappend(rd, a)
+            rd = dictappend(rd, a)
         return rd
     for k in ar.keys():
-        if k[0]=='_':
+        if k[0] == '_':
             continue
         if k in rd:
             if isinstance(rd[k], str):
-                rd[k]=[rd[k]]
+                rd[k] = [rd[k]]
             if isinstance(rd[k], list):
                 if isinstance(ar[k], list):
-                    rd[k]=rd[k]+ar[k]
+                    rd[k] = rd[k] + ar[k]
                 else:
                     rd[k].append(ar[k])
             elif isinstance(rd[k], dict):
                 if isinstance(ar[k], dict):
-                    if k=='separatorsfor':
+                    if k == 'separatorsfor':
                         for k1 in ar[k].keys():
                             if k1 not in rd[k]:
-                                rd[k][k1]=ar[k][k1]
+                                rd[k][k1] = ar[k][k1]
                     else:
-                        rd[k]=dictappend(rd[k], ar[k])
+                        rd[k] = dictappend(rd[k], ar[k])
         else:
-            rd[k]=ar[k]
+            rd[k] = ar[k]
     return rd
 
-def applyrules(rules,d,var={}):
-    ret={}
+
+def applyrules(rules, d, var={}):
+    ret = {}
     if isinstance(rules, list):
         for r in rules:
-            rr=applyrules(r, d, var)
-            ret=dictappend(ret, rr)
+            rr = applyrules(r, d, var)
+            ret = dictappend(ret, rr)
             if '_break' in rr:
                 break
         return ret
     if '_check' in rules and (not rules['_check'](var)):
         return ret
     if 'need' in rules:
-        res = applyrules({'needs':rules['need']}, d, var)
+        res = applyrules({'needs': rules['need']}, d, var)
         if 'needs' in res:
             cfuncs.append_needs(res['needs'])
 
     for k in rules.keys():
-        if k=='separatorsfor':
-            ret[k]=rules[k]; continue
+        if k == 'separatorsfor':
+            ret[k] = rules[k]
+            continue
         if isinstance(rules[k], str):
-            ret[k]=replace(rules[k], d)
+            ret[k] = replace(rules[k], d)
         elif isinstance(rules[k], list):
-            ret[k]=[]
+            ret[k] = []
             for i in rules[k]:
-                ar=applyrules({k:i}, d, var)
+                ar = applyrules({k: i}, d, var)
                 if k in ar:
                     ret[k].append(ar[k])
-        elif k[0]=='_':
+        elif k[0] == '_':
             continue
         elif isinstance(rules[k], dict):
-            ret[k]=[]
+            ret[k] = []
             for k1 in rules[k].keys():
                 if isinstance(k1, types.FunctionType) and k1(var):
                     if isinstance(rules[k][k1], list):
                         for i in rules[k][k1]:
                             if isinstance(i, dict):
-                                res=applyrules({'supertext':i}, d, var)
+                                res = applyrules({'supertext': i}, d, var)
                                 if 'supertext' in res:
-                                    i=res['supertext']
-                                else: i=''
+                                    i = res['supertext']
+                                else:
+                                    i = ''
                             ret[k].append(replace(i, d))
                     else:
-                        i=rules[k][k1]
+                        i = rules[k][k1]
                         if isinstance(i, dict):
-                            res=applyrules({'supertext':i}, d)
+                            res = applyrules({'supertext': i}, d)
                             if 'supertext' in res:
-                                i=res['supertext']
-                            else: i=''
+                                i = res['supertext']
+                            else:
+                                i = ''
                         ret[k].append(replace(i, d))
         else:
-            errmess('applyrules: ignoring rule %s.\n'%repr(rules[k]))
+            errmess('applyrules: ignoring rule %s.\n' % repr(rules[k]))
         if isinstance(ret[k], list):
-            if len(ret[k])==1:
-                ret[k]=ret[k][0]
-            if ret[k]==[]:
+            if len(ret[k]) == 1:
+                ret[k] = ret[k][0]
+            if ret[k] == []:
                 del ret[k]
     return ret
diff --git a/numpy/f2py/capi_maps.py b/numpy/f2py/capi_maps.py
index ce7c0d90e..f6bb1b7dd 100644
--- a/numpy/f2py/capi_maps.py
+++ b/numpy/f2py/capi_maps.py
@@ -46,142 +46,144 @@ __all__ = [
 # Numarray and Numeric users should set this False
 using_newcore = True
 
-depargs=[]
-lcb_map={}
-lcb2_map={}
+depargs = []
+lcb_map = {}
+lcb2_map = {}
 # forced casting: mainly caused by the fact that Python or Numeric
 #                 C/APIs do not support the corresponding C types.
-c2py_map={'double': 'float',
-          'float': 'float',                          # forced casting
-          'long_double': 'float',                    # forced casting
-          'char': 'int',                             # forced casting
-          'signed_char': 'int',                      # forced casting
-          'unsigned_char': 'int',                    # forced casting
-          'short': 'int',                            # forced casting
-          'unsigned_short': 'int',                   # forced casting
-          'int': 'int',                              # (forced casting)
-          'long': 'int',
-          'long_long': 'long',
-          'unsigned': 'int',                         # forced casting
-          'complex_float': 'complex',                # forced casting
-          'complex_double': 'complex',
-          'complex_long_double': 'complex',          # forced casting
-          'string': 'string',
-          }
-c2capi_map={'double':'NPY_DOUBLE',
-            'float':'NPY_FLOAT',
-            'long_double':'NPY_DOUBLE',           # forced casting
-            'char':'NPY_CHAR',
-            'unsigned_char':'NPY_UBYTE',
-            'signed_char':'NPY_BYTE',
-            'short':'NPY_SHORT',
-            'unsigned_short':'NPY_USHORT',
-            'int':'NPY_INT',
-            'unsigned':'NPY_UINT',
-            'long':'NPY_LONG',
-            'long_long':'NPY_LONG',                # forced casting
-            'complex_float':'NPY_CFLOAT',
-            'complex_double':'NPY_CDOUBLE',
-            'complex_long_double':'NPY_CDOUBLE',   # forced casting
-            'string':'NPY_CHAR'}
-
-#These new maps aren't used anyhere yet, but should be by default
+c2py_map = {'double': 'float',
+            'float': 'float',                          # forced casting
+            'long_double': 'float',                    # forced casting
+            'char': 'int',                             # forced casting
+            'signed_char': 'int',                      # forced casting
+            'unsigned_char': 'int',                    # forced casting
+            'short': 'int',                            # forced casting
+            'unsigned_short': 'int',                   # forced casting
+            'int': 'int',                              # (forced casting)
+            'long': 'int',
+            'long_long': 'long',
+            'unsigned': 'int',                         # forced casting
+            'complex_float': 'complex',                # forced casting
+            'complex_double': 'complex',
+            'complex_long_double': 'complex',          # forced casting
+            'string': 'string',
+            }
+c2capi_map = {'double': 'NPY_DOUBLE',
+              'float': 'NPY_FLOAT',
+              'long_double': 'NPY_DOUBLE',           # forced casting
+              'char': 'NPY_CHAR',
+              'unsigned_char': 'NPY_UBYTE',
+              'signed_char': 'NPY_BYTE',
+              'short': 'NPY_SHORT',
+              'unsigned_short': 'NPY_USHORT',
+              'int': 'NPY_INT',
+              'unsigned': 'NPY_UINT',
+              'long': 'NPY_LONG',
+              'long_long': 'NPY_LONG',                # forced casting
+              'complex_float': 'NPY_CFLOAT',
+              'complex_double': 'NPY_CDOUBLE',
+              'complex_long_double': 'NPY_CDOUBLE',   # forced casting
+              'string': 'NPY_CHAR'}
+
+# These new maps aren't used anyhere yet, but should be by default
 #  unless building numeric or numarray extensions.
 if using_newcore:
-    c2capi_map={'double': 'NPY_DOUBLE',
-            'float': 'NPY_FLOAT',
-            'long_double': 'NPY_LONGDOUBLE',
-            'char': 'NPY_BYTE',
-            'unsigned_char': 'NPY_UBYTE',
-            'signed_char': 'NPY_BYTE',
-            'short': 'NPY_SHORT',
-            'unsigned_short': 'NPY_USHORT',
-            'int': 'NPY_INT',
-            'unsigned': 'NPY_UINT',
-            'long': 'NPY_LONG',
-            'unsigned_long': 'NPY_ULONG',
-            'long_long': 'NPY_LONGLONG',
-            'unsigned_long_long': 'NPY_ULONGLONG',
-            'complex_float': 'NPY_CFLOAT',
-            'complex_double': 'NPY_CDOUBLE',
-            'complex_long_double': 'NPY_CDOUBLE',
-            'string': 'NPY_CHAR', # f2py 2e is not ready for NPY_STRING (must set itemisize etc)
-            #'string':'NPY_STRING'
-
+    c2capi_map = {'double': 'NPY_DOUBLE',
+                  'float': 'NPY_FLOAT',
+                  'long_double': 'NPY_LONGDOUBLE',
+                  'char': 'NPY_BYTE',
+                  'unsigned_char': 'NPY_UBYTE',
+                  'signed_char': 'NPY_BYTE',
+                  'short': 'NPY_SHORT',
+                  'unsigned_short': 'NPY_USHORT',
+                  'int': 'NPY_INT',
+                  'unsigned': 'NPY_UINT',
+                  'long': 'NPY_LONG',
+                  'unsigned_long': 'NPY_ULONG',
+                  'long_long': 'NPY_LONGLONG',
+                  'unsigned_long_long': 'NPY_ULONGLONG',
+                  'complex_float': 'NPY_CFLOAT',
+                  'complex_double': 'NPY_CDOUBLE',
+                  'complex_long_double': 'NPY_CDOUBLE',
+                  # f2py 2e is not ready for NPY_STRING (must set itemisize
+                  # etc)
+                  'string': 'NPY_CHAR',
+                  #'string':'NPY_STRING'
+
+                  }
+c2pycode_map = {'double': 'd',
+                'float': 'f',
+                'long_double': 'd',                       # forced casting
+                'char': '1',
+                'signed_char': '1',
+                'unsigned_char': 'b',
+                'short': 's',
+                'unsigned_short': 'w',
+                'int': 'i',
+                'unsigned': 'u',
+                'long': 'l',
+                'long_long': 'L',
+                'complex_float': 'F',
+                'complex_double': 'D',
+                'complex_long_double': 'D',               # forced casting
+                'string': 'c'
                 }
-c2pycode_map={'double':'d',
-              'float':'f',
-              'long_double':'d',                       # forced casting
-              'char':'1',
-              'signed_char':'1',
-              'unsigned_char':'b',
-              'short':'s',
-              'unsigned_short':'w',
-              'int':'i',
-              'unsigned':'u',
-              'long':'l',
-              'long_long':'L',
-              'complex_float':'F',
-              'complex_double':'D',
-              'complex_long_double':'D',               # forced casting
-              'string':'c'
-              }
 if using_newcore:
-    c2pycode_map={'double':'d',
-                 'float':'f',
-                 'long_double':'g',
-                 'char':'b',
-                 'unsigned_char':'B',
-                 'signed_char':'b',
-                 'short':'h',
-                 'unsigned_short':'H',
-                 'int':'i',
-                 'unsigned':'I',
-                 'long':'l',
-                 'unsigned_long':'L',
-                 'long_long':'q',
-                 'unsigned_long_long':'Q',
-                 'complex_float':'F',
-                 'complex_double':'D',
-                 'complex_long_double':'G',
-                 'string':'S'}
-c2buildvalue_map={'double':'d',
-                  'float':'f',
-                  'char':'b',
-                  'signed_char':'b',
-                  'short':'h',
-                  'int':'i',
-                  'long':'l',
-                  'long_long':'L',
-                  'complex_float':'N',
-                  'complex_double':'N',
-                  'complex_long_double':'N',
-                  'string':'z'}
+    c2pycode_map = {'double': 'd',
+                    'float': 'f',
+                    'long_double': 'g',
+                    'char': 'b',
+                    'unsigned_char': 'B',
+                    'signed_char': 'b',
+                    'short': 'h',
+                    'unsigned_short': 'H',
+                    'int': 'i',
+                    'unsigned': 'I',
+                    'long': 'l',
+                    'unsigned_long': 'L',
+                    'long_long': 'q',
+                    'unsigned_long_long': 'Q',
+                    'complex_float': 'F',
+                    'complex_double': 'D',
+                    'complex_long_double': 'G',
+                    'string': 'S'}
+c2buildvalue_map = {'double': 'd',
+                    'float': 'f',
+                    'char': 'b',
+                    'signed_char': 'b',
+                    'short': 'h',
+                    'int': 'i',
+                    'long': 'l',
+                    'long_long': 'L',
+                    'complex_float': 'N',
+                    'complex_double': 'N',
+                    'complex_long_double': 'N',
+                    'string': 'z'}
 
 if sys.version_info[0] >= 3:
     # Bytes, not Unicode strings
     c2buildvalue_map['string'] = 'y'
 
 if using_newcore:
-    #c2buildvalue_map=???
+    # c2buildvalue_map=???
     pass
 
-f2cmap_all={'real':{'':'float','4':'float','8':'double','12':'long_double','16':'long_double'},
-            'integer':{'':'int','1':'signed_char','2':'short','4':'int','8':'long_long',
-                       '-1':'unsigned_char','-2':'unsigned_short','-4':'unsigned',
-                       '-8':'unsigned_long_long'},
-            'complex':{'':'complex_float','8':'complex_float',
-                       '16':'complex_double','24':'complex_long_double',
-                       '32':'complex_long_double'},
-            'complexkind':{'':'complex_float','4':'complex_float',
-                           '8':'complex_double','12':'complex_long_double',
-                           '16':'complex_long_double'},
-            'logical':{'':'int','1':'char','2':'short','4':'int','8':'long_long'},
-            'double complex':{'':'complex_double'},
-            'double precision':{'':'double'},
-            'byte':{'':'char'},
-            'character':{'':'string'}
-            }
+f2cmap_all = {'real': {'': 'float', '4': 'float', '8': 'double', '12': 'long_double', '16': 'long_double'},
+              'integer': {'': 'int', '1': 'signed_char', '2': 'short', '4': 'int', '8': 'long_long',
+                          '-1': 'unsigned_char', '-2': 'unsigned_short', '-4': 'unsigned',
+                          '-8': 'unsigned_long_long'},
+              'complex': {'': 'complex_float', '8': 'complex_float',
+                          '16': 'complex_double', '24': 'complex_long_double',
+                          '32': 'complex_long_double'},
+              'complexkind': {'': 'complex_float', '4': 'complex_float',
+                              '8': 'complex_double', '12': 'complex_long_double',
+                              '16': 'complex_long_double'},
+              'logical': {'': 'int', '1': 'char', '2': 'short', '4': 'int', '8': 'long_long'},
+              'double complex': {'': 'complex_double'},
+              'double precision': {'': 'double'},
+              'byte': {'': 'char'},
+              'character': {'': 'string'}
+              }
 
 if os.path.isfile('.f2py_f2cmap'):
     # User defined additions to f2cmap_all.
@@ -201,271 +203,313 @@ if os.path.isfile('.f2py_f2cmap'):
             d[k.lower()] = d[k]
         for k in list(d.keys()):
             if k not in f2cmap_all:
-                f2cmap_all[k]={}
+                f2cmap_all[k] = {}
             for k1 in list(d[k].keys()):
                 if d[k][k1] in c2py_map:
                     if k1 in f2cmap_all[k]:
-                        outmess("\tWarning: redefinition of {'%s':{'%s':'%s'->'%s'}}\n"%(k, k1, f2cmap_all[k][k1], d[k][k1]))
+                        outmess(
+                            "\tWarning: redefinition of {'%s':{'%s':'%s'->'%s'}}\n" % (k, k1, f2cmap_all[k][k1], d[k][k1]))
                     f2cmap_all[k][k1] = d[k][k1]
-                    outmess('\tMapping "%s(kind=%s)" to "%s"\n' % (k, k1, d[k][k1]))
+                    outmess('\tMapping "%s(kind=%s)" to "%s"\n' %
+                            (k, k1, d[k][k1]))
                 else:
-                    errmess("\tIgnoring map {'%s':{'%s':'%s'}}: '%s' must be in %s\n"%(k, k1, d[k][k1], d[k][k1], list(c2py_map.keys())))
+                    errmess("\tIgnoring map {'%s':{'%s':'%s'}}: '%s' must be in %s\n" % (
+                        k, k1, d[k][k1], d[k][k1], list(c2py_map.keys())))
         outmess('Succesfully applied user defined changes from .f2py_f2cmap\n')
     except Exception as msg:
-        errmess('Failed to apply user defined changes from .f2py_f2cmap: %s. Skipping.\n' % (msg))
-cformat_map={'double': '%g',
-             'float': '%g',
-             'long_double': '%Lg',
-             'char': '%d',
-             'signed_char': '%d',
-             'unsigned_char': '%hhu',
-             'short': '%hd',
-             'unsigned_short': '%hu',
-             'int': '%d',
-             'unsigned': '%u',
-             'long': '%ld',
-             'unsigned_long': '%lu',
-             'long_long': '%ld',
-             'complex_float': '(%g,%g)',
-             'complex_double': '(%g,%g)',
-             'complex_long_double': '(%Lg,%Lg)',
-             'string': '%s',
-             }
-
-############### Auxiliary functions
+        errmess(
+            'Failed to apply user defined changes from .f2py_f2cmap: %s. Skipping.\n' % (msg))
+cformat_map = {'double': '%g',
+               'float': '%g',
+               'long_double': '%Lg',
+               'char': '%d',
+               'signed_char': '%d',
+               'unsigned_char': '%hhu',
+               'short': '%hd',
+               'unsigned_short': '%hu',
+               'int': '%d',
+               'unsigned': '%u',
+               'long': '%ld',
+               'unsigned_long': '%lu',
+               'long_long': '%ld',
+               'complex_float': '(%g,%g)',
+               'complex_double': '(%g,%g)',
+               'complex_long_double': '(%Lg,%Lg)',
+               'string': '%s',
+               }
+
+# Auxiliary functions
+
+
 def getctype(var):
     """
     Determines C type
     """
-    ctype='void'
+    ctype = 'void'
     if isfunction(var):
         if 'result' in var:
-            a=var['result']
+            a = var['result']
         else:
-            a=var['name']
+            a = var['name']
         if a in var['vars']:
             return getctype(var['vars'][a])
         else:
-            errmess('getctype: function %s has no return value?!\n'%a)
+            errmess('getctype: function %s has no return value?!\n' % a)
     elif issubroutine(var):
         return ctype
     elif 'typespec' in var and var['typespec'].lower() in f2cmap_all:
         typespec = var['typespec'].lower()
-        f2cmap=f2cmap_all[typespec]
-        ctype=f2cmap[''] # default type
+        f2cmap = f2cmap_all[typespec]
+        ctype = f2cmap['']  # default type
         if 'kindselector' in var:
             if '*' in var['kindselector']:
                 try:
-                    ctype=f2cmap[var['kindselector']['*']]
+                    ctype = f2cmap[var['kindselector']['*']]
                 except KeyError:
-                    errmess('getctype: "%s %s %s" not supported.\n'%(var['typespec'], '*', var['kindselector']['*']))
+                    errmess('getctype: "%s %s %s" not supported.\n' %
+                            (var['typespec'], '*', var['kindselector']['*']))
             elif 'kind' in var['kindselector']:
-                if typespec+'kind' in f2cmap_all:
-                    f2cmap=f2cmap_all[typespec+'kind']
+                if typespec + 'kind' in f2cmap_all:
+                    f2cmap = f2cmap_all[typespec + 'kind']
                 try:
-                    ctype=f2cmap[var['kindselector']['kind']]
+                    ctype = f2cmap[var['kindselector']['kind']]
                 except KeyError:
                     if typespec in f2cmap_all:
-                        f2cmap=f2cmap_all[typespec]
+                        f2cmap = f2cmap_all[typespec]
                     try:
-                        ctype=f2cmap[str(var['kindselector']['kind'])]
+                        ctype = f2cmap[str(var['kindselector']['kind'])]
                     except KeyError:
-                        errmess('getctype: "%s(kind=%s)" is mapped to C "%s" (to override define dict(%s = dict(%s="<C typespec>")) in %s/.f2py_f2cmap file).\n'\
-                                %(typespec, var['kindselector']['kind'], ctype,
-                                  typespec, var['kindselector']['kind'], os.getcwd()))
+                        errmess('getctype: "%s(kind=%s)" is mapped to C "%s" (to override define dict(%s = dict(%s="<C typespec>")) in %s/.f2py_f2cmap file).\n'
+                                % (typespec, var['kindselector']['kind'], ctype,
+                                   typespec, var['kindselector']['kind'], os.getcwd()))
 
     else:
         if not isexternal(var):
-            errmess('getctype: No C-type found in "%s", assuming void.\n'%var)
+            errmess(
+                'getctype: No C-type found in "%s", assuming void.\n' % var)
     return ctype
 
+
 def getstrlength(var):
     if isstringfunction(var):
         if 'result' in var:
-            a=var['result']
+            a = var['result']
         else:
-            a=var['name']
+            a = var['name']
         if a in var['vars']:
             return getstrlength(var['vars'][a])
         else:
-            errmess('getstrlength: function %s has no return value?!\n'%a)
+            errmess('getstrlength: function %s has no return value?!\n' % a)
     if not isstring(var):
-        errmess('getstrlength: expected a signature of a string but got: %s\n'%(repr(var)))
-    len='1'
+        errmess(
+            'getstrlength: expected a signature of a string but got: %s\n' % (repr(var)))
+    len = '1'
     if 'charselector' in var:
-        a=var['charselector']
+        a = var['charselector']
         if '*' in a:
-            len=a['*']
+            len = a['*']
         elif 'len' in a:
-            len=a['len']
+            len = a['len']
     if re.match(r'\(\s*([*]|[:])\s*\)', len) or re.match(r'([*]|[:])', len):
-    #if len in ['(*)','*','(:)',':']:
+        # if len in ['(*)','*','(:)',':']:
         if isintent_hide(var):
-            errmess('getstrlength:intent(hide): expected a string with defined length but got: %s\n'%(repr(var)))
-        len='-1'
+            errmess('getstrlength:intent(hide): expected a string with defined length but got: %s\n' % (
+                repr(var)))
+        len = '-1'
     return len
 
-def getarrdims(a,var,verbose=0):
+
+def getarrdims(a, var, verbose=0):
     global depargs
-    ret={}
+    ret = {}
     if isstring(var) and not isarray(var):
-        ret['dims']=getstrlength(var)
-        ret['size']=ret['dims']
-        ret['rank']='1'
+        ret['dims'] = getstrlength(var)
+        ret['size'] = ret['dims']
+        ret['rank'] = '1'
     elif isscalar(var):
-        ret['size']='1'
-        ret['rank']='0'
-        ret['dims']=''
+        ret['size'] = '1'
+        ret['rank'] = '0'
+        ret['dims'] = ''
     elif isarray(var):
-#         if not isintent_c(var):
-#             var['dimension'].reverse()
-        dim=copy.copy(var['dimension'])
-        ret['size']='*'.join(dim)
-        try: ret['size']=repr(eval(ret['size']))
-        except: pass
-        ret['dims']=','.join(dim)
-        ret['rank']=repr(len(dim))
-        ret['rank*[-1]']=repr(len(dim)*[-1])[1:-1]
-        for i in range(len(dim)): # solve dim for dependecies
-            v=[]
-            if dim[i] in depargs: v=[dim[i]]
+        #         if not isintent_c(var):
+        #             var['dimension'].reverse()
+        dim = copy.copy(var['dimension'])
+        ret['size'] = '*'.join(dim)
+        try:
+            ret['size'] = repr(eval(ret['size']))
+        except:
+            pass
+        ret['dims'] = ','.join(dim)
+        ret['rank'] = repr(len(dim))
+        ret['rank*[-1]'] = repr(len(dim) * [-1])[1:-1]
+        for i in range(len(dim)):  # solve dim for dependecies
+            v = []
+            if dim[i] in depargs:
+                v = [dim[i]]
             else:
                 for va in depargs:
-                    if re.match(r'.*?\b%s\b.*'%va, dim[i]):
+                    if re.match(r'.*?\b%s\b.*' % va, dim[i]):
                         v.append(va)
             for va in v:
-                if depargs.index(va)>depargs.index(a):
-                    dim[i]='*'
+                if depargs.index(va) > depargs.index(a):
+                    dim[i] = '*'
                     break
-        ret['setdims'], i='', -1
+        ret['setdims'], i = '', -1
         for d in dim:
-            i=i+1
+            i = i + 1
             if d not in ['*', ':', '(*)', '(:)']:
-                ret['setdims']='%s#varname#_Dims[%d]=%s,'%(ret['setdims'], i, d)
-        if ret['setdims']: ret['setdims']=ret['setdims'][:-1]
-        ret['cbsetdims'], i='', -1
+                ret['setdims'] = '%s#varname#_Dims[%d]=%s,' % (
+                    ret['setdims'], i, d)
+        if ret['setdims']:
+            ret['setdims'] = ret['setdims'][:-1]
+        ret['cbsetdims'], i = '', -1
         for d in var['dimension']:
-            i=i+1
+            i = i + 1
             if d not in ['*', ':', '(*)', '(:)']:
-                ret['cbsetdims']='%s#varname#_Dims[%d]=%s,'%(ret['cbsetdims'], i, d)
+                ret['cbsetdims'] = '%s#varname#_Dims[%d]=%s,' % (
+                    ret['cbsetdims'], i, d)
             elif isintent_in(var):
-                outmess('getarrdims:warning: assumed shape array, using 0 instead of %r\n' \
+                outmess('getarrdims:warning: assumed shape array, using 0 instead of %r\n'
                         % (d))
-                ret['cbsetdims']='%s#varname#_Dims[%d]=%s,'%(ret['cbsetdims'], i, 0)
-            elif verbose :
-                errmess('getarrdims: If in call-back function: array argument %s must have bounded dimensions: got %s\n'%(repr(a), repr(d)))
-        if ret['cbsetdims']: ret['cbsetdims']=ret['cbsetdims'][:-1]
+                ret['cbsetdims'] = '%s#varname#_Dims[%d]=%s,' % (
+                    ret['cbsetdims'], i, 0)
+            elif verbose:
+                errmess(
+                    'getarrdims: If in call-back function: array argument %s must have bounded dimensions: got %s\n' % (repr(a), repr(d)))
+        if ret['cbsetdims']:
+            ret['cbsetdims'] = ret['cbsetdims'][:-1]
 #         if not isintent_c(var):
 #             var['dimension'].reverse()
     return ret
 
+
 def getpydocsign(a, var):
     global lcb_map
     if isfunction(var):
         if 'result' in var:
-            af=var['result']
+            af = var['result']
         else:
-            af=var['name']
+            af = var['name']
         if af in var['vars']:
             return getpydocsign(af, var['vars'][af])
         else:
-            errmess('getctype: function %s has no return value?!\n'%af)
+            errmess('getctype: function %s has no return value?!\n' % af)
         return '', ''
-    sig, sigout=a, a
-    opt=''
-    if isintent_in(var): opt='input'
-    elif isintent_inout(var): opt='in/output'
+    sig, sigout = a, a
+    opt = ''
+    if isintent_in(var):
+        opt = 'input'
+    elif isintent_inout(var):
+        opt = 'in/output'
     out_a = a
     if isintent_out(var):
         for k in var['intent']:
-            if k[:4]=='out=':
+            if k[:4] == 'out=':
                 out_a = k[4:]
                 break
-    init=''
-    ctype=getctype(var)
+    init = ''
+    ctype = getctype(var)
 
     if hasinitvalue(var):
-        init, showinit=getinit(a, var)
+        init, showinit = getinit(a, var)
         init = ', optional\\n    Default: %s' % showinit
     if isscalar(var):
         if isintent_inout(var):
-            sig='%s : %s rank-0 array(%s,\'%s\')%s'%(a, opt, c2py_map[ctype],
-                              c2pycode_map[ctype], init)
+            sig = '%s : %s rank-0 array(%s,\'%s\')%s' % (a, opt, c2py_map[ctype],
+                                                         c2pycode_map[ctype], init)
         else:
-            sig='%s : %s %s%s'%(a, opt, c2py_map[ctype], init)
-        sigout='%s : %s'%(out_a, c2py_map[ctype])
+            sig = '%s : %s %s%s' % (a, opt, c2py_map[ctype], init)
+        sigout = '%s : %s' % (out_a, c2py_map[ctype])
     elif isstring(var):
         if isintent_inout(var):
-            sig='%s : %s rank-0 array(string(len=%s),\'c\')%s'%(a, opt, getstrlength(var), init)
+            sig = '%s : %s rank-0 array(string(len=%s),\'c\')%s' % (
+                a, opt, getstrlength(var), init)
         else:
-            sig='%s : %s string(len=%s)%s'%(a, opt, getstrlength(var), init)
-        sigout='%s : string(len=%s)'%(out_a, getstrlength(var))
+            sig = '%s : %s string(len=%s)%s' % (
+                a, opt, getstrlength(var), init)
+        sigout = '%s : string(len=%s)' % (out_a, getstrlength(var))
     elif isarray(var):
-        dim=var['dimension']
-        rank=repr(len(dim))
-        sig='%s : %s rank-%s array(\'%s\') with bounds (%s)%s'%(a, opt, rank,
-                                             c2pycode_map[ctype],
-                                             ','.join(dim), init)
-        if a==out_a:
-            sigout='%s : rank-%s array(\'%s\') with bounds (%s)'\
-                    %(a, rank, c2pycode_map[ctype], ','.join(dim))
+        dim = var['dimension']
+        rank = repr(len(dim))
+        sig = '%s : %s rank-%s array(\'%s\') with bounds (%s)%s' % (a, opt, rank,
+                                                                    c2pycode_map[
+                                                                        ctype],
+                                                                    ','.join(dim), init)
+        if a == out_a:
+            sigout = '%s : rank-%s array(\'%s\') with bounds (%s)'\
+                % (a, rank, c2pycode_map[ctype], ','.join(dim))
         else:
-            sigout='%s : rank-%s array(\'%s\') with bounds (%s) and %s storage'\
-                    %(out_a, rank, c2pycode_map[ctype], ','.join(dim), a)
+            sigout = '%s : rank-%s array(\'%s\') with bounds (%s) and %s storage'\
+                % (out_a, rank, c2pycode_map[ctype], ','.join(dim), a)
     elif isexternal(var):
-        ua=''
+        ua = ''
         if a in lcb_map and lcb_map[a] in lcb2_map and 'argname' in lcb2_map[lcb_map[a]]:
-            ua=lcb2_map[lcb_map[a]]['argname']
-            if not ua==a: ua=' => %s'%ua
-            else: ua=''
-        sig='%s : call-back function%s'%(a, ua)
-        sigout=sig
+            ua = lcb2_map[lcb_map[a]]['argname']
+            if not ua == a:
+                ua = ' => %s' % ua
+            else:
+                ua = ''
+        sig = '%s : call-back function%s' % (a, ua)
+        sigout = sig
     else:
-        errmess('getpydocsign: Could not resolve docsignature for "%s".\\n'%a)
+        errmess(
+            'getpydocsign: Could not resolve docsignature for "%s".\\n' % a)
     return sig, sigout
 
+
 def getarrdocsign(a, var):
-    ctype=getctype(var)
+    ctype = getctype(var)
     if isstring(var) and (not isarray(var)):
-        sig='%s : rank-0 array(string(len=%s),\'c\')'%(a, getstrlength(var))
+        sig = '%s : rank-0 array(string(len=%s),\'c\')' % (a,
+                                                           getstrlength(var))
     elif isscalar(var):
-        sig='%s : rank-0 array(%s,\'%s\')'%(a, c2py_map[ctype],
-                                            c2pycode_map[ctype],)
+        sig = '%s : rank-0 array(%s,\'%s\')' % (a, c2py_map[ctype],
+                                                c2pycode_map[ctype],)
     elif isarray(var):
-        dim=var['dimension']
-        rank=repr(len(dim))
-        sig='%s : rank-%s array(\'%s\') with bounds (%s)'%(a, rank,
-                                                           c2pycode_map[ctype],
-                                                           ','.join(dim))
+        dim = var['dimension']
+        rank = repr(len(dim))
+        sig = '%s : rank-%s array(\'%s\') with bounds (%s)' % (a, rank,
+                                                               c2pycode_map[
+                                                                   ctype],
+                                                               ','.join(dim))
     return sig
 
+
 def getinit(a, var):
-    if isstring(var): init, showinit='""', "''"
-    else: init, showinit='', ''
+    if isstring(var):
+        init, showinit = '""', "''"
+    else:
+        init, showinit = '', ''
     if hasinitvalue(var):
-        init=var['=']
-        showinit=init
+        init = var['=']
+        showinit = init
         if iscomplex(var) or iscomplexarray(var):
-            ret={}
+            ret = {}
 
             try:
                 v = var["="]
                 if ',' in v:
-                    ret['init.r'], ret['init.i']=markoutercomma(v[1:-1]).split('@,@')
+                    ret['init.r'], ret['init.i'] = markoutercomma(
+                        v[1:-1]).split('@,@')
                 else:
                     v = eval(v, {}, {})
-                    ret['init.r'], ret['init.i']=str(v.real), str(v.imag)
+                    ret['init.r'], ret['init.i'] = str(v.real), str(v.imag)
             except:
-                raise ValueError('getinit: expected complex number `(r,i)\' but got `%s\' as initial value of %r.' % (init, a))
+                raise ValueError(
+                    'getinit: expected complex number `(r,i)\' but got `%s\' as initial value of %r.' % (init, a))
             if isarray(var):
-                init='(capi_c.r=%s,capi_c.i=%s,capi_c)'%(ret['init.r'], ret['init.i'])
+                init = '(capi_c.r=%s,capi_c.i=%s,capi_c)' % (
+                    ret['init.r'], ret['init.i'])
         elif isstring(var):
-            if not init: init, showinit='""', "''"
-            if init[0]=="'":
-                init='"%s"'%(init[1:-1].replace('"', '\\"'))
-            if init[0]=='"': showinit="'%s'"%(init[1:-1])
+            if not init:
+                init, showinit = '""', "''"
+            if init[0] == "'":
+                init = '"%s"' % (init[1:-1].replace('"', '\\"'))
+            if init[0] == '"':
+                showinit = "'%s'" % (init[1:-1])
     return init, showinit
 
+
 def sign2map(a, var):
     """
     varname,ctype,atype
@@ -478,93 +522,105 @@ def sign2map(a, var):
     out_a = a
     if isintent_out(var):
         for k in var['intent']:
-            if k[:4]=='out=':
+            if k[:4] == 'out=':
                 out_a = k[4:]
                 break
-    ret={'varname':a,'outvarname':out_a}
-    ret['ctype']=getctype(var)
+    ret = {'varname': a, 'outvarname': out_a}
+    ret['ctype'] = getctype(var)
     intent_flags = []
     for f, s in isintent_dict.items():
-        if f(var): intent_flags.append('F2PY_%s'%s)
+        if f(var):
+            intent_flags.append('F2PY_%s' % s)
     if intent_flags:
-        #XXX: Evaluate intent_flags here.
+        # XXX: Evaluate intent_flags here.
         ret['intent'] = '|'.join(intent_flags)
     else:
         ret['intent'] = 'F2PY_INTENT_IN'
-    if isarray(var): ret['varrformat']='N'
+    if isarray(var):
+        ret['varrformat'] = 'N'
     elif ret['ctype'] in c2buildvalue_map:
-        ret['varrformat']=c2buildvalue_map[ret['ctype']]
-    else: ret['varrformat']='O'
-    ret['init'], ret['showinit']=getinit(a, var)
+        ret['varrformat'] = c2buildvalue_map[ret['ctype']]
+    else:
+        ret['varrformat'] = 'O'
+    ret['init'], ret['showinit'] = getinit(a, var)
     if hasinitvalue(var) and iscomplex(var) and not isarray(var):
-        ret['init.r'], ret['init.i'] = markoutercomma(ret['init'][1:-1]).split('@,@')
+        ret['init.r'], ret['init.i'] = markoutercomma(
+            ret['init'][1:-1]).split('@,@')
     if isexternal(var):
-        ret['cbnamekey']=a
+        ret['cbnamekey'] = a
         if a in lcb_map:
-            ret['cbname']=lcb_map[a]
-            ret['maxnofargs']=lcb2_map[lcb_map[a]]['maxnofargs']
-            ret['nofoptargs']=lcb2_map[lcb_map[a]]['nofoptargs']
-            ret['cbdocstr']=lcb2_map[lcb_map[a]]['docstr']
-            ret['cblatexdocstr']=lcb2_map[lcb_map[a]]['latexdocstr']
+            ret['cbname'] = lcb_map[a]
+            ret['maxnofargs'] = lcb2_map[lcb_map[a]]['maxnofargs']
+            ret['nofoptargs'] = lcb2_map[lcb_map[a]]['nofoptargs']
+            ret['cbdocstr'] = lcb2_map[lcb_map[a]]['docstr']
+            ret['cblatexdocstr'] = lcb2_map[lcb_map[a]]['latexdocstr']
         else:
-            ret['cbname']=a
-            errmess('sign2map: Confused: external %s is not in lcb_map%s.\n'%(a, list(lcb_map.keys())))
+            ret['cbname'] = a
+            errmess('sign2map: Confused: external %s is not in lcb_map%s.\n' % (
+                a, list(lcb_map.keys())))
     if isstring(var):
-        ret['length']=getstrlength(var)
+        ret['length'] = getstrlength(var)
     if isarray(var):
-        ret=dictappend(ret, getarrdims(a, var))
-        dim=copy.copy(var['dimension'])
+        ret = dictappend(ret, getarrdims(a, var))
+        dim = copy.copy(var['dimension'])
     if ret['ctype'] in c2capi_map:
-        ret['atype']=c2capi_map[ret['ctype']]
+        ret['atype'] = c2capi_map[ret['ctype']]
     # Debug info
     if debugcapi(var):
-        il=[isintent_in, 'input', isintent_out, 'output',
-            isintent_inout, 'inoutput', isrequired, 'required',
-            isoptional, 'optional', isintent_hide, 'hidden',
-            iscomplex, 'complex scalar',
-            l_and(isscalar, l_not(iscomplex)), 'scalar',
-            isstring, 'string', isarray, 'array',
-            iscomplexarray, 'complex array', isstringarray, 'string array',
-            iscomplexfunction, 'complex function',
-            l_and(isfunction, l_not(iscomplexfunction)), 'function',
-            isexternal, 'callback',
-            isintent_callback, 'callback',
-            isintent_aux, 'auxiliary',
-            #ismutable,'mutable',l_not(ismutable),'immutable',
-            ]
-        rl=[]
+        il = [isintent_in, 'input', isintent_out, 'output',
+              isintent_inout, 'inoutput', isrequired, 'required',
+              isoptional, 'optional', isintent_hide, 'hidden',
+              iscomplex, 'complex scalar',
+              l_and(isscalar, l_not(iscomplex)), 'scalar',
+              isstring, 'string', isarray, 'array',
+              iscomplexarray, 'complex array', isstringarray, 'string array',
+              iscomplexfunction, 'complex function',
+              l_and(isfunction, l_not(iscomplexfunction)), 'function',
+              isexternal, 'callback',
+              isintent_callback, 'callback',
+              isintent_aux, 'auxiliary',
+              # ismutable,'mutable',l_not(ismutable),'immutable',
+              ]
+        rl = []
         for i in range(0, len(il), 2):
-            if il[i](var): rl.append(il[i+1])
+            if il[i](var):
+                rl.append(il[i + 1])
         if isstring(var):
-            rl.append('slen(%s)=%s'%(a, ret['length']))
+            rl.append('slen(%s)=%s' % (a, ret['length']))
         if isarray(var):
-#             if not isintent_c(var):
-#                 var['dimension'].reverse()
-            ddim=','.join(map(lambda x, y:'%s|%s'%(x, y), var['dimension'], dim))
-            rl.append('dims(%s)'%ddim)
+            #             if not isintent_c(var):
+            #                 var['dimension'].reverse()
+            ddim = ','.join(
+                map(lambda x, y: '%s|%s' % (x, y), var['dimension'], dim))
+            rl.append('dims(%s)' % ddim)
 #             if not isintent_c(var):
 #                 var['dimension'].reverse()
         if isexternal(var):
-            ret['vardebuginfo']='debug-capi:%s=>%s:%s'%(a, ret['cbname'], ','.join(rl))
+            ret['vardebuginfo'] = 'debug-capi:%s=>%s:%s' % (
+                a, ret['cbname'], ','.join(rl))
         else:
-            ret['vardebuginfo']='debug-capi:%s %s=%s:%s'%(ret['ctype'], a, ret['showinit'], ','.join(rl))
+            ret['vardebuginfo'] = 'debug-capi:%s %s=%s:%s' % (
+                ret['ctype'], a, ret['showinit'], ','.join(rl))
         if isscalar(var):
             if ret['ctype'] in cformat_map:
-                ret['vardebugshowvalue']='debug-capi:%s=%s'%(a, cformat_map[ret['ctype']])
+                ret['vardebugshowvalue'] = 'debug-capi:%s=%s' % (
+                    a, cformat_map[ret['ctype']])
         if isstring(var):
-            ret['vardebugshowvalue']='debug-capi:slen(%s)=%%d %s=\\"%%s\\"'%(a, a)
+            ret['vardebugshowvalue'] = 'debug-capi:slen(%s)=%%d %s=\\"%%s\\"' % (
+                a, a)
         if isexternal(var):
-            ret['vardebugshowvalue']='debug-capi:%s=%%p'%(a)
+            ret['vardebugshowvalue'] = 'debug-capi:%s=%%p' % (a)
     if ret['ctype'] in cformat_map:
-        ret['varshowvalue']='#name#:%s=%s'%(a, cformat_map[ret['ctype']])
-        ret['showvalueformat']='%s'%(cformat_map[ret['ctype']])
+        ret['varshowvalue'] = '#name#:%s=%s' % (a, cformat_map[ret['ctype']])
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
     if isstring(var):
-        ret['varshowvalue']='#name#:slen(%s)=%%d %s=\\"%%s\\"'%(a, a)
-    ret['pydocsign'], ret['pydocsignout']=getpydocsign(a, var)
+        ret['varshowvalue'] = '#name#:slen(%s)=%%d %s=\\"%%s\\"' % (a, a)
+    ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, var)
     if hasnote(var):
-        ret['note']=var['note']
+        ret['note'] = var['note']
     return ret
 
+
 def routsign2map(rout):
     """
     name,NAME,begintitle,endtitle
@@ -574,18 +630,18 @@ def routsign2map(rout):
     global lcb_map
     name = rout['name']
     fname = getfortranname(rout)
-    ret={'name': name,
-         'texname': name.replace('_', '\\_'),
-         'name_lower': name.lower(),
-         'NAME': name.upper(),
-         'begintitle': gentitle(name),
-         'endtitle': gentitle('end of %s'%name),
-         'fortranname': fname,
-         'FORTRANNAME': fname.upper(),
-         'callstatement': getcallstatement(rout) or '',
-         'usercode': getusercode(rout) or '',
-         'usercode1': getusercode1(rout) or '',
-         }
+    ret = {'name': name,
+           'texname': name.replace('_', '\\_'),
+           'name_lower': name.lower(),
+           'NAME': name.upper(),
+           'begintitle': gentitle(name),
+           'endtitle': gentitle('end of %s' % name),
+           'fortranname': fname,
+           'FORTRANNAME': fname.upper(),
+           'callstatement': getcallstatement(rout) or '',
+           'usercode': getusercode(rout) or '',
+           'usercode1': getusercode1(rout) or '',
+           }
     if '_' in fname:
         ret['F_FUNC'] = 'F_FUNC_US'
     else:
@@ -594,67 +650,75 @@ def routsign2map(rout):
         ret['F_WRAPPEDFUNC'] = 'F_WRAPPEDFUNC_US'
     else:
         ret['F_WRAPPEDFUNC'] = 'F_WRAPPEDFUNC'
-    lcb_map={}
+    lcb_map = {}
     if 'use' in rout:
         for u in rout['use'].keys():
             if u in cb_rules.cb_map:
                 for un in cb_rules.cb_map[u]:
-                    ln=un[0]
+                    ln = un[0]
                     if 'map' in rout['use'][u]:
                         for k in rout['use'][u]['map'].keys():
-                            if rout['use'][u]['map'][k]==un[0]: ln=k;break
-                    lcb_map[ln]=un[1]
-            #else:
+                            if rout['use'][u]['map'][k] == un[0]:
+                                ln = k
+                                break
+                    lcb_map[ln] = un[1]
+            # else:
             #    errmess('routsign2map: cb_map does not contain module "%s" used in "use" statement.\n'%(u))
     elif 'externals' in rout and rout['externals']:
-        errmess('routsign2map: Confused: function %s has externals %s but no "use" statement.\n'%(ret['name'], repr(rout['externals'])))
+        errmess('routsign2map: Confused: function %s has externals %s but no "use" statement.\n' % (
+            ret['name'], repr(rout['externals'])))
     ret['callprotoargument'] = getcallprotoargument(rout, lcb_map) or ''
     if isfunction(rout):
         if 'result' in rout:
-            a=rout['result']
+            a = rout['result']
         else:
-            a=rout['name']
-        ret['rname']=a
-        ret['pydocsign'], ret['pydocsignout']=getpydocsign(a, rout)
-        ret['ctype']=getctype(rout['vars'][a])
+            a = rout['name']
+        ret['rname'] = a
+        ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, rout)
+        ret['ctype'] = getctype(rout['vars'][a])
         if hasresultnote(rout):
-            ret['resultnote']=rout['vars'][a]['note']
-            rout['vars'][a]['note']=['See elsewhere.']
+            ret['resultnote'] = rout['vars'][a]['note']
+            rout['vars'][a]['note'] = ['See elsewhere.']
         if ret['ctype'] in c2buildvalue_map:
-            ret['rformat']=c2buildvalue_map[ret['ctype']]
+            ret['rformat'] = c2buildvalue_map[ret['ctype']]
         else:
-            ret['rformat']='O'
-            errmess('routsign2map: no c2buildvalue key for type %s\n'%(repr(ret['ctype'])))
+            ret['rformat'] = 'O'
+            errmess('routsign2map: no c2buildvalue key for type %s\n' %
+                    (repr(ret['ctype'])))
         if debugcapi(rout):
             if ret['ctype'] in cformat_map:
-                ret['routdebugshowvalue']='debug-capi:%s=%s'%(a, cformat_map[ret['ctype']])
+                ret['routdebugshowvalue'] = 'debug-capi:%s=%s' % (
+                    a, cformat_map[ret['ctype']])
             if isstringfunction(rout):
-                ret['routdebugshowvalue']='debug-capi:slen(%s)=%%d %s=\\"%%s\\"'%(a, a)
+                ret['routdebugshowvalue'] = 'debug-capi:slen(%s)=%%d %s=\\"%%s\\"' % (
+                    a, a)
         if isstringfunction(rout):
-            ret['rlength']=getstrlength(rout['vars'][a])
-            if ret['rlength']=='-1':
-                errmess('routsign2map: expected explicit specification of the length of the string returned by the fortran function %s; taking 10.\n'%(repr(rout['name'])))
-                ret['rlength']='10'
+            ret['rlength'] = getstrlength(rout['vars'][a])
+            if ret['rlength'] == '-1':
+                errmess('routsign2map: expected explicit specification of the length of the string returned by the fortran function %s; taking 10.\n' % (
+                    repr(rout['name'])))
+                ret['rlength'] = '10'
     if hasnote(rout):
-        ret['note']=rout['note']
-        rout['note']=['See elsewhere.']
+        ret['note'] = rout['note']
+        rout['note'] = ['See elsewhere.']
     return ret
 
+
 def modsign2map(m):
     """
     modulename
     """
     if ismodule(m):
-        ret={'f90modulename':m['name'],
-             'F90MODULENAME':m['name'].upper(),
-             'texf90modulename':m['name'].replace('_', '\\_')}
+        ret = {'f90modulename': m['name'],
+               'F90MODULENAME': m['name'].upper(),
+               'texf90modulename': m['name'].replace('_', '\\_')}
     else:
-        ret={'modulename':m['name'],
-             'MODULENAME':m['name'].upper(),
-             'texmodulename':m['name'].replace('_', '\\_')}
+        ret = {'modulename': m['name'],
+               'MODULENAME': m['name'].upper(),
+               'texmodulename': m['name'].replace('_', '\\_')}
     ret['restdoc'] = getrestdoc(m) or []
     if hasnote(m):
-        ret['note']=m['note']
+        ret['note'] = m['note']
         #m['note']=['See elsewhere.']
     ret['usercode'] = getusercode(m) or ''
     ret['usercode1'] = getusercode1(m) or ''
@@ -669,37 +733,39 @@ def modsign2map(m):
         ret['f2py_wrapper_output'] = m['f2py_wrapper_output']
     return ret
 
-def cb_sign2map(a,var,index=None):
-    ret={'varname':a}
-    if index is None or 1: # disable 7712 patch
+
+def cb_sign2map(a, var, index=None):
+    ret = {'varname': a}
+    if index is None or 1:  # disable 7712 patch
         ret['varname_i'] = ret['varname']
     else:
         ret['varname_i'] = ret['varname'] + '_' + str(index)
-    ret['ctype']=getctype(var)
+    ret['ctype'] = getctype(var)
     if ret['ctype'] in c2capi_map:
-        ret['atype']=c2capi_map[ret['ctype']]
+        ret['atype'] = c2capi_map[ret['ctype']]
     if ret['ctype'] in cformat_map:
-        ret['showvalueformat']='%s'%(cformat_map[ret['ctype']])
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
     if isarray(var):
-        ret=dictappend(ret, getarrdims(a, var))
-    ret['pydocsign'], ret['pydocsignout']=getpydocsign(a, var)
+        ret = dictappend(ret, getarrdims(a, var))
+    ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, var)
     if hasnote(var):
-        ret['note']=var['note']
-        var['note']=['See elsewhere.']
+        ret['note'] = var['note']
+        var['note'] = ['See elsewhere.']
     return ret
 
+
 def cb_routsign2map(rout, um):
     """
     name,begintitle,endtitle,argname
     ctype,rctype,maxnofargs,nofoptargs,returncptr
     """
-    ret={'name':'cb_%s_in_%s'%(rout['name'], um),
-         'returncptr':''}
+    ret = {'name': 'cb_%s_in_%s' % (rout['name'], um),
+           'returncptr': ''}
     if isintent_callback(rout):
         if '_' in rout['name']:
-            F_FUNC='F_FUNC_US'
+            F_FUNC = 'F_FUNC_US'
         else:
-            F_FUNC='F_FUNC'
+            F_FUNC = 'F_FUNC'
         ret['callbackname'] = '%s(%s,%s)' \
                               % (F_FUNC,
                                  rout['name'].lower(),
@@ -709,15 +775,16 @@ def cb_routsign2map(rout, um):
     else:
         ret['callbackname'] = ret['name']
         ret['static'] = 'static'
-    ret['argname']=rout['name']
-    ret['begintitle']=gentitle(ret['name'])
-    ret['endtitle']=gentitle('end of %s'%ret['name'])
-    ret['ctype']=getctype(rout)
-    ret['rctype']='void'
-    if ret['ctype']=='string': ret['rctype']='void'
+    ret['argname'] = rout['name']
+    ret['begintitle'] = gentitle(ret['name'])
+    ret['endtitle'] = gentitle('end of %s' % ret['name'])
+    ret['ctype'] = getctype(rout)
+    ret['rctype'] = 'void'
+    if ret['ctype'] == 'string':
+        ret['rctype'] = 'void'
     else:
-        ret['rctype']=ret['ctype']
-    if ret['rctype']!='void':
+        ret['rctype'] = ret['ctype']
+    if ret['rctype'] != 'void':
         if iscomplexfunction(rout):
             ret['returncptr'] = """
 #ifdef F2PY_CB_RETURNCOMPLEX
@@ -727,21 +794,21 @@ return_value=
         else:
             ret['returncptr'] = 'return_value='
     if ret['ctype'] in cformat_map:
-        ret['showvalueformat']='%s'%(cformat_map[ret['ctype']])
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
     if isstringfunction(rout):
-        ret['strlength']=getstrlength(rout)
+        ret['strlength'] = getstrlength(rout)
     if isfunction(rout):
         if 'result' in rout:
-            a=rout['result']
+            a = rout['result']
         else:
-            a=rout['name']
+            a = rout['name']
         if hasnote(rout['vars'][a]):
-            ret['note']=rout['vars'][a]['note']
-            rout['vars'][a]['note']=['See elsewhere.']
-        ret['rname']=a
-        ret['pydocsign'], ret['pydocsignout']=getpydocsign(a, rout)
+            ret['note'] = rout['vars'][a]['note']
+            rout['vars'][a]['note'] = ['See elsewhere.']
+        ret['rname'] = a
+        ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, rout)
         if iscomplexfunction(rout):
-            ret['rctype']="""
+            ret['rctype'] = """
 #ifdef F2PY_CB_RETURNCOMPLEX
 #ctype#
 #else
@@ -750,41 +817,43 @@ void
 """
     else:
         if hasnote(rout):
-            ret['note']=rout['note']
-            rout['note']=['See elsewhere.']
-    nofargs=0
-    nofoptargs=0
+            ret['note'] = rout['note']
+            rout['note'] = ['See elsewhere.']
+    nofargs = 0
+    nofoptargs = 0
     if 'args' in rout and 'vars' in rout:
         for a in rout['args']:
-            var=rout['vars'][a]
+            var = rout['vars'][a]
             if l_or(isintent_in, isintent_inout)(var):
-                nofargs=nofargs+1
+                nofargs = nofargs + 1
                 if isoptional(var):
-                    nofoptargs=nofoptargs+1
-    ret['maxnofargs']=repr(nofargs)
-    ret['nofoptargs']=repr(nofoptargs)
+                    nofoptargs = nofoptargs + 1
+    ret['maxnofargs'] = repr(nofargs)
+    ret['nofoptargs'] = repr(nofoptargs)
     if hasnote(rout) and isfunction(rout) and 'result' in rout:
-        ret['routnote']=rout['note']
-        rout['note']=['See elsewhere.']
+        ret['routnote'] = rout['note']
+        rout['note'] = ['See elsewhere.']
     return ret
 
-def common_sign2map(a, var): # obsolute
-    ret={'varname':a}
-    ret['ctype']=getctype(var)
+
+def common_sign2map(a, var):  # obsolute
+    ret = {'varname': a}
+    ret['ctype'] = getctype(var)
     if isstringarray(var):
-        ret['ctype']='char'
+        ret['ctype'] = 'char'
     if ret['ctype'] in c2capi_map:
-        ret['atype']=c2capi_map[ret['ctype']]
+        ret['atype'] = c2capi_map[ret['ctype']]
     if ret['ctype'] in cformat_map:
-        ret['showvalueformat']='%s'%(cformat_map[ret['ctype']])
+        ret['showvalueformat'] = '%s' % (cformat_map[ret['ctype']])
     if isarray(var):
-        ret=dictappend(ret, getarrdims(a, var))
+        ret = dictappend(ret, getarrdims(a, var))
     elif isstring(var):
-        ret['size']=getstrlength(var)
-        ret['rank']='1'
-    ret['pydocsign'], ret['pydocsignout']=getpydocsign(a, var)
+        ret['size'] = getstrlength(var)
+        ret['rank'] = '1'
+    ret['pydocsign'], ret['pydocsignout'] = getpydocsign(a, var)
     if hasnote(var):
-        ret['note']=var['note']
-        var['note']=['See elsewhere.']
-    ret['arrdocstr']=getarrdocsign(a, var) # for strings this returns 0-rank but actually is 1-rank
+        ret['note'] = var['note']
+        var['note'] = ['See elsewhere.']
+    # for strings this returns 0-rank but actually is 1-rank
+    ret['arrdocstr'] = getarrdocsign(a, var)
     return ret
diff --git a/numpy/f2py/cb_rules.py b/numpy/f2py/cb_rules.py
index 29c0c1c5d..7d49544ac 100644
--- a/numpy/f2py/cb_rules.py
+++ b/numpy/f2py/cb_rules.py
@@ -29,12 +29,11 @@ from . import cfuncs
 f2py_version = __version__.version
 
 
-
 ################## Rules for callback function ##############
 
-cb_routine_rules={
-    'cbtypedefs':'typedef #rctype#(*#name#_typedef)(#optargs_td##args_td##strarglens_td##noargs#);',
-    'body':"""
+cb_routine_rules = {
+    'cbtypedefs': 'typedef #rctype#(*#name#_typedef)(#optargs_td##args_td##strarglens_td##noargs#);',
+    'body': """
 #begintitle#
 PyObject *#name#_capi = NULL;/*was Py_None*/
 PyTupleObject *#name#_args_capi = NULL;
@@ -128,96 +127,98 @@ capi_return_pt:
 }
 #endtitle#
 """,
-    'need':['setjmp.h', 'CFUNCSMESS'],
-    'maxnofargs':'#maxnofargs#',
-    'nofoptargs':'#nofoptargs#',
-    'docstr':"""\
+    'need': ['setjmp.h', 'CFUNCSMESS'],
+    'maxnofargs': '#maxnofargs#',
+    'nofoptargs': '#nofoptargs#',
+    'docstr': """\
 \tdef #argname#(#docsignature#): return #docreturn#\\n\\
 #docstrsigns#""",
-    'latexdocstr':"""
+    'latexdocstr': """
 {{}\\verb@def #argname#(#latexdocsignature#): return #docreturn#@{}}
 #routnote#
 
 #latexdocstrsigns#""",
-    'docstrshort':'def #argname#(#docsignature#): return #docreturn#'
-    }
-cb_rout_rules=[
-    {# Init
-    'separatorsfor': {'decl': '\n',
-                     'args': ',', 'optargs': '', 'pyobjfrom': '\n', 'freemem': '\n',
-                     'args_td': ',', 'optargs_td': '',
-                     'args_nm': ',', 'optargs_nm': '',
-                     'frompyobj': '\n', 'setdims': '\n',
-                     'docstrsigns': '\\n"\n"',
-                     'latexdocstrsigns': '\n',
-                     'latexdocstrreq': '\n', 'latexdocstropt': '\n',
-                     'latexdocstrout': '\n', 'latexdocstrcbs': '\n',
-                     },
-    'decl': '/*decl*/', 'pyobjfrom': '/*pyobjfrom*/', 'frompyobj': '/*frompyobj*/',
-    'args': [], 'optargs': '', 'return': '', 'strarglens': '', 'freemem': '/*freemem*/',
-    'args_td': [], 'optargs_td': '', 'strarglens_td': '',
-    'args_nm': [], 'optargs_nm': '', 'strarglens_nm': '',
-    'noargs': '',
-    'setdims': '/*setdims*/',
-    'docstrsigns': '', 'latexdocstrsigns': '',
-    'docstrreq': '\tRequired arguments:',
-    'docstropt': '\tOptional arguments:',
-    'docstrout': '\tReturn objects:',
-    'docstrcbs': '\tCall-back functions:',
-    'docreturn': '', 'docsign': '', 'docsignopt': '',
-    'latexdocstrreq': '\\noindent Required arguments:',
-    'latexdocstropt': '\\noindent Optional arguments:',
-    'latexdocstrout': '\\noindent Return objects:',
-    'latexdocstrcbs': '\\noindent Call-back functions:',
-    'routnote': {hasnote:'--- #note#',l_not(hasnote):''},
-    }, { # Function
-    'decl':'\t#ctype# return_value;',
-    'frompyobj':[{debugcapi:'\tCFUNCSMESS("cb:Getting return_value->");'},
-                 '\tif (capi_j>capi_i)\n\t\tGETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,"#ctype#_from_pyobj failed in converting return_value of call-back function #name# to C #ctype#\\n");',
-                 {debugcapi:'\tfprintf(stderr,"#showvalueformat#.\\n",return_value);'}
-                 ],
-    'need':['#ctype#_from_pyobj', {debugcapi:'CFUNCSMESS'}, 'GETSCALARFROMPYTUPLE'],
-    'return':'\treturn return_value;',
-    '_check':l_and(isfunction, l_not(isstringfunction), l_not(iscomplexfunction))
+    'docstrshort': 'def #argname#(#docsignature#): return #docreturn#'
+}
+cb_rout_rules = [
+    {  # Init
+        'separatorsfor': {'decl': '\n',
+                          'args': ',', 'optargs': '', 'pyobjfrom': '\n', 'freemem': '\n',
+                          'args_td': ',', 'optargs_td': '',
+                          'args_nm': ',', 'optargs_nm': '',
+                          'frompyobj': '\n', 'setdims': '\n',
+                          'docstrsigns': '\\n"\n"',
+                          'latexdocstrsigns': '\n',
+                          'latexdocstrreq': '\n', 'latexdocstropt': '\n',
+                          'latexdocstrout': '\n', 'latexdocstrcbs': '\n',
+                          },
+        'decl': '/*decl*/', 'pyobjfrom': '/*pyobjfrom*/', 'frompyobj': '/*frompyobj*/',
+        'args': [], 'optargs': '', 'return': '', 'strarglens': '', 'freemem': '/*freemem*/',
+        'args_td': [], 'optargs_td': '', 'strarglens_td': '',
+        'args_nm': [], 'optargs_nm': '', 'strarglens_nm': '',
+        'noargs': '',
+        'setdims': '/*setdims*/',
+        'docstrsigns': '', 'latexdocstrsigns': '',
+        'docstrreq': '\tRequired arguments:',
+        'docstropt': '\tOptional arguments:',
+        'docstrout': '\tReturn objects:',
+        'docstrcbs': '\tCall-back functions:',
+        'docreturn': '', 'docsign': '', 'docsignopt': '',
+        'latexdocstrreq': '\\noindent Required arguments:',
+        'latexdocstropt': '\\noindent Optional arguments:',
+        'latexdocstrout': '\\noindent Return objects:',
+        'latexdocstrcbs': '\\noindent Call-back functions:',
+        'routnote': {hasnote: '--- #note#', l_not(hasnote): ''},
+    }, {  # Function
+        'decl': '\t#ctype# return_value;',
+        'frompyobj': [{debugcapi: '\tCFUNCSMESS("cb:Getting return_value->");'},
+                      '\tif (capi_j>capi_i)\n\t\tGETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,"#ctype#_from_pyobj failed in converting return_value of call-back function #name# to C #ctype#\\n");',
+                      {debugcapi:
+                       '\tfprintf(stderr,"#showvalueformat#.\\n",return_value);'}
+                      ],
+        'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'}, 'GETSCALARFROMPYTUPLE'],
+        'return': '\treturn return_value;',
+        '_check': l_and(isfunction, l_not(isstringfunction), l_not(iscomplexfunction))
     },
-    {# String function
-    'pyobjfrom':{debugcapi:'\tfprintf(stderr,"debug-capi:cb:#name#:%d:\\n",return_value_len);'},
-    'args':'#ctype# return_value,int return_value_len',
-    'args_nm':'return_value,&return_value_len',
-    'args_td':'#ctype# ,int',
-    'frompyobj':[{debugcapi:'\tCFUNCSMESS("cb:Getting return_value->\\"");'},
-                 """\tif (capi_j>capi_i)
+    {  # String function
+        'pyobjfrom': {debugcapi: '\tfprintf(stderr,"debug-capi:cb:#name#:%d:\\n",return_value_len);'},
+        'args': '#ctype# return_value,int return_value_len',
+        'args_nm': 'return_value,&return_value_len',
+        'args_td': '#ctype# ,int',
+        'frompyobj': [{debugcapi: '\tCFUNCSMESS("cb:Getting return_value->\\"");'},
+                      """\tif (capi_j>capi_i)
 \t\tGETSTRFROMPYTUPLE(capi_return,capi_i++,return_value,return_value_len);""",
-                 {debugcapi:'\tfprintf(stderr,"#showvalueformat#\\".\\n",return_value);'}
-                 ],
-    'need':['#ctype#_from_pyobj', {debugcapi:'CFUNCSMESS'},
-            'string.h', 'GETSTRFROMPYTUPLE'],
-    'return':'return;',
-    '_check':isstringfunction
+                      {debugcapi:
+                       '\tfprintf(stderr,"#showvalueformat#\\".\\n",return_value);'}
+                      ],
+        'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'},
+                 'string.h', 'GETSTRFROMPYTUPLE'],
+        'return': 'return;',
+        '_check': isstringfunction
     },
-    {# Complex function
-    'optargs':"""
+    {  # Complex function
+        'optargs': """
 #ifndef F2PY_CB_RETURNCOMPLEX
 #ctype# *return_value
 #endif
 """,
-    'optargs_nm':"""
+        'optargs_nm': """
 #ifndef F2PY_CB_RETURNCOMPLEX
 return_value
 #endif
 """,
-    'optargs_td':"""
+        'optargs_td': """
 #ifndef F2PY_CB_RETURNCOMPLEX
 #ctype# *
 #endif
 """,
-    'decl':"""
+        'decl': """
 #ifdef F2PY_CB_RETURNCOMPLEX
 \t#ctype# return_value;
 #endif
 """,
-    'frompyobj':[{debugcapi:'\tCFUNCSMESS("cb:Getting return_value->");'},
-                     """\
+        'frompyobj': [{debugcapi: '\tCFUNCSMESS("cb:Getting return_value->");'},
+                      """\
 \tif (capi_j>capi_i)
 #ifdef F2PY_CB_RETURNCOMPLEX
 \t\tGETSCALARFROMPYTUPLE(capi_return,capi_i++,&return_value,#ctype#,\"#ctype#_from_pyobj failed in converting return_value of call-back function #name# to C #ctype#\\n\");
@@ -225,7 +226,7 @@ return_value
 \t\tGETSCALARFROMPYTUPLE(capi_return,capi_i++,return_value,#ctype#,\"#ctype#_from_pyobj failed in converting return_value of call-back function #name# to C #ctype#\\n\");
 #endif
 """,
-                 {debugcapi:"""
+                      {debugcapi: """
 #ifdef F2PY_CB_RETURNCOMPLEX
 \tfprintf(stderr,\"#showvalueformat#.\\n\",(return_value).r,(return_value).i);
 #else
@@ -233,154 +234,162 @@ return_value
 #endif
 
 """}
-                 ],
-    'return':"""
+                      ],
+        'return': """
 #ifdef F2PY_CB_RETURNCOMPLEX
 \treturn return_value;
 #else
 \treturn;
 #endif
 """,
-    'need':['#ctype#_from_pyobj', {debugcapi:'CFUNCSMESS'},
-            'string.h', 'GETSCALARFROMPYTUPLE', '#ctype#'],
-    '_check':iscomplexfunction
+        'need': ['#ctype#_from_pyobj', {debugcapi: 'CFUNCSMESS'},
+                 'string.h', 'GETSCALARFROMPYTUPLE', '#ctype#'],
+        '_check': iscomplexfunction
     },
-    {'docstrout':'\t\t#pydocsignout#',
-     'latexdocstrout':['\\item[]{{}\\verb@#pydocsignout#@{}}',
-                       {hasnote:'--- #note#'}],
-     'docreturn':'#rname#,',
-     '_check':isfunction},
-    {'_check':issubroutine,'return':'return;'}
-    ]
+    {'docstrout': '\t\t#pydocsignout#',
+     'latexdocstrout': ['\\item[]{{}\\verb@#pydocsignout#@{}}',
+                        {hasnote: '--- #note#'}],
+     'docreturn': '#rname#,',
+     '_check': isfunction},
+    {'_check': issubroutine, 'return': 'return;'}
+]
 
-cb_arg_rules=[
-    { # Doc
-    'docstropt':{l_and(isoptional, isintent_nothide):'\t\t#pydocsign#'},
-    'docstrreq':{l_and(isrequired, isintent_nothide):'\t\t#pydocsign#'},
-    'docstrout':{isintent_out:'\t\t#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.'}]},
-    'docsign':{l_and(isrequired, isintent_nothide):'#varname#,'},
-    'docsignopt':{l_and(isoptional, isintent_nothide):'#varname#,'},
-    'depend':''
+cb_arg_rules = [
+    {  # Doc
+        'docstropt': {l_and(isoptional, isintent_nothide): '\t\t#pydocsign#'},
+        'docstrreq': {l_and(isrequired, isintent_nothide): '\t\t#pydocsign#'},
+        'docstrout': {isintent_out: '\t\t#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.'}]},
+        'docsign': {l_and(isrequired, isintent_nothide): '#varname#,'},
+        'docsignopt': {l_and(isoptional, isintent_nothide): '#varname#,'},
+        'depend': ''
     },
     {
-    'args': {
-    l_and (isscalar, isintent_c):'#ctype# #varname_i#',
-    l_and (isscalar, l_not(isintent_c)):'#ctype# *#varname_i#_cb_capi',
-    isarray:'#ctype# *#varname_i#',
-    isstring:'#ctype# #varname_i#'
-    },
-    'args_nm': {
-    l_and (isscalar, isintent_c):'#varname_i#',
-    l_and (isscalar, l_not(isintent_c)):'#varname_i#_cb_capi',
-    isarray:'#varname_i#',
-    isstring:'#varname_i#'
-    },
-    'args_td': {
-    l_and (isscalar, isintent_c):'#ctype#',
-    l_and (isscalar, l_not(isintent_c)):'#ctype# *',
-    isarray:'#ctype# *',
-    isstring:'#ctype#'
+        'args': {
+            l_and(isscalar, isintent_c): '#ctype# #varname_i#',
+            l_and(isscalar, l_not(isintent_c)): '#ctype# *#varname_i#_cb_capi',
+            isarray: '#ctype# *#varname_i#',
+            isstring: '#ctype# #varname_i#'
+        },
+        'args_nm': {
+            l_and(isscalar, isintent_c): '#varname_i#',
+            l_and(isscalar, l_not(isintent_c)): '#varname_i#_cb_capi',
+            isarray: '#varname_i#',
+            isstring: '#varname_i#'
+        },
+        'args_td': {
+            l_and(isscalar, isintent_c): '#ctype#',
+            l_and(isscalar, l_not(isintent_c)): '#ctype# *',
+            isarray: '#ctype# *',
+            isstring: '#ctype#'
+        },
+        # untested with multiple args
+        'strarglens': {isstring: ',int #varname_i#_cb_len'},
+        'strarglens_td': {isstring: ',int'},  # untested with multiple args
+        # untested with multiple args
+        'strarglens_nm': {isstring: ',#varname_i#_cb_len'},
     },
-    'strarglens': {isstring:',int #varname_i#_cb_len'}, # untested with multiple args
-    'strarglens_td': {isstring:',int'}, # untested with multiple args
-    'strarglens_nm': {isstring:',#varname_i#_cb_len'}, # untested with multiple args
-     },
-    { # Scalars
-    'decl':{l_not(isintent_c):'\t#ctype# #varname_i#=(*#varname_i#_cb_capi);'},
-    'error': {l_and(isintent_c, isintent_out,
-                    throw_error('intent(c,out) is forbidden for callback scalar arguments')):\
-               ''},
-    'frompyobj':[{debugcapi:'\tCFUNCSMESS("cb:Getting #varname#->");'},
-                 {isintent_out:'\tif (capi_j>capi_i)\n\t\tGETSCALARFROMPYTUPLE(capi_return,capi_i++,#varname_i#_cb_capi,#ctype#,"#ctype#_from_pyobj failed in converting argument #varname# of call-back function #name# to C #ctype#\\n");'},
-                 {l_and(debugcapi, l_and(l_not(iscomplex), isintent_c)):'\tfprintf(stderr,"#showvalueformat#.\\n",#varname_i#);'},
-                 {l_and(debugcapi, l_and(l_not(iscomplex), l_not(isintent_c))):'\tfprintf(stderr,"#showvalueformat#.\\n",*#varname_i#_cb_capi);'},
-                 {l_and(debugcapi, l_and(iscomplex, isintent_c)):'\tfprintf(stderr,"#showvalueformat#.\\n",(#varname_i#).r,(#varname_i#).i);'},
-                 {l_and(debugcapi, l_and(iscomplex, l_not(isintent_c))):'\tfprintf(stderr,"#showvalueformat#.\\n",(*#varname_i#_cb_capi).r,(*#varname_i#_cb_capi).i);'},
-                 ],
-    'need':[{isintent_out:['#ctype#_from_pyobj', 'GETSCALARFROMPYTUPLE']},
-            {debugcapi:'CFUNCSMESS'}],
-     '_check':isscalar
-     }, {
-    'pyobjfrom':[{isintent_in:"""\
+    {  # Scalars
+        'decl': {l_not(isintent_c): '\t#ctype# #varname_i#=(*#varname_i#_cb_capi);'},
+        'error': {l_and(isintent_c, isintent_out,
+                        throw_error('intent(c,out) is forbidden for callback scalar arguments')):
+                  ''},
+        'frompyobj': [{debugcapi: '\tCFUNCSMESS("cb:Getting #varname#->");'},
+                      {isintent_out:
+                       '\tif (capi_j>capi_i)\n\t\tGETSCALARFROMPYTUPLE(capi_return,capi_i++,#varname_i#_cb_capi,#ctype#,"#ctype#_from_pyobj failed in converting argument #varname# of call-back function #name# to C #ctype#\\n");'},
+                      {l_and(debugcapi, l_and(l_not(iscomplex), isintent_c)):
+                          '\tfprintf(stderr,"#showvalueformat#.\\n",#varname_i#);'},
+                      {l_and(debugcapi, l_and(l_not(iscomplex), l_not( isintent_c))):
+                          '\tfprintf(stderr,"#showvalueformat#.\\n",*#varname_i#_cb_capi);'},
+                      {l_and(debugcapi, l_and(iscomplex, isintent_c)):
+                          '\tfprintf(stderr,"#showvalueformat#.\\n",(#varname_i#).r,(#varname_i#).i);'},
+                      {l_and(debugcapi, l_and(iscomplex, l_not( isintent_c))):
+                          '\tfprintf(stderr,"#showvalueformat#.\\n",(*#varname_i#_cb_capi).r,(*#varname_i#_cb_capi).i);'},
+                      ],
+        'need': [{isintent_out: ['#ctype#_from_pyobj', 'GETSCALARFROMPYTUPLE']},
+                 {debugcapi: 'CFUNCSMESS'}],
+        '_check': isscalar
+    }, {
+        'pyobjfrom': [{isintent_in: """\
 \tif (#name#_nofargs>capi_i)
 \t\tif (PyTuple_SetItem((PyObject *)capi_arglist,capi_i++,pyobj_from_#ctype#1(#varname_i#)))
 \t\t\tgoto capi_fail;"""},
-                 {isintent_inout:"""\
+                      {isintent_inout: """\
 \tif (#name#_nofargs>capi_i)
 \t\tif (PyTuple_SetItem((PyObject *)capi_arglist,capi_i++,pyarr_from_p_#ctype#1(#varname_i#_cb_capi)))
 \t\t\tgoto capi_fail;"""}],
-    'need':[{isintent_in:'pyobj_from_#ctype#1'},
-            {isintent_inout:'pyarr_from_p_#ctype#1'},
-            {iscomplex:'#ctype#'}],
-    '_check':l_and(isscalar, isintent_nothide),
-    '_optional':''
-    }, {# String
-    'frompyobj':[{debugcapi:'\tCFUNCSMESS("cb:Getting #varname#->\\"");'},
-                 """\tif (capi_j>capi_i)
+        'need': [{isintent_in: 'pyobj_from_#ctype#1'},
+                 {isintent_inout: 'pyarr_from_p_#ctype#1'},
+                 {iscomplex: '#ctype#'}],
+        '_check': l_and(isscalar, isintent_nothide),
+        '_optional': ''
+    }, {  # String
+        'frompyobj': [{debugcapi: '\tCFUNCSMESS("cb:Getting #varname#->\\"");'},
+                      """\tif (capi_j>capi_i)
 \t\tGETSTRFROMPYTUPLE(capi_return,capi_i++,#varname_i#,#varname_i#_cb_len);""",
-                 {debugcapi:'\tfprintf(stderr,"#showvalueformat#\\":%d:.\\n",#varname_i#,#varname_i#_cb_len);'},
-                 ],
-    'need':['#ctype#', 'GETSTRFROMPYTUPLE',
-            {debugcapi:'CFUNCSMESS'}, 'string.h'],
-    '_check':l_and(isstring, isintent_out)
+                      {debugcapi:
+                       '\tfprintf(stderr,"#showvalueformat#\\":%d:.\\n",#varname_i#,#varname_i#_cb_len);'},
+                      ],
+        'need': ['#ctype#', 'GETSTRFROMPYTUPLE',
+                 {debugcapi: 'CFUNCSMESS'}, 'string.h'],
+        '_check': l_and(isstring, isintent_out)
     }, {
-    'pyobjfrom':[{debugcapi:'\tfprintf(stderr,"debug-capi:cb:#varname#=\\"#showvalueformat#\\":%d:\\n",#varname_i#,#varname_i#_cb_len);'},
-                 {isintent_in:"""\
+        'pyobjfrom': [{debugcapi: '\tfprintf(stderr,"debug-capi:cb:#varname#=\\"#showvalueformat#\\":%d:\\n",#varname_i#,#varname_i#_cb_len);'},
+                      {isintent_in: """\
 \tif (#name#_nofargs>capi_i)
 \t\tif (PyTuple_SetItem((PyObject *)capi_arglist,capi_i++,pyobj_from_#ctype#1size(#varname_i#,#varname_i#_cb_len)))
 \t\t\tgoto capi_fail;"""},
-                 {isintent_inout:"""\
+                      {isintent_inout: """\
 \tif (#name#_nofargs>capi_i) {
 \t\tint #varname_i#_cb_dims[] = {#varname_i#_cb_len};
 \t\tif (PyTuple_SetItem((PyObject *)capi_arglist,capi_i++,pyarr_from_p_#ctype#1(#varname_i#,#varname_i#_cb_dims)))
 \t\t\tgoto capi_fail;
 \t}"""}],
-    'need':[{isintent_in:'pyobj_from_#ctype#1size'},
-            {isintent_inout:'pyarr_from_p_#ctype#1'}],
-    '_check':l_and(isstring, isintent_nothide),
-    '_optional':''
+        'need': [{isintent_in: 'pyobj_from_#ctype#1size'},
+                 {isintent_inout: 'pyarr_from_p_#ctype#1'}],
+        '_check': l_and(isstring, isintent_nothide),
+        '_optional': ''
     },
-# Array ...
+    # Array ...
     {
-    'decl':'\tnpy_intp #varname_i#_Dims[#rank#] = {#rank*[-1]#};',
-    'setdims':'\t#cbsetdims#;',
-    '_check':isarray,
-    '_depend':''
+        'decl': '\tnpy_intp #varname_i#_Dims[#rank#] = {#rank*[-1]#};',
+        'setdims': '\t#cbsetdims#;',
+        '_check': isarray,
+        '_depend': ''
     },
     {
-    'pyobjfrom': [{debugcapi:'\tfprintf(stderr,"debug-capi:cb:#varname#\\n");'},
-                 {isintent_c: """\
+        'pyobjfrom': [{debugcapi: '\tfprintf(stderr,"debug-capi:cb:#varname#\\n");'},
+                      {isintent_c: """\
 \tif (#name#_nofargs>capi_i) {
 \t\tPyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,#rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,0,NPY_ARRAY_CARRAY,NULL); /*XXX: Hmm, what will destroy this array??? */
 """,
-                  l_not(isintent_c): """\
+                       l_not(isintent_c): """\
 \tif (#name#_nofargs>capi_i) {
 \t\tPyArrayObject *tmp_arr = (PyArrayObject *)PyArray_New(&PyArray_Type,#rank#,#varname_i#_Dims,#atype#,NULL,(char*)#varname_i#,0,NPY_ARRAY_FARRAY,NULL); /*XXX: Hmm, what will destroy this array??? */
 """,
-                  },
-                 """
+                       },
+                      """
 \t\tif (tmp_arr==NULL)
 \t\t\tgoto capi_fail;
 \t\tif (PyTuple_SetItem((PyObject *)capi_arglist,capi_i++,(PyObject *)tmp_arr))
 \t\t\tgoto capi_fail;
 }"""],
-    '_check': l_and(isarray, isintent_nothide, l_or(isintent_in, isintent_inout)),
-    '_optional': '',
+        '_check': l_and(isarray, isintent_nothide, l_or(isintent_in, isintent_inout)),
+        '_optional': '',
     }, {
-    'frompyobj':[{debugcapi:'\tCFUNCSMESS("cb:Getting #varname#->");'},
-                 """\tif (capi_j>capi_i) {
+        'frompyobj': [{debugcapi: '\tCFUNCSMESS("cb:Getting #varname#->");'},
+                      """\tif (capi_j>capi_i) {
 \t\tPyArrayObject *rv_cb_arr = NULL;
 \t\tif ((capi_tmp = PyTuple_GetItem(capi_return,capi_i++))==NULL) goto capi_fail;
 \t\trv_cb_arr =  array_from_pyobj(#atype#,#varname_i#_Dims,#rank#,F2PY_INTENT_IN""",
-    {isintent_c:'|F2PY_INTENT_C'},
-    """,capi_tmp);
+                      {isintent_c: '|F2PY_INTENT_C'},
+                      """,capi_tmp);
 \t\tif (rv_cb_arr == NULL) {
 \t\t\tfprintf(stderr,\"rv_cb_arr is NULL\\n\");
 \t\t\tgoto capi_fail;
@@ -390,151 +399,157 @@ cb_arg_rules=[
 \t\t\tPy_DECREF(rv_cb_arr);
 \t\t}
 \t}""",
-                 {debugcapi:'\tfprintf(stderr,"<-.\\n");'},
-                 ],
-    'need':['MEMCOPY', {iscomplexarray:'#ctype#'}],
-    '_check':l_and(isarray, isintent_out)
+                      {debugcapi: '\tfprintf(stderr,"<-.\\n");'},
+                      ],
+        'need': ['MEMCOPY', {iscomplexarray: '#ctype#'}],
+        '_check': l_and(isarray, isintent_out)
     }, {
-    'docreturn':'#varname#,',
-    '_check':isintent_out
+        'docreturn': '#varname#,',
+        '_check': isintent_out
     }
-    ]
+]
 
 ################## Build call-back module #############
-cb_map={}
+cb_map = {}
+
+
 def buildcallbacks(m):
     global cb_map
-    cb_map[m['name']]=[]
+    cb_map[m['name']] = []
     for bi in m['body']:
-        if bi['block']=='interface':
+        if bi['block'] == 'interface':
             for b in bi['body']:
                 if b:
                     buildcallback(b, m['name'])
                 else:
                     errmess('warning: empty body for %s\n' % (m['name']))
 
+
 def buildcallback(rout, um):
     global cb_map
     from . import capi_maps
 
-    outmess('\tConstructing call-back function "cb_%s_in_%s"\n'%(rout['name'], um))
-    args, depargs=getargs(rout)
-    capi_maps.depargs=depargs
-    var=rout['vars']
-    vrd=capi_maps.cb_routsign2map(rout, um)
-    rd=dictappend({}, vrd)
+    outmess('\tConstructing call-back function "cb_%s_in_%s"\n' %
+            (rout['name'], um))
+    args, depargs = getargs(rout)
+    capi_maps.depargs = depargs
+    var = rout['vars']
+    vrd = capi_maps.cb_routsign2map(rout, um)
+    rd = dictappend({}, vrd)
     cb_map[um].append([rout['name'], rd['name']])
     for r in cb_rout_rules:
         if ('_check' in r and r['_check'](rout)) or ('_check' not in r):
-            ar=applyrules(r, vrd, rout)
-            rd=dictappend(rd, ar)
-    savevrd={}
+            ar = applyrules(r, vrd, rout)
+            rd = dictappend(rd, ar)
+    savevrd = {}
     for i, a in enumerate(args):
-        vrd=capi_maps.cb_sign2map(a, var[a], index=i)
-        savevrd[a]=vrd
+        vrd = capi_maps.cb_sign2map(a, var[a], index=i)
+        savevrd[a] = vrd
         for r in cb_arg_rules:
             if '_depend' in r:
                 continue
             if '_optional' in r and isoptional(var[a]):
                 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)
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
                 if '_break' in r:
                     break
     for a in args:
-        vrd=savevrd[a]
+        vrd = savevrd[a]
         for r in cb_arg_rules:
             if '_depend' in r:
                 continue
             if ('_optional' not in r) or ('_optional' in r and isrequired(var[a])):
                 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)
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
                 if '_break' in r:
                     break
     for a in depargs:
-        vrd=savevrd[a]
+        vrd = savevrd[a]
         for r in cb_arg_rules:
             if '_depend' not in r:
                 continue
             if '_optional' 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)
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
                 if '_break' in r:
                     break
     if 'args' in rd and 'optargs' in rd:
         if isinstance(rd['optargs'], list):
-            rd['optargs']=rd['optargs']+["""
+            rd['optargs'] = rd['optargs'] + ["""
 #ifndef F2PY_CB_RETURNCOMPLEX
 ,
 #endif
 """]
-            rd['optargs_nm']=rd['optargs_nm']+["""
+            rd['optargs_nm'] = rd['optargs_nm'] + ["""
 #ifndef F2PY_CB_RETURNCOMPLEX
 ,
 #endif
 """]
-            rd['optargs_td']=rd['optargs_td']+["""
+            rd['optargs_td'] = rd['optargs_td'] + ["""
 #ifndef F2PY_CB_RETURNCOMPLEX
 ,
 #endif
 """]
     if isinstance(rd['docreturn'], list):
-        rd['docreturn']=stripcomma(replace('#docreturn#', {'docreturn':rd['docreturn']}))
-    optargs=stripcomma(replace('#docsignopt#',
-                                {'docsignopt':rd['docsignopt']}
-                               ))
-    if optargs=='':
-        rd['docsignature']=stripcomma(replace('#docsign#', {'docsign':rd['docsign']}))
+        rd['docreturn'] = stripcomma(
+            replace('#docreturn#', {'docreturn': rd['docreturn']}))
+    optargs = stripcomma(replace('#docsignopt#',
+                                 {'docsignopt': rd['docsignopt']}
+                                 ))
+    if optargs == '':
+        rd['docsignature'] = stripcomma(
+            replace('#docsign#', {'docsign': rd['docsign']}))
     else:
-        rd['docsignature']=replace('#docsign#[#docsignopt#]',
-                                   {'docsign': rd['docsign'],
-                                    'docsignopt': optargs,
-                                    })
-    rd['latexdocsignature']=rd['docsignature'].replace('_', '\\_')
-    rd['latexdocsignature']=rd['latexdocsignature'].replace(',', ', ')
-    rd['docstrsigns']=[]
-    rd['latexdocstrsigns']=[]
+        rd['docsignature'] = replace('#docsign#[#docsignopt#]',
+                                     {'docsign': rd['docsign'],
+                                      'docsignopt': optargs,
+                                      })
+    rd['latexdocsignature'] = rd['docsignature'].replace('_', '\\_')
+    rd['latexdocsignature'] = rd['latexdocsignature'].replace(',', ', ')
+    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
+            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}']
+            rd['latexdocstrsigns'] = rd['latexdocstrsigns'] + rd[k][0:1] +\
+                ['\\begin{description}'] + rd[k][1:] +\
+                ['\\end{description}']
     if 'args' not in rd:
-        rd['args']=''
-        rd['args_td']=''
-        rd['args_nm']=''
+        rd['args'] = ''
+        rd['args_td'] = ''
+        rd['args_nm'] = ''
     if not (rd.get('args') or rd.get('optargs') or rd.get('strarglens')):
         rd['noargs'] = 'void'
 
-    ar=applyrules(cb_routine_rules, rd)
-    cfuncs.callbacks[rd['name']]=ar['body']
+    ar = applyrules(cb_routine_rules, rd)
+    cfuncs.callbacks[rd['name']] = ar['body']
     if isinstance(ar['need'], str):
-        ar['need']=[ar['need']]
+        ar['need'] = [ar['need']]
 
     if 'need' in rd:
         for t in cfuncs.typedefs.keys():
             if t in rd['need']:
                 ar['need'].append(t)
 
-    cfuncs.typedefs_generated[rd['name']+'_typedef'] = ar['cbtypedefs']
-    ar['need'].append(rd['name']+'_typedef')
-    cfuncs.needs[rd['name']]=ar['need']
+    cfuncs.typedefs_generated[rd['name'] + '_typedef'] = ar['cbtypedefs']
+    ar['need'].append(rd['name'] + '_typedef')
+    cfuncs.needs[rd['name']] = ar['need']
 
-    capi_maps.lcb2_map[rd['name']]={'maxnofargs':ar['maxnofargs'],
-                                    'nofoptargs':ar['nofoptargs'],
-                                    'docstr':ar['docstr'],
-                                    'latexdocstr':ar['latexdocstr'],
-                                    'argname':rd['argname']
-                                    }
-    outmess('\t  %s\n'%(ar['docstrshort']))
-    #print ar['body']
+    capi_maps.lcb2_map[rd['name']] = {'maxnofargs': ar['maxnofargs'],
+                                      'nofoptargs': ar['nofoptargs'],
+                                      'docstr': ar['docstr'],
+                                      'latexdocstr': ar['latexdocstr'],
+                                      'argname': rd['argname']
+                                      }
+    outmess('\t  %s\n' % (ar['docstrshort']))
+    # print ar['body']
     return
 ################## Build call-back function #############
diff --git a/numpy/f2py/cfuncs.py b/numpy/f2py/cfuncs.py
index 01e189dc1..0d0a52764 100644
--- a/numpy/f2py/cfuncs.py
+++ b/numpy/f2py/cfuncs.py
@@ -26,48 +26,48 @@ errmess = sys.stderr.write
 
 ##################### Definitions ##################
 
-outneeds={'includes0':[],'includes':[],'typedefs':[],'typedefs_generated':[],
-          'userincludes':[],
-          'cppmacros':[],'cfuncs':[],'callbacks':[],'f90modhooks':[],
-          'commonhooks':[]}
-needs={}
-includes0={'includes0':'/*need_includes0*/'}
-includes={'includes':'/*need_includes*/'}
-userincludes={'userincludes':'/*need_userincludes*/'}
-typedefs={'typedefs':'/*need_typedefs*/'}
-typedefs_generated={'typedefs_generated':'/*need_typedefs_generated*/'}
-cppmacros={'cppmacros':'/*need_cppmacros*/'}
-cfuncs={'cfuncs':'/*need_cfuncs*/'}
-callbacks={'callbacks':'/*need_callbacks*/'}
-f90modhooks={'f90modhooks': '/*need_f90modhooks*/',
-             'initf90modhooksstatic': '/*initf90modhooksstatic*/',
-             'initf90modhooksdynamic': '/*initf90modhooksdynamic*/',
-             }
-commonhooks={'commonhooks': '/*need_commonhooks*/',
-             'initcommonhooks': '/*need_initcommonhooks*/',
-             }
+outneeds = {'includes0': [], 'includes': [], 'typedefs': [], 'typedefs_generated': [],
+            'userincludes': [],
+            'cppmacros': [], 'cfuncs': [], 'callbacks': [], 'f90modhooks': [],
+            'commonhooks': []}
+needs = {}
+includes0 = {'includes0': '/*need_includes0*/'}
+includes = {'includes': '/*need_includes*/'}
+userincludes = {'userincludes': '/*need_userincludes*/'}
+typedefs = {'typedefs': '/*need_typedefs*/'}
+typedefs_generated = {'typedefs_generated': '/*need_typedefs_generated*/'}
+cppmacros = {'cppmacros': '/*need_cppmacros*/'}
+cfuncs = {'cfuncs': '/*need_cfuncs*/'}
+callbacks = {'callbacks': '/*need_callbacks*/'}
+f90modhooks = {'f90modhooks': '/*need_f90modhooks*/',
+               'initf90modhooksstatic': '/*initf90modhooksstatic*/',
+               'initf90modhooksdynamic': '/*initf90modhooksdynamic*/',
+               }
+commonhooks = {'commonhooks': '/*need_commonhooks*/',
+               'initcommonhooks': '/*need_initcommonhooks*/',
+               }
 
 ############ Includes ###################
 
-includes0['math.h']='#include <math.h>'
-includes0['string.h']='#include <string.h>'
-includes0['setjmp.h']='#include <setjmp.h>'
+includes0['math.h'] = '#include <math.h>'
+includes0['string.h'] = '#include <string.h>'
+includes0['setjmp.h'] = '#include <setjmp.h>'
 
-includes['Python.h']='#include "Python.h"'
-needs['arrayobject.h']=['Python.h']
-includes['arrayobject.h']='''#define PY_ARRAY_UNIQUE_SYMBOL PyArray_API
+includes['Python.h'] = '#include "Python.h"'
+needs['arrayobject.h'] = ['Python.h']
+includes['arrayobject.h'] = '''#define PY_ARRAY_UNIQUE_SYMBOL PyArray_API
 #include "arrayobject.h"'''
 
-includes['arrayobject.h']='#include "fortranobject.h"'
-includes['stdarg.h']='#include <stdarg.h>'
+includes['arrayobject.h'] = '#include "fortranobject.h"'
+includes['stdarg.h'] = '#include <stdarg.h>'
 
 ############# Type definitions ###############
 
-typedefs['unsigned_char']='typedef unsigned char unsigned_char;'
-typedefs['unsigned_short']='typedef unsigned short unsigned_short;'
-typedefs['unsigned_long']='typedef unsigned long unsigned_long;'
-typedefs['signed_char']='typedef signed char signed_char;'
-typedefs['long_long']="""\
+typedefs['unsigned_char'] = 'typedef unsigned char unsigned_char;'
+typedefs['unsigned_short'] = 'typedef unsigned short unsigned_short;'
+typedefs['unsigned_long'] = 'typedef unsigned long unsigned_long;'
+typedefs['signed_char'] = 'typedef signed char signed_char;'
+typedefs['long_long'] = """\
 #ifdef _WIN32
 typedef __int64 long_long;
 #else
@@ -75,26 +75,27 @@ typedef long long long_long;
 typedef unsigned long long unsigned_long_long;
 #endif
 """
-typedefs['unsigned_long_long']="""\
+typedefs['unsigned_long_long'] = """\
 #ifdef _WIN32
 typedef __uint64 long_long;
 #else
 typedef unsigned long long unsigned_long_long;
 #endif
 """
-typedefs['long_double']="""\
+typedefs['long_double'] = """\
 #ifndef _LONG_DOUBLE
 typedef long double long_double;
 #endif
 """
-typedefs['complex_long_double']='typedef struct {long double r,i;} complex_long_double;'
-typedefs['complex_float']='typedef struct {float r,i;} complex_float;'
-typedefs['complex_double']='typedef struct {double r,i;} complex_double;'
-typedefs['string']="""typedef char * string;"""
+typedefs[
+    'complex_long_double'] = 'typedef struct {long double r,i;} complex_long_double;'
+typedefs['complex_float'] = 'typedef struct {float r,i;} complex_float;'
+typedefs['complex_double'] = 'typedef struct {double r,i;} complex_double;'
+typedefs['string'] = """typedef char * string;"""
 
 
 ############### CPP macros ####################
-cppmacros['CFUNCSMESS']="""\
+cppmacros['CFUNCSMESS'] = """\
 #ifdef DEBUGCFUNCS
 #define CFUNCSMESS(mess) fprintf(stderr,\"debug-capi:\"mess);
 #define CFUNCSMESSPY(mess,obj) CFUNCSMESS(mess) \\
@@ -105,7 +106,7 @@ cppmacros['CFUNCSMESS']="""\
 #define CFUNCSMESSPY(mess,obj)
 #endif
 """
-cppmacros['F_FUNC']="""\
+cppmacros['F_FUNC'] = """\
 #if defined(PREPEND_FORTRAN)
 #if defined(NO_APPEND_FORTRAN)
 #if defined(UPPERCASE_FORTRAN)
@@ -141,7 +142,7 @@ cppmacros['F_FUNC']="""\
 #define F_FUNC_US(f,F) F_FUNC(f,F)
 #endif
 """
-cppmacros['F_WRAPPEDFUNC']="""\
+cppmacros['F_WRAPPEDFUNC'] = """\
 #if defined(PREPEND_FORTRAN)
 #if defined(NO_APPEND_FORTRAN)
 #if defined(UPPERCASE_FORTRAN)
@@ -177,7 +178,7 @@ cppmacros['F_WRAPPEDFUNC']="""\
 #define F_WRAPPEDFUNC_US(f,F) F_WRAPPEDFUNC(f,F)
 #endif
 """
-cppmacros['F_MODFUNC']="""\
+cppmacros['F_MODFUNC'] = """\
 #if defined(F90MOD2CCONV1) /*E.g. Compaq Fortran */
 #if defined(NO_APPEND_FORTRAN)
 #define F_MODFUNCNAME(m,f) $ ## m ## $ ## f
@@ -211,26 +212,27 @@ cppmacros['F_MODFUNC']="""\
 
 #define F_MODFUNC(m,f) (*(f2pymodstruct##m##.##f))
 """
-cppmacros['SWAPUNSAFE']="""\
+cppmacros['SWAPUNSAFE'] = """\
 #define SWAP(a,b) (size_t)(a) = ((size_t)(a) ^ (size_t)(b));\\
  (size_t)(b) = ((size_t)(a) ^ (size_t)(b));\\
  (size_t)(a) = ((size_t)(a) ^ (size_t)(b))
 """
-cppmacros['SWAP']="""\
+cppmacros['SWAP'] = """\
 #define SWAP(a,b,t) {\\
 \tt *c;\\
 \tc = a;\\
 \ta = b;\\
 \tb = c;}
 """
-#cppmacros['ISCONTIGUOUS']='#define ISCONTIGUOUS(m) (PyArray_FLAGS(m) & NPY_ARRAY_C_CONTIGUOUS)'
-cppmacros['PRINTPYOBJERR']="""\
+# cppmacros['ISCONTIGUOUS']='#define ISCONTIGUOUS(m) (PyArray_FLAGS(m) &
+# NPY_ARRAY_C_CONTIGUOUS)'
+cppmacros['PRINTPYOBJERR'] = """\
 #define PRINTPYOBJERR(obj)\\
 \tfprintf(stderr,\"#modulename#.error is related to \");\\
 \tPyObject_Print((PyObject *)obj,stderr,Py_PRINT_RAW);\\
 \tfprintf(stderr,\"\\n\");
 """
-cppmacros['MINMAX']="""\
+cppmacros['MINMAX'] = """\
 #ifndef max
 #define max(a,b) ((a > b) ? (a) : (b))
 #endif
@@ -244,8 +246,8 @@ cppmacros['MINMAX']="""\
 #define MIN(a,b) ((a < b) ? (a) : (b))
 #endif
 """
-needs['len..']=['f2py_size']
-cppmacros['len..']="""\
+needs['len..'] = ['f2py_size']
+cppmacros['len..'] = """\
 #define rank(var) var ## _Rank
 #define shape(var,dim) var ## _Dims[dim]
 #define old_rank(var) (PyArray_NDIM((PyArrayObject *)(capi_ ## var ## _tmp)))
@@ -258,8 +260,8 @@ cppmacros['len..']="""\
 #define slen(var) capi_ ## var ## _len
 #define size(var, ...) f2py_size((PyArrayObject *)(capi_ ## var ## _tmp), ## __VA_ARGS__, -1)
 """
-needs['f2py_size']=['stdarg.h']
-cfuncs['f2py_size']="""\
+needs['f2py_size'] = ['stdarg.h']
+cfuncs['f2py_size'] = """\
 static int f2py_size(PyArrayObject* var, ...)
 {
   npy_int sz = 0;
@@ -285,13 +287,16 @@ static int f2py_size(PyArrayObject* var, ...)
 }
 """
 
-cppmacros['pyobj_from_char1']='#define pyobj_from_char1(v) (PyInt_FromLong(v))'
-cppmacros['pyobj_from_short1']='#define pyobj_from_short1(v) (PyInt_FromLong(v))'
-needs['pyobj_from_int1']=['signed_char']
-cppmacros['pyobj_from_int1']='#define pyobj_from_int1(v) (PyInt_FromLong(v))'
-cppmacros['pyobj_from_long1']='#define pyobj_from_long1(v) (PyLong_FromLong(v))'
-needs['pyobj_from_long_long1']=['long_long']
-cppmacros['pyobj_from_long_long1']="""\
+cppmacros[
+    'pyobj_from_char1'] = '#define pyobj_from_char1(v) (PyInt_FromLong(v))'
+cppmacros[
+    'pyobj_from_short1'] = '#define pyobj_from_short1(v) (PyInt_FromLong(v))'
+needs['pyobj_from_int1'] = ['signed_char']
+cppmacros['pyobj_from_int1'] = '#define pyobj_from_int1(v) (PyInt_FromLong(v))'
+cppmacros[
+    'pyobj_from_long1'] = '#define pyobj_from_long1(v) (PyLong_FromLong(v))'
+needs['pyobj_from_long_long1'] = ['long_long']
+cppmacros['pyobj_from_long_long1'] = """\
 #ifdef HAVE_LONG_LONG
 #define pyobj_from_long_long1(v) (PyLong_FromLongLong(v))
 #else
@@ -299,22 +304,30 @@ cppmacros['pyobj_from_long_long1']="""\
 #define pyobj_from_long_long1(v) (PyLong_FromLong(v))
 #endif
 """
-needs['pyobj_from_long_double1']=['long_double']
-cppmacros['pyobj_from_long_double1']='#define pyobj_from_long_double1(v) (PyFloat_FromDouble(v))'
-cppmacros['pyobj_from_double1']='#define pyobj_from_double1(v) (PyFloat_FromDouble(v))'
-cppmacros['pyobj_from_float1']='#define pyobj_from_float1(v) (PyFloat_FromDouble(v))'
-needs['pyobj_from_complex_long_double1']=['complex_long_double']
-cppmacros['pyobj_from_complex_long_double1']='#define pyobj_from_complex_long_double1(v) (PyComplex_FromDoubles(v.r,v.i))'
-needs['pyobj_from_complex_double1']=['complex_double']
-cppmacros['pyobj_from_complex_double1']='#define pyobj_from_complex_double1(v) (PyComplex_FromDoubles(v.r,v.i))'
-needs['pyobj_from_complex_float1']=['complex_float']
-cppmacros['pyobj_from_complex_float1']='#define pyobj_from_complex_float1(v) (PyComplex_FromDoubles(v.r,v.i))'
-needs['pyobj_from_string1']=['string']
-cppmacros['pyobj_from_string1']='#define pyobj_from_string1(v) (PyString_FromString((char *)v))'
-needs['pyobj_from_string1size']=['string']
-cppmacros['pyobj_from_string1size']='#define pyobj_from_string1size(v,len) (PyUString_FromStringAndSize((char *)v, len))'
-needs['TRYPYARRAYTEMPLATE']=['PRINTPYOBJERR']
-cppmacros['TRYPYARRAYTEMPLATE']="""\
+needs['pyobj_from_long_double1'] = ['long_double']
+cppmacros[
+    'pyobj_from_long_double1'] = '#define pyobj_from_long_double1(v) (PyFloat_FromDouble(v))'
+cppmacros[
+    'pyobj_from_double1'] = '#define pyobj_from_double1(v) (PyFloat_FromDouble(v))'
+cppmacros[
+    'pyobj_from_float1'] = '#define pyobj_from_float1(v) (PyFloat_FromDouble(v))'
+needs['pyobj_from_complex_long_double1'] = ['complex_long_double']
+cppmacros[
+    'pyobj_from_complex_long_double1'] = '#define pyobj_from_complex_long_double1(v) (PyComplex_FromDoubles(v.r,v.i))'
+needs['pyobj_from_complex_double1'] = ['complex_double']
+cppmacros[
+    'pyobj_from_complex_double1'] = '#define pyobj_from_complex_double1(v) (PyComplex_FromDoubles(v.r,v.i))'
+needs['pyobj_from_complex_float1'] = ['complex_float']
+cppmacros[
+    'pyobj_from_complex_float1'] = '#define pyobj_from_complex_float1(v) (PyComplex_FromDoubles(v.r,v.i))'
+needs['pyobj_from_string1'] = ['string']
+cppmacros[
+    'pyobj_from_string1'] = '#define pyobj_from_string1(v) (PyString_FromString((char *)v))'
+needs['pyobj_from_string1size'] = ['string']
+cppmacros[
+    'pyobj_from_string1size'] = '#define pyobj_from_string1size(v,len) (PyUString_FromStringAndSize((char *)v, len))'
+needs['TRYPYARRAYTEMPLATE'] = ['PRINTPYOBJERR']
+cppmacros['TRYPYARRAYTEMPLATE'] = """\
 /* New SciPy */
 #define TRYPYARRAYTEMPLATECHAR case NPY_STRING: *(char *)(PyArray_DATA(arr))=*v; break;
 #define TRYPYARRAYTEMPLATELONG case NPY_LONG: *(long *)(PyArray_DATA(arr))=*v; break;
@@ -350,8 +363,8 @@ cppmacros['TRYPYARRAYTEMPLATE']="""\
         return 1
 """
 
-needs['TRYCOMPLEXPYARRAYTEMPLATE']=['PRINTPYOBJERR']
-cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
+needs['TRYCOMPLEXPYARRAYTEMPLATE'] = ['PRINTPYOBJERR']
+cppmacros['TRYCOMPLEXPYARRAYTEMPLATE'] = """\
 #define TRYCOMPLEXPYARRAYTEMPLATEOBJECT case NPY_OBJECT: (PyArray_DESCR(arr)->f->setitem)(pyobj_from_complex_ ## ctype ## 1((*v)),PyArray_DATA(arr), arr); break;
 #define TRYCOMPLEXPYARRAYTEMPLATE(ctype,typecode)\\
         PyArrayObject *arr = NULL;\\
@@ -386,41 +399,41 @@ cppmacros['TRYCOMPLEXPYARRAYTEMPLATE']="""\
         };\\
         return -1;
 """
-## cppmacros['NUMFROMARROBJ']="""\
-## #define NUMFROMARROBJ(typenum,ctype) \\
-## \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
-## \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
-## \tif (arr) {\\
-## \t\tif (PyArray_TYPE(arr)==NPY_OBJECT) {\\
-## \t\t\tif (!ctype ## _from_pyobj(v,(PyArray_DESCR(arr)->getitem)(PyArray_DATA(arr)),\"\"))\\
-## \t\t\tgoto capi_fail;\\
-## \t\t} else {\\
-## \t\t\t(PyArray_DESCR(arr)->cast[typenum])(PyArray_DATA(arr),1,(char*)v,1,1);\\
-## \t\t}\\
-## \t\tif ((PyObject *)arr != obj) { Py_DECREF(arr); }\\
-## \t\treturn 1;\\
-## \t}
-## """
-## #XXX: Note that CNUMFROMARROBJ is identical with NUMFROMARROBJ
-## cppmacros['CNUMFROMARROBJ']="""\
-## #define CNUMFROMARROBJ(typenum,ctype) \\
-## \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
-## \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
-## \tif (arr) {\\
-## \t\tif (PyArray_TYPE(arr)==NPY_OBJECT) {\\
-## \t\t\tif (!ctype ## _from_pyobj(v,(PyArray_DESCR(arr)->getitem)(PyArray_DATA(arr)),\"\"))\\
-## \t\t\tgoto capi_fail;\\
-## \t\t} else {\\
-## \t\t\t(PyArray_DESCR(arr)->cast[typenum])((void *)(PyArray_DATA(arr)),1,(void *)(v),1,1);\\
-## \t\t}\\
-## \t\tif ((PyObject *)arr != obj) { Py_DECREF(arr); }\\
-## \t\treturn 1;\\
-## \t}
-## """
+# cppmacros['NUMFROMARROBJ']="""\
+# define NUMFROMARROBJ(typenum,ctype) \\
+# \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
+# \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
+# \tif (arr) {\\
+# \t\tif (PyArray_TYPE(arr)==NPY_OBJECT) {\\
+# \t\t\tif (!ctype ## _from_pyobj(v,(PyArray_DESCR(arr)->getitem)(PyArray_DATA(arr)),\"\"))\\
+# \t\t\tgoto capi_fail;\\
+# \t\t} else {\\
+# \t\t\t(PyArray_DESCR(arr)->cast[typenum])(PyArray_DATA(arr),1,(char*)v,1,1);\\
+# \t\t}\\
+# \t\tif ((PyObject *)arr != obj) { Py_DECREF(arr); }\\
+# \t\treturn 1;\\
+# \t}
+# """
+# XXX: Note that CNUMFROMARROBJ is identical with NUMFROMARROBJ
+# cppmacros['CNUMFROMARROBJ']="""\
+# define CNUMFROMARROBJ(typenum,ctype) \\
+# \tif (PyArray_Check(obj)) arr = (PyArrayObject *)obj;\\
+# \telse arr = (PyArrayObject *)PyArray_ContiguousFromObject(obj,typenum,0,0);\\
+# \tif (arr) {\\
+# \t\tif (PyArray_TYPE(arr)==NPY_OBJECT) {\\
+# \t\t\tif (!ctype ## _from_pyobj(v,(PyArray_DESCR(arr)->getitem)(PyArray_DATA(arr)),\"\"))\\
+# \t\t\tgoto capi_fail;\\
+# \t\t} else {\\
+# \t\t\t(PyArray_DESCR(arr)->cast[typenum])((void *)(PyArray_DATA(arr)),1,(void *)(v),1,1);\\
+# \t\t}\\
+# \t\tif ((PyObject *)arr != obj) { Py_DECREF(arr); }\\
+# \t\treturn 1;\\
+# \t}
+# """
 
 
-needs['GETSTRFROMPYTUPLE']=['STRINGCOPYN', 'PRINTPYOBJERR']
-cppmacros['GETSTRFROMPYTUPLE']="""\
+needs['GETSTRFROMPYTUPLE'] = ['STRINGCOPYN', 'PRINTPYOBJERR']
+cppmacros['GETSTRFROMPYTUPLE'] = """\
 #define GETSTRFROMPYTUPLE(tuple,index,str,len) {\\
 \t\tPyObject *rv_cb_str = PyTuple_GetItem((tuple),(index));\\
 \t\tif (rv_cb_str == NULL)\\
@@ -435,7 +448,7 @@ cppmacros['GETSTRFROMPYTUPLE']="""\
 \t\t}\\
 \t}
 """
-cppmacros['GETSCALARFROMPYTUPLE']="""\
+cppmacros['GETSCALARFROMPYTUPLE'] = """\
 #define GETSCALARFROMPYTUPLE(tuple,index,var,ctype,mess) {\\
 \t\tif ((capi_tmp = PyTuple_GetItem((tuple),(index)))==NULL) goto capi_fail;\\
 \t\tif (!(ctype ## _from_pyobj((var),capi_tmp,mess)))\\
@@ -443,7 +456,7 @@ cppmacros['GETSCALARFROMPYTUPLE']="""\
 \t}
 """
 
-cppmacros['FAILNULL']="""\\
+cppmacros['FAILNULL'] = """\\
 #define FAILNULL(p) do {                                            \\
     if ((p) == NULL) {                                              \\
         PyErr_SetString(PyExc_MemoryError, "NULL pointer found");   \\
@@ -451,12 +464,12 @@ cppmacros['FAILNULL']="""\\
     }                                                               \\
 } while (0)
 """
-needs['MEMCOPY']=['string.h', 'FAILNULL']
-cppmacros['MEMCOPY']="""\
+needs['MEMCOPY'] = ['string.h', 'FAILNULL']
+cppmacros['MEMCOPY'] = """\
 #define MEMCOPY(to,from,n)\\
     do { FAILNULL(to); FAILNULL(from); (void)memcpy(to,from,n); } while (0)
 """
-cppmacros['STRINGMALLOC']="""\
+cppmacros['STRINGMALLOC'] = """\
 #define STRINGMALLOC(str,len)\\
 \tif ((str = (string)malloc(sizeof(char)*(len+1))) == NULL) {\\
 \t\tPyErr_SetString(PyExc_MemoryError, \"out of memory\");\\
@@ -465,11 +478,11 @@ cppmacros['STRINGMALLOC']="""\
 \t\t(str)[len] = '\\0';\\
 \t}
 """
-cppmacros['STRINGFREE']="""\
+cppmacros['STRINGFREE'] = """\
 #define STRINGFREE(str) do {if (!(str == NULL)) free(str);} while (0)
 """
-needs['STRINGCOPYN']=['string.h', 'FAILNULL']
-cppmacros['STRINGCOPYN']="""\
+needs['STRINGCOPYN'] = ['string.h', 'FAILNULL']
+cppmacros['STRINGCOPYN'] = """\
 #define STRINGCOPYN(to,from,buf_size)                           \\
     do {                                                        \\
         int _m = (buf_size);                                    \\
@@ -484,24 +497,24 @@ cppmacros['STRINGCOPYN']="""\
         }                                                       \\
     } while (0)
 """
-needs['STRINGCOPY']=['string.h', 'FAILNULL']
-cppmacros['STRINGCOPY']="""\
+needs['STRINGCOPY'] = ['string.h', 'FAILNULL']
+cppmacros['STRINGCOPY'] = """\
 #define STRINGCOPY(to,from)\\
     do { FAILNULL(to); FAILNULL(from); (void)strcpy(to,from); } while (0)
 """
-cppmacros['CHECKGENERIC']="""\
+cppmacros['CHECKGENERIC'] = """\
 #define CHECKGENERIC(check,tcheck,name) \\
 \tif (!(check)) {\\
 \t\tPyErr_SetString(#modulename#_error,\"(\"tcheck\") failed for \"name);\\
 \t\t/*goto capi_fail;*/\\
 \t} else """
-cppmacros['CHECKARRAY']="""\
+cppmacros['CHECKARRAY'] = """\
 #define CHECKARRAY(check,tcheck,name) \\
 \tif (!(check)) {\\
 \t\tPyErr_SetString(#modulename#_error,\"(\"tcheck\") failed for \"name);\\
 \t\t/*goto capi_fail;*/\\
 \t} else """
-cppmacros['CHECKSTRING']="""\
+cppmacros['CHECKSTRING'] = """\
 #define CHECKSTRING(check,tcheck,name,show,var)\\
 \tif (!(check)) {\\
 \t\tchar errstring[256];\\
@@ -509,7 +522,7 @@ cppmacros['CHECKSTRING']="""\
 \t\tPyErr_SetString(#modulename#_error, errstring);\\
 \t\t/*goto capi_fail;*/\\
 \t} else """
-cppmacros['CHECKSCALAR']="""\
+cppmacros['CHECKSCALAR'] = """\
 #define CHECKSCALAR(check,tcheck,name,show,var)\\
 \tif (!(check)) {\\
 \t\tchar errstring[256];\\
@@ -517,37 +530,38 @@ cppmacros['CHECKSCALAR']="""\
 \t\tPyErr_SetString(#modulename#_error,errstring);\\
 \t\t/*goto capi_fail;*/\\
 \t} else """
-## cppmacros['CHECKDIMS']="""\
-## #define CHECKDIMS(dims,rank) \\
-## \tfor (int i=0;i<(rank);i++)\\
-## \t\tif (dims[i]<0) {\\
-## \t\t\tfprintf(stderr,\"Unspecified array argument requires a complete dimension specification.\\n\");\\
-## \t\t\tgoto capi_fail;\\
-## \t\t}
-## """
-cppmacros['ARRSIZE']='#define ARRSIZE(dims,rank) (_PyArray_multiply_list(dims,rank))'
-cppmacros['OLDPYNUM']="""\
+# cppmacros['CHECKDIMS']="""\
+# define CHECKDIMS(dims,rank) \\
+# \tfor (int i=0;i<(rank);i++)\\
+# \t\tif (dims[i]<0) {\\
+# \t\t\tfprintf(stderr,\"Unspecified array argument requires a complete dimension specification.\\n\");\\
+# \t\t\tgoto capi_fail;\\
+# \t\t}
+# """
+cppmacros[
+    'ARRSIZE'] = '#define ARRSIZE(dims,rank) (_PyArray_multiply_list(dims,rank))'
+cppmacros['OLDPYNUM'] = """\
 #ifdef OLDPYNUM
 #error You need to intall Numeric Python version 13 or higher. Get it from http:/sourceforge.net/project/?group_id=1369
 #endif
 """
 ################# C functions ###############
 
-cfuncs['calcarrindex']="""\
+cfuncs['calcarrindex'] = """\
 static int calcarrindex(int *i,PyArrayObject *arr) {
 \tint k,ii = i[0];
 \tfor (k=1; k < PyArray_NDIM(arr); k++)
 \t\tii += (ii*(PyArray_DIM(arr,k) - 1)+i[k]); /* assuming contiguous arr */
 \treturn ii;
 }"""
-cfuncs['calcarrindextr']="""\
+cfuncs['calcarrindextr'] = """\
 static int calcarrindextr(int *i,PyArrayObject *arr) {
 \tint k,ii = i[PyArray_NDIM(arr)-1];
 \tfor (k=1; k < PyArray_NDIM(arr); k++)
 \t\tii += (ii*(PyArray_DIM(arr,PyArray_NDIM(arr)-k-1) - 1)+i[PyArray_NDIM(arr)-k-1]); /* assuming contiguous arr */
 \treturn ii;
 }"""
-cfuncs['forcomb']="""\
+cfuncs['forcomb'] = """\
 static struct { int nd;npy_intp *d;int *i,*i_tr,tr; } forcombcache;
 static int initforcomb(npy_intp *dims,int nd,int tr) {
   int k;
@@ -587,8 +601,8 @@ static int *nextforcomb(void) {
   if (forcombcache.tr) return i_tr;
   return i;
 }"""
-needs['try_pyarr_from_string']=['STRINGCOPYN', 'PRINTPYOBJERR', 'string']
-cfuncs['try_pyarr_from_string']="""\
+needs['try_pyarr_from_string'] = ['STRINGCOPYN', 'PRINTPYOBJERR', 'string']
+cfuncs['try_pyarr_from_string'] = """\
 static int try_pyarr_from_string(PyObject *obj,const string str) {
 \tPyArrayObject *arr = NULL;
 \tif (PyArray_Check(obj) && (!((arr = (PyArrayObject *)obj) == NULL)))
@@ -600,8 +614,8 @@ capi_fail:
 \treturn 0;
 }
 """
-needs['string_from_pyobj']=['string', 'STRINGMALLOC', 'STRINGCOPYN']
-cfuncs['string_from_pyobj']="""\
+needs['string_from_pyobj'] = ['string', 'STRINGMALLOC', 'STRINGCOPYN']
+cfuncs['string_from_pyobj'] = """\
 static int string_from_pyobj(string *str,int *len,const string inistr,PyObject *obj,const char *errmess) {
 \tPyArrayObject *arr = NULL;
 \tPyObject *tmp = NULL;
@@ -669,8 +683,8 @@ capi_fail:
 \treturn 0;
 }
 """
-needs['char_from_pyobj']=['int_from_pyobj']
-cfuncs['char_from_pyobj']="""\
+needs['char_from_pyobj'] = ['int_from_pyobj']
+cfuncs['char_from_pyobj'] = """\
 static int char_from_pyobj(char* v,PyObject *obj,const char *errmess) {
 \tint i=0;
 \tif (int_from_pyobj(&i,obj,errmess)) {
@@ -680,8 +694,8 @@ static int char_from_pyobj(char* v,PyObject *obj,const char *errmess) {
 \treturn 0;
 }
 """
-needs['signed_char_from_pyobj']=['int_from_pyobj', 'signed_char']
-cfuncs['signed_char_from_pyobj']="""\
+needs['signed_char_from_pyobj'] = ['int_from_pyobj', 'signed_char']
+cfuncs['signed_char_from_pyobj'] = """\
 static int signed_char_from_pyobj(signed_char* v,PyObject *obj,const char *errmess) {
 \tint i=0;
 \tif (int_from_pyobj(&i,obj,errmess)) {
@@ -691,8 +705,8 @@ static int signed_char_from_pyobj(signed_char* v,PyObject *obj,const char *errme
 \treturn 0;
 }
 """
-needs['short_from_pyobj']=['int_from_pyobj']
-cfuncs['short_from_pyobj']="""\
+needs['short_from_pyobj'] = ['int_from_pyobj']
+cfuncs['short_from_pyobj'] = """\
 static int short_from_pyobj(short* v,PyObject *obj,const char *errmess) {
 \tint i=0;
 \tif (int_from_pyobj(&i,obj,errmess)) {
@@ -702,7 +716,7 @@ static int short_from_pyobj(short* v,PyObject *obj,const char *errmess) {
 \treturn 0;
 }
 """
-cfuncs['int_from_pyobj']="""\
+cfuncs['int_from_pyobj'] = """\
 static int int_from_pyobj(int* v,PyObject *obj,const char *errmess) {
 \tPyObject* tmp = NULL;
 \tif (PyInt_Check(obj)) {
@@ -734,7 +748,7 @@ static int int_from_pyobj(int* v,PyObject *obj,const char *errmess) {
 \treturn 0;
 }
 """
-cfuncs['long_from_pyobj']="""\
+cfuncs['long_from_pyobj'] = """\
 static int long_from_pyobj(long* v,PyObject *obj,const char *errmess) {
 \tPyObject* tmp = NULL;
 \tif (PyInt_Check(obj)) {
@@ -766,8 +780,8 @@ static int long_from_pyobj(long* v,PyObject *obj,const char *errmess) {
 \treturn 0;
 }
 """
-needs['long_long_from_pyobj']=['long_long']
-cfuncs['long_long_from_pyobj']="""\
+needs['long_long_from_pyobj'] = ['long_long']
+cfuncs['long_long_from_pyobj'] = """\
 static int long_long_from_pyobj(long_long* v,PyObject *obj,const char *errmess) {
 \tPyObject* tmp = NULL;
 \tif (PyLong_Check(obj)) {
@@ -803,8 +817,8 @@ static int long_long_from_pyobj(long_long* v,PyObject *obj,const char *errmess)
 \treturn 0;
 }
 """
-needs['long_double_from_pyobj']=['double_from_pyobj', 'long_double']
-cfuncs['long_double_from_pyobj']="""\
+needs['long_double_from_pyobj'] = ['double_from_pyobj', 'long_double']
+cfuncs['long_double_from_pyobj'] = """\
 static int long_double_from_pyobj(long_double* v,PyObject *obj,const char *errmess) {
 \tdouble d=0;
 \tif (PyArray_CheckScalar(obj)){
@@ -824,7 +838,7 @@ static int long_double_from_pyobj(long_double* v,PyObject *obj,const char *errme
 \treturn 0;
 }
 """
-cfuncs['double_from_pyobj']="""\
+cfuncs['double_from_pyobj'] = """\
 static int double_from_pyobj(double* v,PyObject *obj,const char *errmess) {
 \tPyObject* tmp = NULL;
 \tif (PyFloat_Check(obj)) {
@@ -864,8 +878,8 @@ static int double_from_pyobj(double* v,PyObject *obj,const char *errmess) {
 \treturn 0;
 }
 """
-needs['float_from_pyobj']=['double_from_pyobj']
-cfuncs['float_from_pyobj']="""\
+needs['float_from_pyobj'] = ['double_from_pyobj']
+cfuncs['float_from_pyobj'] = """\
 static int float_from_pyobj(float* v,PyObject *obj,const char *errmess) {
 \tdouble d=0.0;
 \tif (double_from_pyobj(&d,obj,errmess)) {
@@ -875,9 +889,9 @@ static int float_from_pyobj(float* v,PyObject *obj,const char *errmess) {
 \treturn 0;
 }
 """
-needs['complex_long_double_from_pyobj']=['complex_long_double', 'long_double',
-                                         'complex_double_from_pyobj']
-cfuncs['complex_long_double_from_pyobj']="""\
+needs['complex_long_double_from_pyobj'] = ['complex_long_double', 'long_double',
+                                           'complex_double_from_pyobj']
+cfuncs['complex_long_double_from_pyobj'] = """\
 static int complex_long_double_from_pyobj(complex_long_double* v,PyObject *obj,const char *errmess) {
 \tcomplex_double cd={0.0,0.0};
 \tif (PyArray_CheckScalar(obj)){
@@ -899,8 +913,8 @@ static int complex_long_double_from_pyobj(complex_long_double* v,PyObject *obj,c
 \treturn 0;
 }
 """
-needs['complex_double_from_pyobj']=['complex_double']
-cfuncs['complex_double_from_pyobj']="""\
+needs['complex_double_from_pyobj'] = ['complex_double']
+cfuncs['complex_double_from_pyobj'] = """\
 static int complex_double_from_pyobj(complex_double* v,PyObject *obj,const char *errmess) {
 \tPy_complex c;
 \tif (PyComplex_Check(obj)) {
@@ -976,8 +990,9 @@ static int complex_double_from_pyobj(complex_double* v,PyObject *obj,const char
 \treturn 0;
 }
 """
-needs['complex_float_from_pyobj']=['complex_float', 'complex_double_from_pyobj']
-cfuncs['complex_float_from_pyobj']="""\
+needs['complex_float_from_pyobj'] = [
+    'complex_float', 'complex_double_from_pyobj']
+cfuncs['complex_float_from_pyobj'] = """\
 static int complex_float_from_pyobj(complex_float* v,PyObject *obj,const char *errmess) {
 \tcomplex_double cd={0.0,0.0};
 \tif (complex_double_from_pyobj(&cd,obj,errmess)) {
@@ -988,31 +1003,45 @@ static int complex_float_from_pyobj(complex_float* v,PyObject *obj,const char *e
 \treturn 0;
 }
 """
-needs['try_pyarr_from_char']=['pyobj_from_char1', 'TRYPYARRAYTEMPLATE']
-cfuncs['try_pyarr_from_char']='static int try_pyarr_from_char(PyObject* obj,char* v) {\n\tTRYPYARRAYTEMPLATE(char,\'c\');\n}\n'
-needs['try_pyarr_from_signed_char']=['TRYPYARRAYTEMPLATE', 'unsigned_char']
-cfuncs['try_pyarr_from_unsigned_char']='static int try_pyarr_from_unsigned_char(PyObject* obj,unsigned_char* v) {\n\tTRYPYARRAYTEMPLATE(unsigned_char,\'b\');\n}\n'
-needs['try_pyarr_from_signed_char']=['TRYPYARRAYTEMPLATE', 'signed_char']
-cfuncs['try_pyarr_from_signed_char']='static int try_pyarr_from_signed_char(PyObject* obj,signed_char* v) {\n\tTRYPYARRAYTEMPLATE(signed_char,\'1\');\n}\n'
-needs['try_pyarr_from_short']=['pyobj_from_short1', 'TRYPYARRAYTEMPLATE']
-cfuncs['try_pyarr_from_short']='static int try_pyarr_from_short(PyObject* obj,short* v) {\n\tTRYPYARRAYTEMPLATE(short,\'s\');\n}\n'
-needs['try_pyarr_from_int']=['pyobj_from_int1', 'TRYPYARRAYTEMPLATE']
-cfuncs['try_pyarr_from_int']='static int try_pyarr_from_int(PyObject* obj,int* v) {\n\tTRYPYARRAYTEMPLATE(int,\'i\');\n}\n'
-needs['try_pyarr_from_long']=['pyobj_from_long1', 'TRYPYARRAYTEMPLATE']
-cfuncs['try_pyarr_from_long']='static int try_pyarr_from_long(PyObject* obj,long* v) {\n\tTRYPYARRAYTEMPLATE(long,\'l\');\n}\n'
-needs['try_pyarr_from_long_long']=['pyobj_from_long_long1', 'TRYPYARRAYTEMPLATE', 'long_long']
-cfuncs['try_pyarr_from_long_long']='static int try_pyarr_from_long_long(PyObject* obj,long_long* v) {\n\tTRYPYARRAYTEMPLATE(long_long,\'L\');\n}\n'
-needs['try_pyarr_from_float']=['pyobj_from_float1', 'TRYPYARRAYTEMPLATE']
-cfuncs['try_pyarr_from_float']='static int try_pyarr_from_float(PyObject* obj,float* v) {\n\tTRYPYARRAYTEMPLATE(float,\'f\');\n}\n'
-needs['try_pyarr_from_double']=['pyobj_from_double1', 'TRYPYARRAYTEMPLATE']
-cfuncs['try_pyarr_from_double']='static int try_pyarr_from_double(PyObject* obj,double* v) {\n\tTRYPYARRAYTEMPLATE(double,\'d\');\n}\n'
-needs['try_pyarr_from_complex_float']=['pyobj_from_complex_float1', 'TRYCOMPLEXPYARRAYTEMPLATE', 'complex_float']
-cfuncs['try_pyarr_from_complex_float']='static int try_pyarr_from_complex_float(PyObject* obj,complex_float* v) {\n\tTRYCOMPLEXPYARRAYTEMPLATE(float,\'F\');\n}\n'
-needs['try_pyarr_from_complex_double']=['pyobj_from_complex_double1', 'TRYCOMPLEXPYARRAYTEMPLATE', 'complex_double']
-cfuncs['try_pyarr_from_complex_double']='static int try_pyarr_from_complex_double(PyObject* obj,complex_double* v) {\n\tTRYCOMPLEXPYARRAYTEMPLATE(double,\'D\');\n}\n'
+needs['try_pyarr_from_char'] = ['pyobj_from_char1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_char'] = 'static int try_pyarr_from_char(PyObject* obj,char* v) {\n\tTRYPYARRAYTEMPLATE(char,\'c\');\n}\n'
+needs['try_pyarr_from_signed_char'] = ['TRYPYARRAYTEMPLATE', 'unsigned_char']
+cfuncs[
+    'try_pyarr_from_unsigned_char'] = 'static int try_pyarr_from_unsigned_char(PyObject* obj,unsigned_char* v) {\n\tTRYPYARRAYTEMPLATE(unsigned_char,\'b\');\n}\n'
+needs['try_pyarr_from_signed_char'] = ['TRYPYARRAYTEMPLATE', 'signed_char']
+cfuncs[
+    'try_pyarr_from_signed_char'] = 'static int try_pyarr_from_signed_char(PyObject* obj,signed_char* v) {\n\tTRYPYARRAYTEMPLATE(signed_char,\'1\');\n}\n'
+needs['try_pyarr_from_short'] = ['pyobj_from_short1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_short'] = 'static int try_pyarr_from_short(PyObject* obj,short* v) {\n\tTRYPYARRAYTEMPLATE(short,\'s\');\n}\n'
+needs['try_pyarr_from_int'] = ['pyobj_from_int1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_int'] = 'static int try_pyarr_from_int(PyObject* obj,int* v) {\n\tTRYPYARRAYTEMPLATE(int,\'i\');\n}\n'
+needs['try_pyarr_from_long'] = ['pyobj_from_long1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_long'] = 'static int try_pyarr_from_long(PyObject* obj,long* v) {\n\tTRYPYARRAYTEMPLATE(long,\'l\');\n}\n'
+needs['try_pyarr_from_long_long'] = [
+    'pyobj_from_long_long1', 'TRYPYARRAYTEMPLATE', 'long_long']
+cfuncs[
+    'try_pyarr_from_long_long'] = 'static int try_pyarr_from_long_long(PyObject* obj,long_long* v) {\n\tTRYPYARRAYTEMPLATE(long_long,\'L\');\n}\n'
+needs['try_pyarr_from_float'] = ['pyobj_from_float1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_float'] = 'static int try_pyarr_from_float(PyObject* obj,float* v) {\n\tTRYPYARRAYTEMPLATE(float,\'f\');\n}\n'
+needs['try_pyarr_from_double'] = ['pyobj_from_double1', 'TRYPYARRAYTEMPLATE']
+cfuncs[
+    'try_pyarr_from_double'] = 'static int try_pyarr_from_double(PyObject* obj,double* v) {\n\tTRYPYARRAYTEMPLATE(double,\'d\');\n}\n'
+needs['try_pyarr_from_complex_float'] = [
+    'pyobj_from_complex_float1', 'TRYCOMPLEXPYARRAYTEMPLATE', 'complex_float']
+cfuncs[
+    'try_pyarr_from_complex_float'] = 'static int try_pyarr_from_complex_float(PyObject* obj,complex_float* v) {\n\tTRYCOMPLEXPYARRAYTEMPLATE(float,\'F\');\n}\n'
+needs['try_pyarr_from_complex_double'] = [
+    'pyobj_from_complex_double1', 'TRYCOMPLEXPYARRAYTEMPLATE', 'complex_double']
+cfuncs[
+    'try_pyarr_from_complex_double'] = 'static int try_pyarr_from_complex_double(PyObject* obj,complex_double* v) {\n\tTRYCOMPLEXPYARRAYTEMPLATE(double,\'D\');\n}\n'
 
-needs['create_cb_arglist']=['CFUNCSMESS', 'PRINTPYOBJERR', 'MINMAX']
-cfuncs['create_cb_arglist']="""\
+needs['create_cb_arglist'] = ['CFUNCSMESS', 'PRINTPYOBJERR', 'MINMAX']
+cfuncs['create_cb_arglist'] = """\
 static int create_cb_arglist(PyObject* fun,PyTupleObject* xa,const int maxnofargs,const int nofoptargs,int *nofargs,PyTupleObject **args,const char *errmess) {
 \tPyObject *tmp = NULL;
 \tPyObject *tmp_fun = NULL;
@@ -1115,25 +1144,29 @@ capi_fail:
 }
 """
 
+
 def buildcfuncs():
     from .capi_maps import c2capi_map
     for k in c2capi_map.keys():
-        m='pyarr_from_p_%s1'%k
-        cppmacros[m]='#define %s(v) (PyArray_SimpleNewFromData(0,NULL,%s,(char *)v))'%(m, c2capi_map[k])
-    k='string'
-    m='pyarr_from_p_%s1'%k
-    cppmacros[m]='#define %s(v,dims) (PyArray_SimpleNewFromData(1,dims,NPY_CHAR,(char *)v))'%(m)
+        m = 'pyarr_from_p_%s1' % k
+        cppmacros[
+            m] = '#define %s(v) (PyArray_SimpleNewFromData(0,NULL,%s,(char *)v))' % (m, c2capi_map[k])
+    k = 'string'
+    m = 'pyarr_from_p_%s1' % k
+    cppmacros[
+        m] = '#define %s(v,dims) (PyArray_SimpleNewFromData(1,dims,NPY_CHAR,(char *)v))' % (m)
 
 
 ############ Auxiliary functions for sorting needs ###################
 
-def append_needs(need,flag=1):
+def append_needs(need, flag=1):
     global outneeds, needs
     if isinstance(need, list):
         for n in need:
             append_needs(n, flag)
     elif isinstance(need, str):
-        if not need: return
+        if not need:
+            return
         if need in includes0:
             n = 'includes0'
         elif need in includes:
@@ -1153,72 +1186,76 @@ def append_needs(need,flag=1):
         elif need in commonhooks:
             n = 'commonhooks'
         else:
-            errmess('append_needs: unknown need %s\n'%(repr(need)))
+            errmess('append_needs: unknown need %s\n' % (repr(need)))
+            return
+        if need in outneeds[n]:
             return
-        if need in outneeds[n]: return
         if flag:
-            tmp={}
+            tmp = {}
             if need in needs:
                 for nn in needs[need]:
-                    t=append_needs(nn, 0)
+                    t = append_needs(nn, 0)
                     if isinstance(t, dict):
                         for nnn in t.keys():
                             if nnn in tmp:
-                                tmp[nnn]=tmp[nnn]+t[nnn]
+                                tmp[nnn] = tmp[nnn] + t[nnn]
                             else:
-                                tmp[nnn]=t[nnn]
+                                tmp[nnn] = t[nnn]
             for nn in tmp.keys():
                 for nnn in tmp[nn]:
                     if nnn not in outneeds[nn]:
-                        outneeds[nn]=[nnn]+outneeds[nn]
+                        outneeds[nn] = [nnn] + outneeds[nn]
             outneeds[n].append(need)
         else:
-            tmp={}
+            tmp = {}
             if need in needs:
                 for nn in needs[need]:
-                    t=append_needs(nn, flag)
+                    t = append_needs(nn, flag)
                     if isinstance(t, dict):
                         for nnn in t.keys():
                             if nnn in tmp:
-                                tmp[nnn]=t[nnn]+tmp[nnn]
+                                tmp[nnn] = t[nnn] + tmp[nnn]
                             else:
-                                tmp[nnn]=t[nnn]
+                                tmp[nnn] = t[nnn]
             if n not in tmp:
-                tmp[n]=[]
+                tmp[n] = []
             tmp[n].append(need)
             return tmp
     else:
-        errmess('append_needs: expected list or string but got :%s\n'%(repr(need)))
+        errmess('append_needs: expected list or string but got :%s\n' %
+                (repr(need)))
+
 
 def get_needs():
     global outneeds, needs
-    res={}
+    res = {}
     for n in outneeds.keys():
-        out=[]
-        saveout=copy.copy(outneeds[n])
-        while len(outneeds[n])>0:
+        out = []
+        saveout = copy.copy(outneeds[n])
+        while len(outneeds[n]) > 0:
             if outneeds[n][0] not in needs:
                 out.append(outneeds[n][0])
                 del outneeds[n][0]
             else:
-                flag=0
+                flag = 0
                 for k in outneeds[n][1:]:
                     if k in needs[outneeds[n][0]]:
-                        flag=1
+                        flag = 1
                         break
                 if flag:
-                    outneeds[n]=outneeds[n][1:]+[outneeds[n][0]]
+                    outneeds[n] = outneeds[n][1:] + [outneeds[n][0]]
                 else:
                     out.append(outneeds[n][0])
                     del outneeds[n][0]
-            if saveout and (0 not in map(lambda x, y:x==y, saveout, outneeds[n])) \
-                   and outneeds[n] != []:
+            if saveout and (0 not in map(lambda x, y: x == y, saveout, outneeds[n])) \
+                    and outneeds[n] != []:
                 print(n, saveout)
-                errmess('get_needs: no progress in sorting needs, probably circular dependence, skipping.\n')
-                out=out+saveout
+                errmess(
+                    'get_needs: no progress in sorting needs, probably circular dependence, skipping.\n')
+                out = out + saveout
                 break
-            saveout=copy.copy(outneeds[n])
-        if out==[]:
-            out=[n]
-        res[n]=out
+            saveout = copy.copy(outneeds[n])
+        if out == []:
+            out = [n]
+        res[n] = out
     return res
diff --git a/numpy/f2py/common_rules.py b/numpy/f2py/common_rules.py
index 0a4644465..1940d4211 100644
--- a/numpy/f2py/common_rules.py
+++ b/numpy/f2py/common_rules.py
@@ -27,20 +27,21 @@ from . import capi_maps
 from . import func2subr
 from .crackfortran import rmbadname
 
-def findcommonblocks(block,top=1):
+
+def findcommonblocks(block, top=1):
     ret = []
     if hascommon(block):
         for n in block['common'].keys():
-            vars={}
+            vars = {}
             for v in block['common'][n]:
-                vars[v]=block['vars'][v]
+                vars[v] = block['vars'][v]
             ret.append((n, block['common'][n], vars))
     elif hasbody(block):
         for b in block['body']:
-            ret=ret+findcommonblocks(b, 0)
+            ret = ret + findcommonblocks(b, 0)
     if top:
-        tret=[]
-        names=[]
+        tret = []
+        names = []
         for t in ret:
             if t[0] not in names:
                 names.append(t[0])
@@ -48,80 +49,102 @@ def findcommonblocks(block,top=1):
         return tret
     return ret
 
+
 def buildhooks(m):
-    ret = {'commonhooks':[],'initcommonhooks':[],'docs':['"COMMON blocks:\\n"']}
+    ret = {'commonhooks': [], 'initcommonhooks': [],
+           'docs': ['"COMMON blocks:\\n"']}
     fwrap = ['']
-    def fadd(line,s=fwrap): s[0] = '%s\n      %s'%(s[0], line)
+
+    def fadd(line, s=fwrap):
+        s[0] = '%s\n      %s' % (s[0], line)
     chooks = ['']
-    def cadd(line,s=chooks): s[0] = '%s\n%s'%(s[0], line)
+
+    def cadd(line, s=chooks):
+        s[0] = '%s\n%s' % (s[0], line)
     ihooks = ['']
-    def iadd(line,s=ihooks): s[0] = '%s\n%s'%(s[0], line)
+
+    def iadd(line, s=ihooks):
+        s[0] = '%s\n%s' % (s[0], line)
     doc = ['']
-    def dadd(line,s=doc): s[0] = '%s\n%s'%(s[0], line)
+
+    def dadd(line, s=doc):
+        s[0] = '%s\n%s' % (s[0], line)
     for (name, vnames, vars) in findcommonblocks(m):
         lower_name = name.lower()
         hnames, inames = [], []
         for n in vnames:
-            if isintent_hide(vars[n]): hnames.append(n)
-            else: inames.append(n)
+            if isintent_hide(vars[n]):
+                hnames.append(n)
+            else:
+                inames.append(n)
         if hnames:
-            outmess('\t\tConstructing COMMON block support for "%s"...\n\t\t  %s\n\t\t  Hidden: %s\n'%(name, ','.join(inames), ','.join(hnames)))
+            outmess('\t\tConstructing COMMON block support for "%s"...\n\t\t  %s\n\t\t  Hidden: %s\n' % (
+                name, ','.join(inames), ','.join(hnames)))
         else:
-            outmess('\t\tConstructing COMMON block support for "%s"...\n\t\t  %s\n'%(name, ','.join(inames)))
-        fadd('subroutine f2pyinit%s(setupfunc)'%name)
+            outmess('\t\tConstructing COMMON block support for "%s"...\n\t\t  %s\n' % (
+                name, ','.join(inames)))
+        fadd('subroutine f2pyinit%s(setupfunc)' % name)
         fadd('external setupfunc')
         for n in vnames:
             fadd(func2subr.var2fixfortran(vars, n))
-        if name=='_BLNK_':
-            fadd('common %s'%(','.join(vnames)))
+        if name == '_BLNK_':
+            fadd('common %s' % (','.join(vnames)))
         else:
-            fadd('common /%s/ %s'%(name, ','.join(vnames)))
-        fadd('call setupfunc(%s)'%(','.join(inames)))
+            fadd('common /%s/ %s' % (name, ','.join(vnames)))
+        fadd('call setupfunc(%s)' % (','.join(inames)))
         fadd('end\n')
-        cadd('static FortranDataDef f2py_%s_def[] = {'%(name))
-        idims=[]
+        cadd('static FortranDataDef f2py_%s_def[] = {' % (name))
+        idims = []
         for n in inames:
             ct = capi_maps.getctype(vars[n])
             at = capi_maps.c2capi_map[ct]
             dm = capi_maps.getarrdims(n, vars[n])
-            if dm['dims']: idims.append('(%s)'%(dm['dims']))
-            else: idims.append('')
-            dms=dm['dims'].strip()
-            if not dms: dms='-1'
-            cadd('\t{\"%s\",%s,{{%s}},%s},'%(n, dm['rank'], dms, at))
+            if dm['dims']:
+                idims.append('(%s)' % (dm['dims']))
+            else:
+                idims.append('')
+            dms = dm['dims'].strip()
+            if not dms:
+                dms = '-1'
+            cadd('\t{\"%s\",%s,{{%s}},%s},' % (n, dm['rank'], dms, at))
         cadd('\t{NULL}\n};')
         inames1 = rmbadname(inames)
-        inames1_tps = ','.join(['char *'+s for s in inames1])
-        cadd('static void f2py_setup_%s(%s) {'%(name, inames1_tps))
+        inames1_tps = ','.join(['char *' + s for s in inames1])
+        cadd('static void f2py_setup_%s(%s) {' % (name, inames1_tps))
         cadd('\tint i_f2py=0;')
         for n in inames1:
-            cadd('\tf2py_%s_def[i_f2py++].data = %s;'%(name, n))
+            cadd('\tf2py_%s_def[i_f2py++].data = %s;' % (name, n))
         cadd('}')
         if '_' in lower_name:
-            F_FUNC='F_FUNC_US'
+            F_FUNC = 'F_FUNC_US'
         else:
-            F_FUNC='F_FUNC'
-        cadd('extern void %s(f2pyinit%s,F2PYINIT%s)(void(*)(%s));'\
-             %(F_FUNC, lower_name, name.upper(),
-               ','.join(['char*']*len(inames1))))
-        cadd('static void f2py_init_%s(void) {'%name)
-        cadd('\t%s(f2pyinit%s,F2PYINIT%s)(f2py_setup_%s);'\
-             %(F_FUNC, lower_name, name.upper(), name))
+            F_FUNC = 'F_FUNC'
+        cadd('extern void %s(f2pyinit%s,F2PYINIT%s)(void(*)(%s));'
+             % (F_FUNC, lower_name, name.upper(),
+                ','.join(['char*'] * len(inames1))))
+        cadd('static void f2py_init_%s(void) {' % name)
+        cadd('\t%s(f2pyinit%s,F2PYINIT%s)(f2py_setup_%s);'
+             % (F_FUNC, lower_name, name.upper(), name))
         cadd('}\n')
-        iadd('\tF2PyDict_SetItemString(d, \"%s\", PyFortranObject_New(f2py_%s_def,f2py_init_%s));'%(name, name, name))
+        iadd('\tF2PyDict_SetItemString(d, \"%s\", PyFortranObject_New(f2py_%s_def,f2py_init_%s));' % (
+            name, name, name))
         tname = name.replace('_', '\\_')
-        dadd('\\subsection{Common block \\texttt{%s}}\n'%(tname))
+        dadd('\\subsection{Common block \\texttt{%s}}\n' % (tname))
         dadd('\\begin{description}')
         for n in inames:
-            dadd('\\item[]{{}\\verb@%s@{}}'%(capi_maps.getarrdocsign(n, vars[n])))
+            dadd('\\item[]{{}\\verb@%s@{}}' %
+                 (capi_maps.getarrdocsign(n, vars[n])))
             if hasnote(vars[n]):
                 note = vars[n]['note']
-                if isinstance(note, list): note='\n'.join(note)
-                dadd('--- %s'%(note))
+                if isinstance(note, list):
+                    note = '\n'.join(note)
+                dadd('--- %s' % (note))
         dadd('\\end{description}')
-        ret['docs'].append('"\t/%s/ %s\\n"'%(name, ','.join(map(lambda v, d:v+d, inames, idims))))
-    ret['commonhooks']=chooks
-    ret['initcommonhooks']=ihooks
-    ret['latexdoc']=doc[0]
-    if len(ret['docs'])<=1: ret['docs']=''
+        ret['docs'].append(
+            '"\t/%s/ %s\\n"' % (name, ','.join(map(lambda v, d: v + d, inames, idims))))
+    ret['commonhooks'] = chooks
+    ret['initcommonhooks'] = ihooks
+    ret['latexdoc'] = doc[0]
+    if len(ret['docs']) <= 1:
+        ret['docs'] = ''
     return ret, fwrap[0]
diff --git a/numpy/f2py/crackfortran.py b/numpy/f2py/crackfortran.py
index 3a5940d6f..9370a46b5 100755
--- a/numpy/f2py/crackfortran.py
+++ b/numpy/f2py/crackfortran.py
@@ -150,9 +150,9 @@ import platform
 
 from . import __version__
 from .auxfuncs import (
-    errmess, hascommon, isdouble, iscomplex, isexternal,isinteger,
+    errmess, hascommon, isdouble, iscomplex, isexternal, isinteger,
     isintent_aux, isintent_c, isintent_callback, isintent_in,
-    isintent_inout, isintent_inplace,islogical, isoptional,isscalar,
+    isintent_inout, isintent_inplace, islogical, isoptional, isscalar,
     isstring, isstringarray, l_or, show
 )
 
@@ -161,10 +161,10 @@ f2py_version = __version__.version
 
 # Global flags:
 strictf77 = 1          # Ignore `!' comments unless line[0]=='!'
-sourcecodeform = 'fix' # 'fix','free'
+sourcecodeform = 'fix'  # 'fix','free'
 quiet = 0              # Be verbose if 0 (Obsolete: not used any more)
 verbose = 1            # Be quiet if 0, extra verbose if > 1.
-tabchar = 4*' '
+tabchar = 4 * ' '
 pyffilename = ''
 f77modulename = ''
 skipemptyends = 0      # for old F77 programs without 'program' statement
@@ -181,7 +181,7 @@ filepositiontext = ''
 gotnextfile = 1
 groupcache = None
 groupcounter = 0
-grouplist = {groupcounter:[]}
+grouplist = {groupcounter: []}
 groupname = ''
 include_paths = []
 neededmodule = -1
@@ -206,7 +206,7 @@ def reset_global_f2py_vars():
     sourcecodeform = 'fix'
     quiet = 0
     verbose = 1
-    tabchar = 4*' '
+    tabchar = 4 * ' '
     pyffilename = ''
     f77modulename = ''
     skipemptyends = 0
@@ -215,8 +215,8 @@ def reset_global_f2py_vars():
     debug = []
     # variables
     groupcounter = 0
-    grouplist = {groupcounter:[]}
-    neededmodule =-1
+    grouplist = {groupcounter: []}
+    neededmodule = -1
     expectbegin = 1
     skipblocksuntil = -1
     usermodules = []
@@ -231,7 +231,7 @@ def reset_global_f2py_vars():
     previous_context = None
 
 
-def outmess(line,flag=1):
+def outmess(line, flag=1):
     global filepositiontext
 
     if not verbose:
@@ -241,13 +241,15 @@ def outmess(line,flag=1):
             sys.stdout.write(filepositiontext)
         sys.stdout.write(line)
 
-re._MAXCACHE=50
-defaultimplicitrules={}
-for c in "abcdefghopqrstuvwxyz$_": defaultimplicitrules[c]={'typespec':'real'}
-for c in "ijklmn": defaultimplicitrules[c]={'typespec':'integer'}
+re._MAXCACHE = 50
+defaultimplicitrules = {}
+for c in "abcdefghopqrstuvwxyz$_":
+    defaultimplicitrules[c] = {'typespec': 'real'}
+for c in "ijklmn":
+    defaultimplicitrules[c] = {'typespec': 'integer'}
 del c
-badnames={}
-invbadnames={}
+badnames = {}
+invbadnames = {}
 for n in ['int', 'double', 'float', 'char', 'short', 'long', 'void', 'case', 'while',
           'return', 'signed', 'unsigned', 'if', 'for', 'typedef', 'sizeof', 'union',
           'struct', 'static', 'register', 'new', 'break', 'do', 'goto', 'switch',
@@ -257,38 +259,51 @@ for n in ['int', 'double', 'float', 'char', 'short', 'long', 'void', 'case', 'wh
           'flen', 'fshape',
           'string', 'complex_double', 'float_double', 'stdin', 'stderr', 'stdout',
           'type', 'default']:
-    badnames[n]=n+'_bn'
-    invbadnames[n+'_bn']=n
+    badnames[n] = n + '_bn'
+    invbadnames[n + '_bn'] = n
+
 
 def rmbadname1(name):
     if name in badnames:
-        errmess('rmbadname1: Replacing "%s" with "%s".\n'%(name, badnames[name]))
+        errmess('rmbadname1: Replacing "%s" with "%s".\n' %
+                (name, badnames[name]))
         return badnames[name]
     return name
 
-def rmbadname(names): return [rmbadname1(_m) for _m in names]
+
+def rmbadname(names):
+    return [rmbadname1(_m) for _m in names]
+
 
 def undo_rmbadname1(name):
     if name in invbadnames:
-        errmess('undo_rmbadname1: Replacing "%s" with "%s".\n'\
-                %(name, invbadnames[name]))
+        errmess('undo_rmbadname1: Replacing "%s" with "%s".\n'
+                % (name, invbadnames[name]))
         return invbadnames[name]
     return name
 
-def undo_rmbadname(names): return [undo_rmbadname1(_m) for _m in names]
+
+def undo_rmbadname(names):
+    return [undo_rmbadname1(_m) for _m in names]
+
 
 def getextension(name):
-    i=name.rfind('.')
-    if i==-1: return ''
-    if '\\' in name[i:]: return ''
-    if '/' in name[i:]: return ''
-    return name[i+1:]
+    i = name.rfind('.')
+    if i == -1:
+        return ''
+    if '\\' in name[i:]:
+        return ''
+    if '/' in name[i:]:
+        return ''
+    return name[i + 1:]
 
 is_f_file = re.compile(r'.*[.](for|ftn|f77|f)\Z', re.I).match
 _has_f_header = re.compile(r'-[*]-\s*fortran\s*-[*]-', re.I).search
 _has_f90_header = re.compile(r'-[*]-\s*f90\s*-[*]-', re.I).search
 _has_fix_header = re.compile(r'-[*]-\s*fix\s*-[*]-', re.I).search
 _free_f90_start = re.compile(r'[^c*]\s*[^\s\d\t]', re.I).match
+
+
 def is_free_format(file):
     """Check if file is in free format Fortran."""
     # f90 allows both fixed and free format, assuming fixed unless
@@ -296,16 +311,16 @@ def is_free_format(file):
     result = 0
     f = open(file, 'r')
     line = f.readline()
-    n = 15 # the number of non-comment lines to scan for hints
+    n = 15  # the number of non-comment lines to scan for hints
     if _has_f_header(line):
         n = 0
     elif _has_f90_header(line):
         n = 0
         result = 1
-    while n>0 and line:
-        if line[0]!='!' and line.strip():
+    while n > 0 and line:
+        if line[0] != '!' and line.strip():
             n -= 1
-            if (line[0]!='\t' and _free_f90_start(line[:5])) or line[-2:-1]=='&':
+            if (line[0] != '\t' and _free_f90_start(line[:5])) or line[-2:-1] == '&':
                 result = 1
                 break
         line = f.readline()
@@ -313,8 +328,8 @@ def is_free_format(file):
     return result
 
 
-####### Read fortran (77,90) code
-def readfortrancode(ffile,dowithline=show,istop=1):
+# Read fortran (77,90) code
+def readfortrancode(ffile, dowithline=show, istop=1):
     """
     Read fortran codes from files and
      1) Get rid of comments, line continuations, and empty lines; lower cases.
@@ -325,138 +340,164 @@ def readfortrancode(ffile,dowithline=show,istop=1):
     global beginpattern, quiet, verbose, dolowercase, include_paths
 
     if not istop:
-        saveglobals=gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
-           beginpattern, quiet, verbose, dolowercase
-    if ffile==[]: return
+        saveglobals = gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
+            beginpattern, quiet, verbose, dolowercase
+    if ffile == []:
+        return
     localdolowercase = dolowercase
-    cont=0
-    finalline=''
-    ll=''
-    commentline=re.compile(r'(?P<line>([^"]*["][^"]*["][^"!]*|[^\']*\'[^\']*\'[^\'!]*|[^!\'"]*))!{1}(?P<rest>.*)')
-    includeline=re.compile(r'\s*include\s*(\'|")(?P<name>[^\'"]*)(\'|")', re.I)
-    cont1=re.compile(r'(?P<line>.*)&\s*\Z')
-    cont2=re.compile(r'(\s*&|)(?P<line>.*)')
+    cont = 0
+    finalline = ''
+    ll = ''
+    commentline = re.compile(
+        r'(?P<line>([^"]*["][^"]*["][^"!]*|[^\']*\'[^\']*\'[^\'!]*|[^!\'"]*))!{1}(?P<rest>.*)')
+    includeline = re.compile(
+        r'\s*include\s*(\'|")(?P<name>[^\'"]*)(\'|")', re.I)
+    cont1 = re.compile(r'(?P<line>.*)&\s*\Z')
+    cont2 = re.compile(r'(\s*&|)(?P<line>.*)')
     mline_mark = re.compile(r".*?'''")
-    if istop: dowithline('', -1)
-    ll, l1='', ''
-    spacedigits=[' '] + [str(_m) for _m in range(10)]
-    filepositiontext=''
-    fin=fileinput.FileInput(ffile)
+    if istop:
+        dowithline('', -1)
+    ll, l1 = '', ''
+    spacedigits = [' '] + [str(_m) for _m in range(10)]
+    filepositiontext = ''
+    fin = fileinput.FileInput(ffile)
     while True:
-        l=fin.readline()
-        if not l: break
+        l = fin.readline()
+        if not l:
+            break
         if fin.isfirstline():
-            filepositiontext=''
-            currentfilename=fin.filename()
-            gotnextfile=1
-            l1=l
-            strictf77=0
-            sourcecodeform='fix'
+            filepositiontext = ''
+            currentfilename = fin.filename()
+            gotnextfile = 1
+            l1 = l
+            strictf77 = 0
+            sourcecodeform = 'fix'
             ext = os.path.splitext(currentfilename)[1]
             if is_f_file(currentfilename) and \
-                   not (_has_f90_header(l) or _has_fix_header(l)):
-                strictf77=1
+                    not (_has_f90_header(l) or _has_fix_header(l)):
+                strictf77 = 1
             elif is_free_format(currentfilename) and not _has_fix_header(l):
-                sourcecodeform='free'
-            if strictf77: beginpattern=beginpattern77
-            else: beginpattern=beginpattern90
-            outmess('\tReading file %s (format:%s%s)\n'\
-                    %(repr(currentfilename), sourcecodeform,
-                      strictf77 and ',strict' or ''))
-
-        l=l.expandtabs().replace('\xa0', ' ')
-        while not l=='':                       # Get rid of newline characters
-            if l[-1] not in "\n\r\f": break
-            l=l[:-1]
+                sourcecodeform = 'free'
+            if strictf77:
+                beginpattern = beginpattern77
+            else:
+                beginpattern = beginpattern90
+            outmess('\tReading file %s (format:%s%s)\n'
+                    % (repr(currentfilename), sourcecodeform,
+                       strictf77 and ',strict' or ''))
+
+        l = l.expandtabs().replace('\xa0', ' ')
+        # Get rid of newline characters
+        while not l == '':
+            if l[-1] not in "\n\r\f":
+                break
+            l = l[:-1]
         if not strictf77:
-            r=commentline.match(l)
+            r = commentline.match(l)
             if r:
-                l=r.group('line')+' ' # Strip comments starting with `!'
-                rl=r.group('rest')
-                if rl[:4].lower()=='f2py': # f2py directive
-                    l = l + 4*' '
-                    r=commentline.match(rl[4:])
-                    if r: l=l+r.group('line')
-                    else: l = l + rl[4:]
-        if l.strip()=='': # Skip empty line
-            cont=0
+                l = r.group('line') + ' '  # Strip comments starting with `!'
+                rl = r.group('rest')
+                if rl[:4].lower() == 'f2py':  # f2py directive
+                    l = l + 4 * ' '
+                    r = commentline.match(rl[4:])
+                    if r:
+                        l = l + r.group('line')
+                    else:
+                        l = l + rl[4:]
+        if l.strip() == '':  # Skip empty line
+            cont = 0
             continue
-        if sourcecodeform=='fix':
+        if sourcecodeform == 'fix':
             if l[0] in ['*', 'c', '!', 'C', '#']:
-                if l[1:5].lower()=='f2py': # f2py directive
-                    l='     '+l[5:]
-                else: # Skip comment line
-                    cont=0
+                if l[1:5].lower() == 'f2py':  # f2py directive
+                    l = '     ' + l[5:]
+                else:  # Skip comment line
+                    cont = 0
                     continue
             elif strictf77:
-                if len(l)>72: l=l[:72]
+                if len(l) > 72:
+                    l = l[:72]
             if not (l[0] in spacedigits):
                 raise Exception('readfortrancode: Found non-(space,digit) char '
                                 'in the first column.\n\tAre you sure that '
                                 'this code is in fix form?\n\tline=%s' % repr(l))
 
-            if (not cont or strictf77) and (len(l)>5 and not l[5]==' '):
+            if (not cont or strictf77) and (len(l) > 5 and not l[5] == ' '):
                 # Continuation of a previous line
-                ll=ll+l[6:]
-                finalline=''
-                origfinalline=''
+                ll = ll + l[6:]
+                finalline = ''
+                origfinalline = ''
             else:
                 if not strictf77:
                     # F90 continuation
-                    r=cont1.match(l)
-                    if r: l=r.group('line') # Continuation follows ..
+                    r = cont1.match(l)
+                    if r:
+                        l = r.group('line')  # Continuation follows ..
                     if cont:
-                        ll=ll+cont2.match(l).group('line')
-                        finalline=''
-                        origfinalline=''
+                        ll = ll + cont2.match(l).group('line')
+                        finalline = ''
+                        origfinalline = ''
                     else:
-                        l='     '+l[5:] # clean up line beginning from possible digits.
-                        if localdolowercase: finalline=ll.lower()
-                        else: finalline=ll
-                        origfinalline=ll
-                        ll=l
-                    cont=(r is not None)
+                        # clean up line beginning from possible digits.
+                        l = '     ' + l[5:]
+                        if localdolowercase:
+                            finalline = ll.lower()
+                        else:
+                            finalline = ll
+                        origfinalline = ll
+                        ll = l
+                    cont = (r is not None)
                 else:
-                    l='     '+l[5:] # clean up line beginning from possible digits.
-                    if localdolowercase: finalline=ll.lower()
-                    else: finalline=ll
-                    origfinalline =ll
-                    ll=l
-
-        elif sourcecodeform=='free':
-            if not cont and ext=='.pyf' and mline_mark.match(l):
+                    # clean up line beginning from possible digits.
+                    l = '     ' + l[5:]
+                    if localdolowercase:
+                        finalline = ll.lower()
+                    else:
+                        finalline = ll
+                    origfinalline = ll
+                    ll = l
+
+        elif sourcecodeform == 'free':
+            if not cont and ext == '.pyf' and mline_mark.match(l):
                 l = l + '\n'
                 while True:
                     lc = fin.readline()
                     if not lc:
-                        errmess('Unexpected end of file when reading multiline\n')
+                        errmess(
+                            'Unexpected end of file when reading multiline\n')
                         break
                     l = l + lc
                     if mline_mark.match(lc):
                         break
                 l = l.rstrip()
-            r=cont1.match(l)
-            if r: l=r.group('line') # Continuation follows ..
+            r = cont1.match(l)
+            if r:
+                l = r.group('line')  # Continuation follows ..
             if cont:
-                ll=ll+cont2.match(l).group('line')
-                finalline=''
-                origfinalline=''
+                ll = ll + cont2.match(l).group('line')
+                finalline = ''
+                origfinalline = ''
             else:
-                if localdolowercase: finalline=ll.lower()
-                else: finalline=ll
-                origfinalline =ll
-                ll=l
-            cont=(r is not None)
+                if localdolowercase:
+                    finalline = ll.lower()
+                else:
+                    finalline = ll
+                origfinalline = ll
+                ll = l
+            cont = (r is not None)
         else:
-            raise ValueError("Flag sourcecodeform must be either 'fix' or 'free': %s"%repr(sourcecodeform))
-        filepositiontext='Line #%d in %s:"%s"\n\t' % (fin.filelineno()-1, currentfilename, l1)
-        m=includeline.match(origfinalline)
+            raise ValueError(
+                "Flag sourcecodeform must be either 'fix' or 'free': %s" % repr(sourcecodeform))
+        filepositiontext = 'Line #%d in %s:"%s"\n\t' % (
+            fin.filelineno() - 1, currentfilename, l1)
+        m = includeline.match(origfinalline)
         if m:
-            fn=m.group('name')
+            fn = m.group('name')
             if os.path.isfile(fn):
                 readfortrancode(fn, dowithline=dowithline, istop=0)
             else:
-                include_dirs = [os.path.dirname(currentfilename)] + include_paths
+                include_dirs = [
+                    os.path.dirname(currentfilename)] + include_paths
                 foundfile = 0
                 for inc_dir in include_dirs:
                     fn1 = os.path.join(inc_dir, fn)
@@ -465,18 +506,21 @@ def readfortrancode(ffile,dowithline=show,istop=1):
                         readfortrancode(fn1, dowithline=dowithline, istop=0)
                         break
                 if not foundfile:
-                    outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n'%(repr(fn), os.pathsep.join(include_dirs)))
+                    outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n' % (
+                        repr(fn), os.pathsep.join(include_dirs)))
         else:
             dowithline(finalline)
-        l1=ll
+        l1 = ll
     if localdolowercase:
-        finalline=ll.lower()
-    else: finalline=ll
+        finalline = ll.lower()
+    else:
+        finalline = ll
     origfinalline = ll
-    filepositiontext='Line #%d in %s:"%s"\n\t' % (fin.filelineno()-1, currentfilename, l1)
-    m=includeline.match(origfinalline)
+    filepositiontext = 'Line #%d in %s:"%s"\n\t' % (
+        fin.filelineno() - 1, currentfilename, l1)
+    m = includeline.match(origfinalline)
     if m:
-        fn=m.group('name')
+        fn = m.group('name')
         if os.path.isfile(fn):
             readfortrancode(fn, dowithline=dowithline, istop=0)
         else:
@@ -489,62 +533,94 @@ def readfortrancode(ffile,dowithline=show,istop=1):
                     readfortrancode(fn1, dowithline=dowithline, istop=0)
                     break
             if not foundfile:
-                outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n'%(repr(fn), os.pathsep.join(include_dirs)))
+                outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n' % (
+                    repr(fn), os.pathsep.join(include_dirs)))
     else:
         dowithline(finalline)
-    filepositiontext=''
+    filepositiontext = ''
     fin.close()
-    if istop: dowithline('', 1)
+    if istop:
+        dowithline('', 1)
     else:
         gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
-           beginpattern, quiet, verbose, dolowercase=saveglobals
+            beginpattern, quiet, verbose, dolowercase = saveglobals
 
-########### Crack line
-beforethisafter=r'\s*(?P<before>%s(?=\s*(\b(%s)\b)))'+ \
-                          r'\s*(?P<this>(\b(%s)\b))'+ \
-                          r'\s*(?P<after>%s)\s*\Z'
+# Crack line
+beforethisafter = r'\s*(?P<before>%s(?=\s*(\b(%s)\b)))' + \
+    r'\s*(?P<this>(\b(%s)\b))' + \
+    r'\s*(?P<after>%s)\s*\Z'
 ##
-fortrantypes='character|logical|integer|real|complex|double\s*(precision\s*(complex|)|complex)|type(?=\s*\([\w\s,=(*)]*\))|byte'
-typespattern=re.compile(beforethisafter%('', fortrantypes, fortrantypes, '.*'), re.I), 'type'
-typespattern4implicit=re.compile(beforethisafter%('', fortrantypes+'|static|automatic|undefined', fortrantypes+'|static|automatic|undefined', '.*'), re.I)
+fortrantypes = 'character|logical|integer|real|complex|double\s*(precision\s*(complex|)|complex)|type(?=\s*\([\w\s,=(*)]*\))|byte'
+typespattern = re.compile(
+    beforethisafter % ('', fortrantypes, fortrantypes, '.*'), re.I), 'type'
+typespattern4implicit = re.compile(beforethisafter % (
+    '', fortrantypes + '|static|automatic|undefined', fortrantypes + '|static|automatic|undefined', '.*'), re.I)
 #
-functionpattern=re.compile(beforethisafter%('([a-z]+[\w\s(=*+-/)]*?|)', 'function', 'function', '.*'), re.I), 'begin'
-subroutinepattern=re.compile(beforethisafter%('[a-z\s]*?', 'subroutine', 'subroutine', '.*'), re.I), 'begin'
-#modulepattern=re.compile(beforethisafter%('[a-z\s]*?','module','module','.*'),re.I),'begin'
+functionpattern = re.compile(beforethisafter % (
+    '([a-z]+[\w\s(=*+-/)]*?|)', 'function', 'function', '.*'), re.I), 'begin'
+subroutinepattern = re.compile(beforethisafter % (
+    '[a-z\s]*?', 'subroutine', 'subroutine', '.*'), re.I), 'begin'
+# modulepattern=re.compile(beforethisafter%('[a-z\s]*?','module','module','.*'),re.I),'begin'
 #
-groupbegins77=r'program|block\s*data'
-beginpattern77=re.compile(beforethisafter%('', groupbegins77, groupbegins77, '.*'), re.I), 'begin'
-groupbegins90=groupbegins77+r'|module(?!\s*procedure)|python\s*module|interface|type(?!\s*\()'
-beginpattern90=re.compile(beforethisafter%('', groupbegins90, groupbegins90, '.*'), re.I), 'begin'
-groupends=r'end|endprogram|endblockdata|endmodule|endpythonmodule|endinterface'
-endpattern=re.compile(beforethisafter%('', groupends, groupends, '[\w\s]*'), re.I), 'end'
-#endifs='end\s*(if|do|where|select|while|forall)'
-endifs='(end\s*(if|do|where|select|while|forall))|(module\s*procedure)'
-endifpattern=re.compile(beforethisafter%('[\w]*?', endifs, endifs, '[\w\s]*'), re.I), 'endif'
+groupbegins77 = r'program|block\s*data'
+beginpattern77 = re.compile(
+    beforethisafter % ('', groupbegins77, groupbegins77, '.*'), re.I), 'begin'
+groupbegins90 = groupbegins77 + \
+    r'|module(?!\s*procedure)|python\s*module|interface|type(?!\s*\()'
+beginpattern90 = re.compile(
+    beforethisafter % ('', groupbegins90, groupbegins90, '.*'), re.I), 'begin'
+groupends = r'end|endprogram|endblockdata|endmodule|endpythonmodule|endinterface'
+endpattern = re.compile(
+    beforethisafter % ('', groupends, groupends, '[\w\s]*'), re.I), 'end'
+# endifs='end\s*(if|do|where|select|while|forall)'
+endifs = '(end\s*(if|do|where|select|while|forall))|(module\s*procedure)'
+endifpattern = re.compile(
+    beforethisafter % ('[\w]*?', endifs, endifs, '[\w\s]*'), re.I), 'endif'
 #
-implicitpattern=re.compile(beforethisafter%('', 'implicit', 'implicit', '.*'), re.I), 'implicit'
-dimensionpattern=re.compile(beforethisafter%('', 'dimension|virtual', 'dimension|virtual', '.*'), re.I), 'dimension'
-externalpattern=re.compile(beforethisafter%('', 'external', 'external', '.*'), re.I), 'external'
-optionalpattern=re.compile(beforethisafter%('', 'optional', 'optional', '.*'), re.I), 'optional'
-requiredpattern=re.compile(beforethisafter%('', 'required', 'required', '.*'), re.I), 'required'
-publicpattern=re.compile(beforethisafter%('', 'public', 'public', '.*'), re.I), 'public'
-privatepattern=re.compile(beforethisafter%('', 'private', 'private', '.*'), re.I), 'private'
-intrisicpattern=re.compile(beforethisafter%('', 'intrisic', 'intrisic', '.*'), re.I), 'intrisic'
-intentpattern=re.compile(beforethisafter%('', 'intent|depend|note|check', 'intent|depend|note|check', '\s*\(.*?\).*'), re.I), 'intent'
-parameterpattern=re.compile(beforethisafter%('', 'parameter', 'parameter', '\s*\(.*'), re.I), 'parameter'
-datapattern=re.compile(beforethisafter%('', 'data', 'data', '.*'), re.I), 'data'
-callpattern=re.compile(beforethisafter%('', 'call', 'call', '.*'), re.I), 'call'
-entrypattern=re.compile(beforethisafter%('', 'entry', 'entry', '.*'), re.I), 'entry'
-callfunpattern=re.compile(beforethisafter%('', 'callfun', 'callfun', '.*'), re.I), 'callfun'
-commonpattern=re.compile(beforethisafter%('', 'common', 'common', '.*'), re.I), 'common'
-usepattern=re.compile(beforethisafter%('', 'use', 'use', '.*'), re.I), 'use'
-containspattern=re.compile(beforethisafter%('', 'contains', 'contains', ''), re.I), 'contains'
-formatpattern=re.compile(beforethisafter%('', 'format', 'format', '.*'), re.I), 'format'
-## Non-fortran and f2py-specific statements
-f2pyenhancementspattern=re.compile(beforethisafter%('', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', '.*'), re.I|re.S), 'f2pyenhancements'
-multilinepattern = re.compile(r"\s*(?P<before>''')(?P<this>.*?)(?P<after>''')\s*\Z", re.S), 'multiline'
+implicitpattern = re.compile(
+    beforethisafter % ('', 'implicit', 'implicit', '.*'), re.I), 'implicit'
+dimensionpattern = re.compile(beforethisafter % (
+    '', 'dimension|virtual', 'dimension|virtual', '.*'), re.I), 'dimension'
+externalpattern = re.compile(
+    beforethisafter % ('', 'external', 'external', '.*'), re.I), 'external'
+optionalpattern = re.compile(
+    beforethisafter % ('', 'optional', 'optional', '.*'), re.I), 'optional'
+requiredpattern = re.compile(
+    beforethisafter % ('', 'required', 'required', '.*'), re.I), 'required'
+publicpattern = re.compile(
+    beforethisafter % ('', 'public', 'public', '.*'), re.I), 'public'
+privatepattern = re.compile(
+    beforethisafter % ('', 'private', 'private', '.*'), re.I), 'private'
+intrisicpattern = re.compile(
+    beforethisafter % ('', 'intrisic', 'intrisic', '.*'), re.I), 'intrisic'
+intentpattern = re.compile(beforethisafter % (
+    '', 'intent|depend|note|check', 'intent|depend|note|check', '\s*\(.*?\).*'), re.I), 'intent'
+parameterpattern = re.compile(
+    beforethisafter % ('', 'parameter', 'parameter', '\s*\(.*'), re.I), 'parameter'
+datapattern = re.compile(
+    beforethisafter % ('', 'data', 'data', '.*'), re.I), 'data'
+callpattern = re.compile(
+    beforethisafter % ('', 'call', 'call', '.*'), re.I), 'call'
+entrypattern = re.compile(
+    beforethisafter % ('', 'entry', 'entry', '.*'), re.I), 'entry'
+callfunpattern = re.compile(
+    beforethisafter % ('', 'callfun', 'callfun', '.*'), re.I), 'callfun'
+commonpattern = re.compile(
+    beforethisafter % ('', 'common', 'common', '.*'), re.I), 'common'
+usepattern = re.compile(
+    beforethisafter % ('', 'use', 'use', '.*'), re.I), 'use'
+containspattern = re.compile(
+    beforethisafter % ('', 'contains', 'contains', ''), re.I), 'contains'
+formatpattern = re.compile(
+    beforethisafter % ('', 'format', 'format', '.*'), re.I), 'format'
+# Non-fortran and f2py-specific statements
+f2pyenhancementspattern = re.compile(beforethisafter % ('', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef',
+                                                        'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', '.*'), re.I | re.S), 'f2pyenhancements'
+multilinepattern = re.compile(
+    r"\s*(?P<before>''')(?P<this>.*?)(?P<after>''')\s*\Z", re.S), 'multiline'
 ##
 
+
 def _simplifyargs(argsline):
     a = []
     for n in markoutercomma(argsline).split('@,@'):
@@ -554,7 +630,9 @@ def _simplifyargs(argsline):
     return ','.join(a)
 
 crackline_re_1 = re.compile(r'\s*(?P<result>\b[a-z]+[\w]*\b)\s*[=].*', re.I)
-def crackline(line,reset=0):
+
+
+def crackline(line, reset=0):
     """
     reset=-1  --- initialize
     reset=0   --- crack the line
@@ -569,44 +647,49 @@ def crackline(line,reset=0):
     if ';' in line and not (f2pyenhancementspattern[0].match(line) or
                             multilinepattern[0].match(line)):
         for l in line.split(';'):
-            assert reset==0, repr(reset) # XXX: non-zero reset values need testing
+            # XXX: non-zero reset values need testing
+            assert reset == 0, repr(reset)
             crackline(l, reset)
         return
-    if reset<0:
-        groupcounter=0
-        groupname={groupcounter:''}
-        groupcache={groupcounter:{}}
-        grouplist={groupcounter:[]}
-        groupcache[groupcounter]['body']=[]
-        groupcache[groupcounter]['vars']={}
-        groupcache[groupcounter]['block']=''
-        groupcache[groupcounter]['name']=''
-        neededmodule=-1
-        skipblocksuntil=-1
+    if reset < 0:
+        groupcounter = 0
+        groupname = {groupcounter: ''}
+        groupcache = {groupcounter: {}}
+        grouplist = {groupcounter: []}
+        groupcache[groupcounter]['body'] = []
+        groupcache[groupcounter]['vars'] = {}
+        groupcache[groupcounter]['block'] = ''
+        groupcache[groupcounter]['name'] = ''
+        neededmodule = -1
+        skipblocksuntil = -1
         return
-    if reset>0:
-        fl=0
-        if f77modulename and neededmodule==groupcounter: fl=2
-        while groupcounter>fl:
-            outmess('crackline: groupcounter=%s groupname=%s\n'%(repr(groupcounter), repr(groupname)))
-            outmess('crackline: Mismatch of blocks encountered. Trying to fix it by assuming "end" statement.\n')
-            grouplist[groupcounter-1].append(groupcache[groupcounter])
-            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+    if reset > 0:
+        fl = 0
+        if f77modulename and neededmodule == groupcounter:
+            fl = 2
+        while groupcounter > fl:
+            outmess('crackline: groupcounter=%s groupname=%s\n' %
+                    (repr(groupcounter), repr(groupname)))
+            outmess(
+                'crackline: Mismatch of blocks encountered. Trying to fix it by assuming "end" statement.\n')
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
             del grouplist[groupcounter]
-            groupcounter=groupcounter-1
-        if f77modulename and neededmodule==groupcounter:
-            grouplist[groupcounter-1].append(groupcache[groupcounter])
-            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            groupcounter = groupcounter - 1
+        if f77modulename and neededmodule == groupcounter:
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
             del grouplist[groupcounter]
-            groupcounter=groupcounter-1 # end interface
-            grouplist[groupcounter-1].append(groupcache[groupcounter])
-            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            groupcounter = groupcounter - 1  # end interface
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
             del grouplist[groupcounter]
-            groupcounter=groupcounter-1 # end module
-            neededmodule=-1
+            groupcounter = groupcounter - 1  # end module
+            neededmodule = -1
         return
-    if line=='': return
-    flag=0
+    if line == '':
+        return
+    flag = 0
     for pat in [dimensionpattern, externalpattern, intentpattern, optionalpattern,
                 requiredpattern,
                 parameterpattern, datapattern, publicpattern, privatepattern,
@@ -623,188 +706,225 @@ def crackline(line,reset=0):
         m = pat[0].match(line)
         if m:
             break
-        flag=flag+1
+        flag = flag + 1
     if not m:
         re_1 = crackline_re_1
-        if 0<=skipblocksuntil<=groupcounter:return
+        if 0 <= skipblocksuntil <= groupcounter:
+            return
         if 'externals' in groupcache[groupcounter]:
             for name in groupcache[groupcounter]['externals']:
                 if name in invbadnames:
-                    name=invbadnames[name]
+                    name = invbadnames[name]
                 if 'interfaced' in groupcache[groupcounter] and name in groupcache[groupcounter]['interfaced']:
                     continue
-                m1=re.match(r'(?P<before>[^"]*)\b%s\b\s*@\(@(?P<args>[^@]*)@\)@.*\Z'%name, markouterparen(line), re.I)
+                m1 = re.match(
+                    r'(?P<before>[^"]*)\b%s\b\s*@\(@(?P<args>[^@]*)@\)@.*\Z' % name, markouterparen(line), re.I)
                 if m1:
                     m2 = re_1.match(m1.group('before'))
                     a = _simplifyargs(m1.group('args'))
                     if m2:
-                        line='callfun %s(%s) result (%s)'%(name, a, m2.group('result'))
-                    else: line='callfun %s(%s)'%(name, a)
+                        line = 'callfun %s(%s) result (%s)' % (
+                            name, a, m2.group('result'))
+                    else:
+                        line = 'callfun %s(%s)' % (name, a)
                     m = callfunpattern[0].match(line)
                     if not m:
-                        outmess('crackline: could not resolve function call for line=%s.\n'%repr(line))
+                        outmess(
+                            'crackline: could not resolve function call for line=%s.\n' % repr(line))
                         return
                     analyzeline(m, 'callfun', line)
                     return
-        if verbose>1 or (verbose==1 and currentfilename.lower().endswith('.pyf')):
+        if verbose > 1 or (verbose == 1 and currentfilename.lower().endswith('.pyf')):
             previous_context = None
-            outmess('crackline:%d: No pattern for line\n'%(groupcounter))
+            outmess('crackline:%d: No pattern for line\n' % (groupcounter))
         return
-    elif pat[1]=='end':
-        if 0<=skipblocksuntil<groupcounter:
-            groupcounter=groupcounter-1
-            if skipblocksuntil<=groupcounter: return
-        if groupcounter<=0:
+    elif pat[1] == 'end':
+        if 0 <= skipblocksuntil < groupcounter:
+            groupcounter = groupcounter - 1
+            if skipblocksuntil <= groupcounter:
+                return
+        if groupcounter <= 0:
             raise Exception('crackline: groupcounter(=%s) is nonpositive. '
-                            'Check the blocks.' \
+                            'Check the blocks.'
                             % (groupcounter))
         m1 = beginpattern[0].match((line))
-        if (m1) and (not m1.group('this')==groupname[groupcounter]):
+        if (m1) and (not m1.group('this') == groupname[groupcounter]):
             raise Exception('crackline: End group %s does not match with '
-                            'previous Begin group %s\n\t%s' % \
+                            'previous Begin group %s\n\t%s' %
                             (repr(m1.group('this')), repr(groupname[groupcounter]),
                              filepositiontext)
                             )
-        if skipblocksuntil==groupcounter:
-            skipblocksuntil=-1
-        grouplist[groupcounter-1].append(groupcache[groupcounter])
-        grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+        if skipblocksuntil == groupcounter:
+            skipblocksuntil = -1
+        grouplist[groupcounter - 1].append(groupcache[groupcounter])
+        grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
         del grouplist[groupcounter]
-        groupcounter=groupcounter-1
+        groupcounter = groupcounter - 1
         if not skipemptyends:
-            expectbegin=1
+            expectbegin = 1
     elif pat[1] == 'begin':
-        if 0<=skipblocksuntil<=groupcounter:
-            groupcounter=groupcounter+1
+        if 0 <= skipblocksuntil <= groupcounter:
+            groupcounter = groupcounter + 1
             return
-        gotnextfile=0
+        gotnextfile = 0
         analyzeline(m, pat[1], line)
-        expectbegin=0
-    elif pat[1]=='endif':
+        expectbegin = 0
+    elif pat[1] == 'endif':
         pass
-    elif pat[1]=='contains':
-        if ignorecontains: return
-        if 0<=skipblocksuntil<=groupcounter: return
-        skipblocksuntil=groupcounter
+    elif pat[1] == 'contains':
+        if ignorecontains:
+            return
+        if 0 <= skipblocksuntil <= groupcounter:
+            return
+        skipblocksuntil = groupcounter
     else:
-        if 0<=skipblocksuntil<=groupcounter:return
+        if 0 <= skipblocksuntil <= groupcounter:
+            return
         analyzeline(m, pat[1], line)
 
+
 def markouterparen(line):
-    l='';f=0
+    l = ''
+    f = 0
     for c in line:
-        if c=='(':
-            f=f+1
-            if f==1: l=l+'@(@'; continue
-        elif c==')':
-            f=f-1
-            if f==0: l=l+'@)@'; continue
-        l=l+c
+        if c == '(':
+            f = f + 1
+            if f == 1:
+                l = l + '@(@'
+                continue
+        elif c == ')':
+            f = f - 1
+            if f == 0:
+                l = l + '@)@'
+                continue
+        l = l + c
     return l
-def markoutercomma(line,comma=','):
-    l='';f=0
-    cc=''
+
+
+def markoutercomma(line, comma=','):
+    l = ''
+    f = 0
+    cc = ''
     for c in line:
-        if (not cc or cc==')') and c=='(':
-            f=f+1
+        if (not cc or cc == ')') and c == '(':
+            f = f + 1
             cc = ')'
-        elif not cc and c=='\'' and (not l or l[-1]!='\\'):
-            f=f+1
+        elif not cc and c == '\'' and (not l or l[-1] != '\\'):
+            f = f + 1
             cc = '\''
-        elif c==cc:
-            f=f-1
-            if f==0:
-                cc=''
-        elif c==comma and f==0:
-            l=l+'@'+comma+'@'
+        elif c == cc:
+            f = f - 1
+            if f == 0:
+                cc = ''
+        elif c == comma and f == 0:
+            l = l + '@' + comma + '@'
             continue
-        l=l+c
+        l = l + c
     assert not f, repr((f, line, l, cc))
     return l
+
+
 def unmarkouterparen(line):
     r = line.replace('@(@', '(').replace('@)@', ')')
     return r
-def appenddecl(decl,decl2,force=1):
-    if not decl: decl={}
-    if not decl2: return decl
-    if decl is decl2: return decl
+
+
+def appenddecl(decl, decl2, force=1):
+    if not decl:
+        decl = {}
+    if not decl2:
+        return decl
+    if decl is decl2:
+        return decl
     for k in list(decl2.keys()):
-        if k=='typespec':
+        if k == 'typespec':
             if force or k not in decl:
-                decl[k]=decl2[k]
-        elif k=='attrspec':
+                decl[k] = decl2[k]
+        elif k == 'attrspec':
             for l in decl2[k]:
-                decl=setattrspec(decl, l, force)
-        elif k=='kindselector':
-            decl=setkindselector(decl, decl2[k], force)
-        elif k=='charselector':
-            decl=setcharselector(decl, decl2[k], force)
+                decl = setattrspec(decl, l, force)
+        elif k == 'kindselector':
+            decl = setkindselector(decl, decl2[k], force)
+        elif k == 'charselector':
+            decl = setcharselector(decl, decl2[k], force)
         elif k in ['=', 'typename']:
             if force or k not in decl:
-                decl[k]=decl2[k]
-        elif k=='note':
+                decl[k] = decl2[k]
+        elif k == 'note':
             pass
         elif k in ['intent', 'check', 'dimension', 'optional', 'required']:
-            errmess('appenddecl: "%s" not implemented.\n'%k)
+            errmess('appenddecl: "%s" not implemented.\n' % k)
         else:
-            raise Exception('appenddecl: Unknown variable definition key:' + \
+            raise Exception('appenddecl: Unknown variable definition key:' +
                             str(k))
     return decl
 
-selectpattern=re.compile(r'\s*(?P<this>(@\(@.*?@\)@|[*][\d*]+|[*]\s*@\(@.*?@\)@|))(?P<after>.*)\Z', re.I)
-nameargspattern=re.compile(r'\s*(?P<name>\b[\w$]+\b)\s*(@\(@\s*(?P<args>[\w\s,]*)\s*@\)@|)\s*((result(\s*@\(@\s*(?P<result>\b[\w$]+\b)\s*@\)@|))|(bind\s*@\(@\s*(?P<bind>.*)\s*@\)@))*\s*\Z', re.I)
-callnameargspattern=re.compile(r'\s*(?P<name>\b[\w$]+\b)\s*@\(@\s*(?P<args>.*)\s*@\)@\s*\Z', re.I)
-real16pattern = re.compile(r'([-+]?(?:\d+(?:\.\d*)?|\d*\.\d+))[dD]((?:[-+]?\d+)?)')
-real8pattern = re.compile(r'([-+]?((?:\d+(?:\.\d*)?|\d*\.\d+))[eE]((?:[-+]?\d+)?)|(\d+\.\d*))')
+selectpattern = re.compile(
+    r'\s*(?P<this>(@\(@.*?@\)@|[*][\d*]+|[*]\s*@\(@.*?@\)@|))(?P<after>.*)\Z', re.I)
+nameargspattern = re.compile(
+    r'\s*(?P<name>\b[\w$]+\b)\s*(@\(@\s*(?P<args>[\w\s,]*)\s*@\)@|)\s*((result(\s*@\(@\s*(?P<result>\b[\w$]+\b)\s*@\)@|))|(bind\s*@\(@\s*(?P<bind>.*)\s*@\)@))*\s*\Z', re.I)
+callnameargspattern = re.compile(
+    r'\s*(?P<name>\b[\w$]+\b)\s*@\(@\s*(?P<args>.*)\s*@\)@\s*\Z', re.I)
+real16pattern = re.compile(
+    r'([-+]?(?:\d+(?:\.\d*)?|\d*\.\d+))[dD]((?:[-+]?\d+)?)')
+real8pattern = re.compile(
+    r'([-+]?((?:\d+(?:\.\d*)?|\d*\.\d+))[eE]((?:[-+]?\d+)?)|(\d+\.\d*))')
 
 _intentcallbackpattern = re.compile(r'intent\s*\(.*?\bcallback\b', re.I)
+
+
 def _is_intent_callback(vdecl):
     for a in vdecl.get('attrspec', []):
         if _intentcallbackpattern.match(a):
             return 1
     return 0
 
+
 def _resolvenameargspattern(line):
     line = markouterparen(line)
-    m1=nameargspattern.match(line)
+    m1 = nameargspattern.match(line)
     if m1:
         return m1.group('name'), m1.group('args'), m1.group('result'), m1.group('bind')
-    m1=callnameargspattern.match(line)
+    m1 = callnameargspattern.match(line)
     if m1:
         return m1.group('name'), m1.group('args'), None, None
     return None, [], None, None
 
+
 def analyzeline(m, case, line):
     global groupcounter, groupname, groupcache, grouplist, filepositiontext
     global currentfilename, f77modulename, neededinterface, neededmodule
     global expectbegin, gotnextfile, previous_context
 
-    block=m.group('this')
+    block = m.group('this')
     if case != 'multiline':
         previous_context = None
     if expectbegin and case not in ['begin', 'call', 'callfun', 'type'] \
-       and not skipemptyends and groupcounter<1:
-        newname=os.path.basename(currentfilename).split('.')[0]
-        outmess('analyzeline: no group yet. Creating program group with name "%s".\n'%newname)
-        gotnextfile=0
-        groupcounter=groupcounter+1
-        groupname[groupcounter]='program'
-        groupcache[groupcounter]={}
-        grouplist[groupcounter]=[]
-        groupcache[groupcounter]['body']=[]
-        groupcache[groupcounter]['vars']={}
-        groupcache[groupcounter]['block']='program'
-        groupcache[groupcounter]['name']=newname
-        groupcache[groupcounter]['from']='fromsky'
-        expectbegin=0
+       and not skipemptyends and groupcounter < 1:
+        newname = os.path.basename(currentfilename).split('.')[0]
+        outmess(
+            'analyzeline: no group yet. Creating program group with name "%s".\n' % newname)
+        gotnextfile = 0
+        groupcounter = groupcounter + 1
+        groupname[groupcounter] = 'program'
+        groupcache[groupcounter] = {}
+        grouplist[groupcounter] = []
+        groupcache[groupcounter]['body'] = []
+        groupcache[groupcounter]['vars'] = {}
+        groupcache[groupcounter]['block'] = 'program'
+        groupcache[groupcounter]['name'] = newname
+        groupcache[groupcounter]['from'] = 'fromsky'
+        expectbegin = 0
     if case in ['begin', 'call', 'callfun']:
         # Crack line => block,name,args,result
         block = block.lower()
-        if re.match(r'block\s*data', block, re.I): block='block data'
-        if re.match(r'python\s*module', block, re.I): block='python module'
+        if re.match(r'block\s*data', block, re.I):
+            block = 'block data'
+        if re.match(r'python\s*module', block, re.I):
+            block = 'python module'
         name, args, result, bind = _resolvenameargspattern(m.group('after'))
         if name is None:
-            if block=='block data':
+            if block == 'block data':
                 name = '_BLOCK_DATA_'
             else:
                 name = ''
@@ -812,398 +932,492 @@ def analyzeline(m, case, line):
                 outmess('analyzeline: No name/args pattern found for line.\n')
 
         previous_context = (block, name, groupcounter)
-        if args: args=rmbadname([x.strip() for x in markoutercomma(args).split('@,@')])
-        else: args=[]
+        if args:
+            args = rmbadname([x.strip()
+                              for x in markoutercomma(args).split('@,@')])
+        else:
+            args = []
         if '' in args:
             while '' in args:
                 args.remove('')
-            outmess('analyzeline: argument list is malformed (missing argument).\n')
+            outmess(
+                'analyzeline: argument list is malformed (missing argument).\n')
 
         # end of crack line => block,name,args,result
-        needmodule=0
-        needinterface=0
+        needmodule = 0
+        needinterface = 0
 
         if case in ['call', 'callfun']:
-            needinterface=1
+            needinterface = 1
             if 'args' not in groupcache[groupcounter]:
                 return
             if name not in groupcache[groupcounter]['args']:
                 return
             for it in grouplist[groupcounter]:
-                if it['name']==name:
+                if it['name'] == name:
                     return
             if name in groupcache[groupcounter]['interfaced']:
                 return
-            block={'call':'subroutine','callfun':'function'}[case]
-        if f77modulename and neededmodule==-1 and groupcounter<=1:
-            neededmodule=groupcounter+2
-            needmodule=1
+            block = {'call': 'subroutine', 'callfun': 'function'}[case]
+        if f77modulename and neededmodule == -1 and groupcounter <= 1:
+            neededmodule = groupcounter + 2
+            needmodule = 1
             if block != 'interface':
-                needinterface=1
+                needinterface = 1
         # Create new block(s)
-        groupcounter=groupcounter+1
-        groupcache[groupcounter]={}
-        grouplist[groupcounter]=[]
+        groupcounter = groupcounter + 1
+        groupcache[groupcounter] = {}
+        grouplist[groupcounter] = []
         if needmodule:
-            if verbose>1:
-                outmess('analyzeline: Creating module block %s\n'%repr(f77modulename), 0)
-            groupname[groupcounter]='module'
-            groupcache[groupcounter]['block']='python module'
-            groupcache[groupcounter]['name']=f77modulename
-            groupcache[groupcounter]['from']=''
-            groupcache[groupcounter]['body']=[]
-            groupcache[groupcounter]['externals']=[]
-            groupcache[groupcounter]['interfaced']=[]
-            groupcache[groupcounter]['vars']={}
-            groupcounter=groupcounter+1
-            groupcache[groupcounter]={}
-            grouplist[groupcounter]=[]
+            if verbose > 1:
+                outmess('analyzeline: Creating module block %s\n' %
+                        repr(f77modulename), 0)
+            groupname[groupcounter] = 'module'
+            groupcache[groupcounter]['block'] = 'python module'
+            groupcache[groupcounter]['name'] = f77modulename
+            groupcache[groupcounter]['from'] = ''
+            groupcache[groupcounter]['body'] = []
+            groupcache[groupcounter]['externals'] = []
+            groupcache[groupcounter]['interfaced'] = []
+            groupcache[groupcounter]['vars'] = {}
+            groupcounter = groupcounter + 1
+            groupcache[groupcounter] = {}
+            grouplist[groupcounter] = []
         if needinterface:
-            if verbose>1:
-                outmess('analyzeline: Creating additional interface block (groupcounter=%s).\n' % (groupcounter), 0)
-            groupname[groupcounter]='interface'
-            groupcache[groupcounter]['block']='interface'
-            groupcache[groupcounter]['name']='unknown_interface'
-            groupcache[groupcounter]['from']='%s:%s'%(groupcache[groupcounter-1]['from'], groupcache[groupcounter-1]['name'])
-            groupcache[groupcounter]['body']=[]
-            groupcache[groupcounter]['externals']=[]
-            groupcache[groupcounter]['interfaced']=[]
-            groupcache[groupcounter]['vars']={}
-            groupcounter=groupcounter+1
-            groupcache[groupcounter]={}
-            grouplist[groupcounter]=[]
-        groupname[groupcounter]=block
-        groupcache[groupcounter]['block']=block
-        if not name: name='unknown_'+block
-        groupcache[groupcounter]['prefix']=m.group('before')
-        groupcache[groupcounter]['name']=rmbadname1(name)
-        groupcache[groupcounter]['result']=result
-        if groupcounter==1:
-            groupcache[groupcounter]['from']=currentfilename
+            if verbose > 1:
+                outmess('analyzeline: Creating additional interface block (groupcounter=%s).\n' % (
+                    groupcounter), 0)
+            groupname[groupcounter] = 'interface'
+            groupcache[groupcounter]['block'] = 'interface'
+            groupcache[groupcounter]['name'] = 'unknown_interface'
+            groupcache[groupcounter]['from'] = '%s:%s' % (
+                groupcache[groupcounter - 1]['from'], groupcache[groupcounter - 1]['name'])
+            groupcache[groupcounter]['body'] = []
+            groupcache[groupcounter]['externals'] = []
+            groupcache[groupcounter]['interfaced'] = []
+            groupcache[groupcounter]['vars'] = {}
+            groupcounter = groupcounter + 1
+            groupcache[groupcounter] = {}
+            grouplist[groupcounter] = []
+        groupname[groupcounter] = block
+        groupcache[groupcounter]['block'] = block
+        if not name:
+            name = 'unknown_' + block
+        groupcache[groupcounter]['prefix'] = m.group('before')
+        groupcache[groupcounter]['name'] = rmbadname1(name)
+        groupcache[groupcounter]['result'] = result
+        if groupcounter == 1:
+            groupcache[groupcounter]['from'] = currentfilename
         else:
-            if f77modulename and groupcounter==3:
-                groupcache[groupcounter]['from']='%s:%s'%(groupcache[groupcounter-1]['from'], currentfilename)
+            if f77modulename and groupcounter == 3:
+                groupcache[groupcounter]['from'] = '%s:%s' % (
+                    groupcache[groupcounter - 1]['from'], currentfilename)
             else:
-                groupcache[groupcounter]['from']='%s:%s'%(groupcache[groupcounter-1]['from'], groupcache[groupcounter-1]['name'])
+                groupcache[groupcounter]['from'] = '%s:%s' % (
+                    groupcache[groupcounter - 1]['from'], groupcache[groupcounter - 1]['name'])
         for k in list(groupcache[groupcounter].keys()):
             if not groupcache[groupcounter][k]:
                 del groupcache[groupcounter][k]
 
-        groupcache[groupcounter]['args']=args
-        groupcache[groupcounter]['body']=[]
-        groupcache[groupcounter]['externals']=[]
-        groupcache[groupcounter]['interfaced']=[]
-        groupcache[groupcounter]['vars']={}
-        groupcache[groupcounter]['entry']={}
+        groupcache[groupcounter]['args'] = args
+        groupcache[groupcounter]['body'] = []
+        groupcache[groupcounter]['externals'] = []
+        groupcache[groupcounter]['interfaced'] = []
+        groupcache[groupcounter]['vars'] = {}
+        groupcache[groupcounter]['entry'] = {}
         # end of creation
-        if block=='type':
+        if block == 'type':
             groupcache[groupcounter]['varnames'] = []
 
-        if case in ['call', 'callfun']: # set parents variables
-            if name not in groupcache[groupcounter-2]['externals']:
-                groupcache[groupcounter-2]['externals'].append(name)
-            groupcache[groupcounter]['vars']=copy.deepcopy(groupcache[groupcounter-2]['vars'])
-            #try: del groupcache[groupcounter]['vars'][groupcache[groupcounter-2]['name']]
-            #except: pass
-            try: del groupcache[groupcounter]['vars'][name][groupcache[groupcounter]['vars'][name]['attrspec'].index('external')]
-            except: pass
-        if block in ['function', 'subroutine']: # set global attributes
-            try: groupcache[groupcounter]['vars'][name]=appenddecl(groupcache[groupcounter]['vars'][name], groupcache[groupcounter-2]['vars'][''])
-            except: pass
-            if case=='callfun': # return type
+        if case in ['call', 'callfun']:  # set parents variables
+            if name not in groupcache[groupcounter - 2]['externals']:
+                groupcache[groupcounter - 2]['externals'].append(name)
+            groupcache[groupcounter]['vars'] = copy.deepcopy(
+                groupcache[groupcounter - 2]['vars'])
+            # try: del groupcache[groupcounter]['vars'][groupcache[groupcounter-2]['name']]
+            # except: pass
+            try:
+                del groupcache[groupcounter]['vars'][name][
+                    groupcache[groupcounter]['vars'][name]['attrspec'].index('external')]
+            except:
+                pass
+        if block in ['function', 'subroutine']:  # set global attributes
+            try:
+                groupcache[groupcounter]['vars'][name] = appenddecl(
+                    groupcache[groupcounter]['vars'][name], groupcache[groupcounter - 2]['vars'][''])
+            except:
+                pass
+            if case == 'callfun':  # return type
                 if result and result in groupcache[groupcounter]['vars']:
-                    if not name==result:
-                        groupcache[groupcounter]['vars'][name]=appenddecl(groupcache[groupcounter]['vars'][name], groupcache[groupcounter]['vars'][result])
-            #if groupcounter>1: # name is interfaced
-            try: groupcache[groupcounter-2]['interfaced'].append(name)
-            except: pass
-        if block=='function':
-            t=typespattern[0].match(m.group('before')+' '+name)
+                    if not name == result:
+                        groupcache[groupcounter]['vars'][name] = appenddecl(
+                            groupcache[groupcounter]['vars'][name], groupcache[groupcounter]['vars'][result])
+            # if groupcounter>1: # name is interfaced
+            try:
+                groupcache[groupcounter - 2]['interfaced'].append(name)
+            except:
+                pass
+        if block == 'function':
+            t = typespattern[0].match(m.group('before') + ' ' + name)
             if t:
-                typespec, selector, attr, edecl=cracktypespec0(t.group('this'), t.group('after'))
+                typespec, selector, attr, edecl = cracktypespec0(
+                    t.group('this'), t.group('after'))
                 updatevars(typespec, selector, attr, edecl)
 
         if case in ['call', 'callfun']:
-            grouplist[groupcounter-1].append(groupcache[groupcounter])
-            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
             del grouplist[groupcounter]
-            groupcounter=groupcounter-1 # end routine
-            grouplist[groupcounter-1].append(groupcache[groupcounter])
-            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            groupcounter = groupcounter - 1  # end routine
+            grouplist[groupcounter - 1].append(groupcache[groupcounter])
+            grouplist[groupcounter - 1][-1]['body'] = grouplist[groupcounter]
             del grouplist[groupcounter]
-            groupcounter=groupcounter-1 # end interface
+            groupcounter = groupcounter - 1  # end interface
 
-    elif case=='entry':
-        name, args, result, bind=_resolvenameargspattern(m.group('after'))
+    elif case == 'entry':
+        name, args, result, bind = _resolvenameargspattern(m.group('after'))
         if name is not None:
             if args:
-                args=rmbadname([x.strip() for x in markoutercomma(args).split('@,@')])
-            else: args=[]
+                args = rmbadname([x.strip()
+                                  for x in markoutercomma(args).split('@,@')])
+            else:
+                args = []
             assert result is None, repr(result)
             groupcache[groupcounter]['entry'][name] = args
             previous_context = ('entry', name, groupcounter)
-    elif case=='type':
-        typespec, selector, attr, edecl=cracktypespec0(block, m.group('after'))
+    elif case == 'type':
+        typespec, selector, attr, edecl = cracktypespec0(
+            block, m.group('after'))
         last_name = updatevars(typespec, selector, attr, edecl)
         if last_name is not None:
             previous_context = ('variable', last_name, groupcounter)
     elif case in ['dimension', 'intent', 'optional', 'required', 'external', 'public', 'private', 'intrisic']:
-        edecl=groupcache[groupcounter]['vars']
-        ll=m.group('after').strip()
-        i=ll.find('::')
-        if i<0 and case=='intent':
-            i=markouterparen(ll).find('@)@')-2
-            ll=ll[:i+1]+'::'+ll[i+1:]
-            i=ll.find('::')
-            if ll[i:]=='::' and 'args' in groupcache[groupcounter]:
-                outmess('All arguments will have attribute %s%s\n'%(m.group('this'), ll[:i]))
+        edecl = groupcache[groupcounter]['vars']
+        ll = m.group('after').strip()
+        i = ll.find('::')
+        if i < 0 and case == 'intent':
+            i = markouterparen(ll).find('@)@') - 2
+            ll = ll[:i + 1] + '::' + ll[i + 1:]
+            i = ll.find('::')
+            if ll[i:] == '::' and 'args' in groupcache[groupcounter]:
+                outmess('All arguments will have attribute %s%s\n' %
+                        (m.group('this'), ll[:i]))
                 ll = ll + ','.join(groupcache[groupcounter]['args'])
-        if i<0:i=0;pl=''
-        else: pl=ll[:i].strip();ll=ll[i+2:]
+        if i < 0:
+            i = 0
+            pl = ''
+        else:
+            pl = ll[:i].strip()
+            ll = ll[i + 2:]
         ch = markoutercomma(pl).split('@,@')
-        if len(ch)>1:
+        if len(ch) > 1:
             pl = ch[0]
-            outmess('analyzeline: cannot handle multiple attributes without type specification. Ignoring %r.\n' % (','.join(ch[1:])))
+            outmess('analyzeline: cannot handle multiple attributes without type specification. Ignoring %r.\n' % (
+                ','.join(ch[1:])))
         last_name = None
 
         for e in [x.strip() for x in markoutercomma(ll).split('@,@')]:
-            m1=namepattern.match(e)
+            m1 = namepattern.match(e)
             if not m1:
-                if case in ['public', 'private']: k=''
+                if case in ['public', 'private']:
+                    k = ''
                 else:
                     print(m.groupdict())
-                    outmess('analyzeline: no name pattern found in %s statement for %s. Skipping.\n'%(case, repr(e)))
+                    outmess('analyzeline: no name pattern found in %s statement for %s. Skipping.\n' % (
+                        case, repr(e)))
                     continue
             else:
-                k=rmbadname1(m1.group('name'))
+                k = rmbadname1(m1.group('name'))
             if k not in edecl:
-                edecl[k]={}
-            if case=='dimension':
-                ap=case+m1.group('after')
-            if case=='intent':
-                ap=m.group('this')+pl
+                edecl[k] = {}
+            if case == 'dimension':
+                ap = case + m1.group('after')
+            if case == 'intent':
+                ap = m.group('this') + pl
                 if _intentcallbackpattern.match(ap):
                     if k not in groupcache[groupcounter]['args']:
-                        if groupcounter>1:
-                            if '__user__' not in groupcache[groupcounter-2]['name']:
-                                outmess('analyzeline: missing __user__ module (could be nothing)\n')
-                            if k!=groupcache[groupcounter]['name']: # fixes ticket 1693
-                                outmess('analyzeline: appending intent(callback) %s'\
+                        if groupcounter > 1:
+                            if '__user__' not in groupcache[groupcounter - 2]['name']:
+                                outmess(
+                                    'analyzeline: missing __user__ module (could be nothing)\n')
+                            # fixes ticket 1693
+                            if k != groupcache[groupcounter]['name']:
+                                outmess('analyzeline: appending intent(callback) %s'
                                         ' to %s arguments\n' % (k, groupcache[groupcounter]['name']))
                                 groupcache[groupcounter]['args'].append(k)
                         else:
-                            errmess('analyzeline: intent(callback) %s is ignored' % (k))
+                            errmess(
+                                'analyzeline: intent(callback) %s is ignored' % (k))
                     else:
-                        errmess('analyzeline: intent(callback) %s is already'\
+                        errmess('analyzeline: intent(callback) %s is already'
                                 ' in argument list' % (k))
             if case in ['optional', 'required', 'public', 'external', 'private', 'intrisic']:
-                ap=case
+                ap = case
             if 'attrspec' in edecl[k]:
                 edecl[k]['attrspec'].append(ap)
             else:
-                edecl[k]['attrspec']=[ap]
-            if case=='external':
-                if groupcache[groupcounter]['block']=='program':
+                edecl[k]['attrspec'] = [ap]
+            if case == 'external':
+                if groupcache[groupcounter]['block'] == 'program':
                     outmess('analyzeline: ignoring program arguments\n')
                     continue
                 if k not in groupcache[groupcounter]['args']:
                     #outmess('analyzeline: ignoring external %s (not in arguments list)\n'%(`k`))
                     continue
                 if 'externals' not in groupcache[groupcounter]:
-                    groupcache[groupcounter]['externals']=[]
+                    groupcache[groupcounter]['externals'] = []
                 groupcache[groupcounter]['externals'].append(k)
             last_name = k
-        groupcache[groupcounter]['vars']=edecl
+        groupcache[groupcounter]['vars'] = edecl
         if last_name is not None:
             previous_context = ('variable', last_name, groupcounter)
-    elif case=='parameter':
-        edecl=groupcache[groupcounter]['vars']
-        ll=m.group('after').strip()[1:-1]
+    elif case == 'parameter':
+        edecl = groupcache[groupcounter]['vars']
+        ll = m.group('after').strip()[1:-1]
         last_name = None
         for e in markoutercomma(ll).split('@,@'):
             try:
-                k, initexpr=[x.strip() for x in e.split('=')]
+                k, initexpr = [x.strip() for x in e.split('=')]
             except:
-                outmess('analyzeline: could not extract name,expr in parameter statement "%s" of "%s"\n'%(e, ll));continue
+                outmess(
+                    'analyzeline: could not extract name,expr in parameter statement "%s" of "%s"\n' % (e, ll))
+                continue
             params = get_parameters(edecl)
-            k=rmbadname1(k)
+            k = rmbadname1(k)
             if k not in edecl:
-                edecl[k]={}
-            if '=' in edecl[k] and (not edecl[k]['=']==initexpr):
-                outmess('analyzeline: Overwriting the value of parameter "%s" ("%s") with "%s".\n'%(k, edecl[k]['='], initexpr))
+                edecl[k] = {}
+            if '=' in edecl[k] and (not edecl[k]['='] == initexpr):
+                outmess('analyzeline: Overwriting the value of parameter "%s" ("%s") with "%s".\n' % (
+                    k, edecl[k]['='], initexpr))
             t = determineexprtype(initexpr, params)
             if t:
-                if t.get('typespec')=='real':
+                if t.get('typespec') == 'real':
                     tt = list(initexpr)
                     for m in real16pattern.finditer(initexpr):
-                        tt[m.start():m.end()] = list(\
+                        tt[m.start():m.end()] = list(
                             initexpr[m.start():m.end()].lower().replace('d', 'e'))
                     initexpr = ''.join(tt)
-                elif t.get('typespec')=='complex':
+                elif t.get('typespec') == 'complex':
                     initexpr = initexpr[1:].lower().replace('d', 'e').\
-                               replace(',', '+1j*(')
+                        replace(',', '+1j*(')
             try:
                 v = eval(initexpr, {}, params)
             except (SyntaxError, NameError, TypeError) as msg:
-                errmess('analyzeline: Failed to evaluate %r. Ignoring: %s\n'\
+                errmess('analyzeline: Failed to evaluate %r. Ignoring: %s\n'
                         % (initexpr, msg))
                 continue
             edecl[k]['='] = repr(v)
             if 'attrspec' in edecl[k]:
                 edecl[k]['attrspec'].append('parameter')
-            else: edecl[k]['attrspec']=['parameter']
+            else:
+                edecl[k]['attrspec'] = ['parameter']
             last_name = k
-        groupcache[groupcounter]['vars']=edecl
+        groupcache[groupcounter]['vars'] = edecl
         if last_name is not None:
             previous_context = ('variable', last_name, groupcounter)
-    elif case=='implicit':
-        if m.group('after').strip().lower()=='none':
-            groupcache[groupcounter]['implicit']=None
+    elif case == 'implicit':
+        if m.group('after').strip().lower() == 'none':
+            groupcache[groupcounter]['implicit'] = None
         elif m.group('after'):
             if 'implicit' in groupcache[groupcounter]:
-                impl=groupcache[groupcounter]['implicit']
-            else: impl={}
+                impl = groupcache[groupcounter]['implicit']
+            else:
+                impl = {}
             if impl is None:
-                outmess('analyzeline: Overwriting earlier "implicit none" statement.\n')
-                impl={}
+                outmess(
+                    'analyzeline: Overwriting earlier "implicit none" statement.\n')
+                impl = {}
             for e in markoutercomma(m.group('after')).split('@,@'):
-                decl={}
-                m1=re.match(r'\s*(?P<this>.*?)\s*(\(\s*(?P<after>[a-z-, ]+)\s*\)\s*|)\Z', e, re.I)
+                decl = {}
+                m1 = re.match(
+                    r'\s*(?P<this>.*?)\s*(\(\s*(?P<after>[a-z-, ]+)\s*\)\s*|)\Z', e, re.I)
                 if not m1:
-                    outmess('analyzeline: could not extract info of implicit statement part "%s"\n'%(e));continue
-                m2=typespattern4implicit.match(m1.group('this'))
+                    outmess(
+                        'analyzeline: could not extract info of implicit statement part "%s"\n' % (e))
+                    continue
+                m2 = typespattern4implicit.match(m1.group('this'))
                 if not m2:
-                    outmess('analyzeline: could not extract types pattern of implicit statement part "%s"\n'%(e));continue
-                typespec, selector, attr, edecl=cracktypespec0(m2.group('this'), m2.group('after'))
-                kindselect, charselect, typename=cracktypespec(typespec, selector)
-                decl['typespec']=typespec
-                decl['kindselector']=kindselect
-                decl['charselector']=charselect
-                decl['typename']=typename
+                    outmess(
+                        'analyzeline: could not extract types pattern of implicit statement part "%s"\n' % (e))
+                    continue
+                typespec, selector, attr, edecl = cracktypespec0(
+                    m2.group('this'), m2.group('after'))
+                kindselect, charselect, typename = cracktypespec(
+                    typespec, selector)
+                decl['typespec'] = typespec
+                decl['kindselector'] = kindselect
+                decl['charselector'] = charselect
+                decl['typename'] = typename
                 for k in list(decl.keys()):
-                    if not decl[k]: del decl[k]
+                    if not decl[k]:
+                        del decl[k]
                 for r in markoutercomma(m1.group('after')).split('@,@'):
                     if '-' in r:
-                        try: begc, endc=[x.strip() for x in r.split('-')]
+                        try:
+                            begc, endc = [x.strip() for x in r.split('-')]
                         except:
-                            outmess('analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement\n'%r);continue
-                    else: begc=endc=r.strip()
-                    if not len(begc)==len(endc)==1:
-                        outmess('analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement (2)\n'%r);continue
-                    for o in range(ord(begc), ord(endc)+1):
-                        impl[chr(o)]=decl
-            groupcache[groupcounter]['implicit']=impl
-    elif case=='data':
-        ll=[]
-        dl='';il='';f=0;fc=1;inp=0
+                            outmess(
+                                'analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement\n' % r)
+                            continue
+                    else:
+                        begc = endc = r.strip()
+                    if not len(begc) == len(endc) == 1:
+                        outmess(
+                            'analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement (2)\n' % r)
+                        continue
+                    for o in range(ord(begc), ord(endc) + 1):
+                        impl[chr(o)] = decl
+            groupcache[groupcounter]['implicit'] = impl
+    elif case == 'data':
+        ll = []
+        dl = ''
+        il = ''
+        f = 0
+        fc = 1
+        inp = 0
         for c in m.group('after'):
             if not inp:
-                if c=="'": fc=not fc
-                if c=='/' and fc: f=f+1;continue
-            if c=='(': inp = inp + 1
-            elif c==')': inp = inp - 1
-            if f==0: dl=dl+c
-            elif f==1: il=il+c
-            elif f==2:
+                if c == "'":
+                    fc = not fc
+                if c == '/' and fc:
+                    f = f + 1
+                    continue
+            if c == '(':
+                inp = inp + 1
+            elif c == ')':
+                inp = inp - 1
+            if f == 0:
+                dl = dl + c
+            elif f == 1:
+                il = il + c
+            elif f == 2:
                 dl = dl.strip()
                 if dl.startswith(','):
                     dl = dl[1:].strip()
                 ll.append([dl, il])
-                dl=c;il='';f=0
-        if f==2:
+                dl = c
+                il = ''
+                f = 0
+        if f == 2:
             dl = dl.strip()
             if dl.startswith(','):
                 dl = dl[1:].strip()
             ll.append([dl, il])
-        vars={}
+        vars = {}
         if 'vars' in groupcache[groupcounter]:
-            vars=groupcache[groupcounter]['vars']
+            vars = groupcache[groupcounter]['vars']
         last_name = None
         for l in ll:
-            l=[x.strip() for x in l]
-            if l[0][0]==',':l[0]=l[0][1:]
-            if l[0][0]=='(':
-                outmess('analyzeline: implied-DO list "%s" is not supported. Skipping.\n'%l[0])
+            l = [x.strip() for x in l]
+            if l[0][0] == ',':
+                l[0] = l[0][1:]
+            if l[0][0] == '(':
+                outmess(
+                    'analyzeline: implied-DO list "%s" is not supported. Skipping.\n' % l[0])
                 continue
-            #if '(' in l[0]:
-            #    #outmess('analyzeline: ignoring this data statement.\n')
+            # if '(' in l[0]:
+            # outmess('analyzeline: ignoring this data statement.\n')
             #    continue
-            i=0;j=0;llen=len(l[1])
+            i = 0
+            j = 0
+            llen = len(l[1])
             for v in rmbadname([x.strip() for x in markoutercomma(l[0]).split('@,@')]):
-                if v[0]=='(':
-                    outmess('analyzeline: implied-DO list "%s" is not supported. Skipping.\n'%v)
+                if v[0] == '(':
+                    outmess(
+                        'analyzeline: implied-DO list "%s" is not supported. Skipping.\n' % v)
                     # XXX: subsequent init expressions may get wrong values.
-                    #      Ignoring since data statements are irrelevant for wrapping.
+                    # Ignoring since data statements are irrelevant for
+                    # wrapping.
                     continue
-                fc=0
-                while (i<llen) and (fc or not l[1][i]==','):
-                    if l[1][i]=="'": fc=not fc
-                    i=i+1
-                i=i+1
-                #v,l[1][j:i-1]=name,initvalue
+                fc = 0
+                while (i < llen) and (fc or not l[1][i] == ','):
+                    if l[1][i] == "'":
+                        fc = not fc
+                    i = i + 1
+                i = i + 1
+                # v,l[1][j:i-1]=name,initvalue
                 if v not in vars:
-                    vars[v]={}
-                if '=' in vars[v] and not vars[v]['=']==l[1][j:i-1]:
-                    outmess('analyzeline: changing init expression of "%s" ("%s") to "%s"\n'%(v, vars[v]['='], l[1][j:i-1]))
-                vars[v]['=']=l[1][j:i-1]
-                j=i
+                    vars[v] = {}
+                if '=' in vars[v] and not vars[v]['='] == l[1][j:i - 1]:
+                    outmess('analyzeline: changing init expression of "%s" ("%s") to "%s"\n' % (
+                        v, vars[v]['='], l[1][j:i - 1]))
+                vars[v]['='] = l[1][j:i - 1]
+                j = i
                 last_name = v
-        groupcache[groupcounter]['vars']=vars
+        groupcache[groupcounter]['vars'] = vars
         if last_name is not None:
             previous_context = ('variable', last_name, groupcounter)
-    elif case=='common':
-        line=m.group('after').strip()
-        if not line[0]=='/':line='//'+line
-        cl=[]
-        f=0;bn='';ol=''
+    elif case == 'common':
+        line = m.group('after').strip()
+        if not line[0] == '/':
+            line = '//' + line
+        cl = []
+        f = 0
+        bn = ''
+        ol = ''
         for c in line:
-            if c=='/':f=f+1;continue
-            if f>=3:
+            if c == '/':
+                f = f + 1
+                continue
+            if f >= 3:
                 bn = bn.strip()
-                if not bn: bn='_BLNK_'
+                if not bn:
+                    bn = '_BLNK_'
                 cl.append([bn, ol])
-                f=f-2;bn='';ol=''
-            if f%2: bn=bn+c
-            else: ol=ol+c
+                f = f - 2
+                bn = ''
+                ol = ''
+            if f % 2:
+                bn = bn + c
+            else:
+                ol = ol + c
         bn = bn.strip()
-        if not bn: bn='_BLNK_'
+        if not bn:
+            bn = '_BLNK_'
         cl.append([bn, ol])
-        commonkey={}
+        commonkey = {}
         if 'common' in groupcache[groupcounter]:
-            commonkey=groupcache[groupcounter]['common']
+            commonkey = groupcache[groupcounter]['common']
         for c in cl:
             if c[0] in commonkey:
-                outmess('analyzeline: previously defined common block encountered. Skipping.\n')
+                outmess(
+                    'analyzeline: previously defined common block encountered. Skipping.\n')
                 continue
-            commonkey[c[0]]=[]
+            commonkey[c[0]] = []
             for i in [x.strip() for x in markoutercomma(c[1]).split('@,@')]:
-                if i: commonkey[c[0]].append(i)
-        groupcache[groupcounter]['common']=commonkey
+                if i:
+                    commonkey[c[0]].append(i)
+        groupcache[groupcounter]['common'] = commonkey
         previous_context = ('common', bn, groupcounter)
-    elif case=='use':
-        m1=re.match(r'\A\s*(?P<name>\b[\w]+\b)\s*((,(\s*\bonly\b\s*:|(?P<notonly>))\s*(?P<list>.*))|)\s*\Z', m.group('after'), re.I)
+    elif case == 'use':
+        m1 = re.match(
+            r'\A\s*(?P<name>\b[\w]+\b)\s*((,(\s*\bonly\b\s*:|(?P<notonly>))\s*(?P<list>.*))|)\s*\Z', m.group('after'), re.I)
         if m1:
-            mm=m1.groupdict()
+            mm = m1.groupdict()
             if 'use' not in groupcache[groupcounter]:
-                groupcache[groupcounter]['use']={}
-            name=m1.group('name')
-            groupcache[groupcounter]['use'][name]={}
-            isonly=0
+                groupcache[groupcounter]['use'] = {}
+            name = m1.group('name')
+            groupcache[groupcounter]['use'][name] = {}
+            isonly = 0
             if 'list' in mm and mm['list'] is not None:
                 if 'notonly' in mm and mm['notonly'] is None:
-                    isonly=1
-                groupcache[groupcounter]['use'][name]['only']=isonly
-                ll=[x.strip() for x in mm['list'].split(',')]
-                rl={}
+                    isonly = 1
+                groupcache[groupcounter]['use'][name]['only'] = isonly
+                ll = [x.strip() for x in mm['list'].split(',')]
+                rl = {}
                 for l in ll:
                     if '=' in l:
-                        m2=re.match(r'\A\s*(?P<local>\b[\w]+\b)\s*=\s*>\s*(?P<use>\b[\w]+\b)\s*\Z', l, re.I)
-                        if m2: rl[m2.group('local').strip()]=m2.group('use').strip()
+                        m2 = re.match(
+                            r'\A\s*(?P<local>\b[\w]+\b)\s*=\s*>\s*(?P<use>\b[\w]+\b)\s*\Z', l, re.I)
+                        if m2:
+                            rl[m2.group('local').strip()] = m2.group(
+                                'use').strip()
                         else:
-                            outmess('analyzeline: Not local=>use pattern found in %s\n'%repr(l))
+                            outmess(
+                                'analyzeline: Not local=>use pattern found in %s\n' % repr(l))
                     else:
-                        rl[l]=l
-                    groupcache[groupcounter]['use'][name]['map']=rl
+                        rl[l] = l
+                    groupcache[groupcounter]['use'][name]['map'] = rl
             else:
                 pass
         else:
@@ -1213,13 +1427,13 @@ def analyzeline(m, case, line):
         if 'f2pyenhancements' not in groupcache[groupcounter]:
             groupcache[groupcounter]['f2pyenhancements'] = {}
         d = groupcache[groupcounter]['f2pyenhancements']
-        if m.group('this')=='usercode' and 'usercode' in d:
+        if m.group('this') == 'usercode' and 'usercode' in d:
             if isinstance(d['usercode'], str):
                 d['usercode'] = [d['usercode']]
             d['usercode'].append(m.group('after'))
         else:
             d[m.group('this')] = m.group('after')
-    elif case=='multiline':
+    elif case == 'multiline':
         if previous_context is None:
             if verbose:
                 outmess('analyzeline: No context for multiline block.\n')
@@ -1230,10 +1444,11 @@ def analyzeline(m, case, line):
                         previous_context[:2],
                         m.group('this'))
     else:
-        if verbose>1:
+        if verbose > 1:
             print(m.groupdict())
             outmess('analyzeline: No code implemented for line.\n')
 
+
 def appendmultiline(group, context_name, ml):
     if 'f2pymultilines' not in group:
         group['f2pymultilines'] = {}
@@ -1243,45 +1458,61 @@ def appendmultiline(group, context_name, ml):
     d[context_name].append(ml)
     return
 
+
 def cracktypespec0(typespec, ll):
-    selector=None
-    attr=None
-    if re.match(r'double\s*complex', typespec, re.I): typespec='double complex'
-    elif re.match(r'double\s*precision', typespec, re.I): typespec='double precision'
-    else: typespec=typespec.strip().lower()
-    m1=selectpattern.match(markouterparen(ll))
+    selector = None
+    attr = None
+    if re.match(r'double\s*complex', typespec, re.I):
+        typespec = 'double complex'
+    elif re.match(r'double\s*precision', typespec, re.I):
+        typespec = 'double precision'
+    else:
+        typespec = typespec.strip().lower()
+    m1 = selectpattern.match(markouterparen(ll))
     if not m1:
-        outmess('cracktypespec0: no kind/char_selector pattern found for line.\n')
+        outmess(
+            'cracktypespec0: no kind/char_selector pattern found for line.\n')
         return
-    d=m1.groupdict()
-    for k in list(d.keys()): d[k]=unmarkouterparen(d[k])
+    d = m1.groupdict()
+    for k in list(d.keys()):
+        d[k] = unmarkouterparen(d[k])
     if typespec in ['complex', 'integer', 'logical', 'real', 'character', 'type']:
-        selector=d['this']
-        ll=d['after']
-    i=ll.find('::')
-    if i>=0:
-        attr=ll[:i].strip()
-        ll=ll[i+2:]
+        selector = d['this']
+        ll = d['after']
+    i = ll.find('::')
+    if i >= 0:
+        attr = ll[:i].strip()
+        ll = ll[i + 2:]
     return typespec, selector, attr, ll
 #####
-namepattern=re.compile(r'\s*(?P<name>\b[\w]+\b)\s*(?P<after>.*)\s*\Z', re.I)
-kindselector=re.compile(r'\s*(\(\s*(kind\s*=)?\s*(?P<kind>.*)\s*\)|[*]\s*(?P<kind2>.*?))\s*\Z', re.I)
-charselector=re.compile(r'\s*(\((?P<lenkind>.*)\)|[*]\s*(?P<charlen>.*))\s*\Z', re.I)
-lenkindpattern=re.compile(r'\s*(kind\s*=\s*(?P<kind>.*?)\s*(@,@\s*len\s*=\s*(?P<len>.*)|)|(len\s*=\s*|)(?P<len2>.*?)\s*(@,@\s*(kind\s*=\s*|)(?P<kind2>.*)|))\s*\Z', re.I)
-lenarraypattern=re.compile(r'\s*(@\(@\s*(?!/)\s*(?P<array>.*?)\s*@\)@\s*[*]\s*(?P<len>.*?)|([*]\s*(?P<len2>.*?)|)\s*(@\(@\s*(?!/)\s*(?P<array2>.*?)\s*@\)@|))\s*(=\s*(?P<init>.*?)|(@\(@|)/\s*(?P<init2>.*?)\s*/(@\)@|)|)\s*\Z', re.I)
+namepattern = re.compile(r'\s*(?P<name>\b[\w]+\b)\s*(?P<after>.*)\s*\Z', re.I)
+kindselector = re.compile(
+    r'\s*(\(\s*(kind\s*=)?\s*(?P<kind>.*)\s*\)|[*]\s*(?P<kind2>.*?))\s*\Z', re.I)
+charselector = re.compile(
+    r'\s*(\((?P<lenkind>.*)\)|[*]\s*(?P<charlen>.*))\s*\Z', re.I)
+lenkindpattern = re.compile(
+    r'\s*(kind\s*=\s*(?P<kind>.*?)\s*(@,@\s*len\s*=\s*(?P<len>.*)|)|(len\s*=\s*|)(?P<len2>.*?)\s*(@,@\s*(kind\s*=\s*|)(?P<kind2>.*)|))\s*\Z', re.I)
+lenarraypattern = re.compile(
+    r'\s*(@\(@\s*(?!/)\s*(?P<array>.*?)\s*@\)@\s*[*]\s*(?P<len>.*?)|([*]\s*(?P<len2>.*?)|)\s*(@\(@\s*(?!/)\s*(?P<array2>.*?)\s*@\)@|))\s*(=\s*(?P<init>.*?)|(@\(@|)/\s*(?P<init2>.*?)\s*/(@\)@|)|)\s*\Z', re.I)
+
+
 def removespaces(expr):
-    expr=expr.strip()
-    if len(expr)<=1: return expr
-    expr2=expr[0]
-    for i in range(1, len(expr)-1):
-        if expr[i]==' ' and \
-           ((expr[i+1] in "()[]{}=+-/* ") or (expr[i-1] in "()[]{}=+-/* ")): continue
-        expr2=expr2+expr[i]
-    expr2=expr2+expr[-1]
+    expr = expr.strip()
+    if len(expr) <= 1:
+        return expr
+    expr2 = expr[0]
+    for i in range(1, len(expr) - 1):
+        if (expr[i] == ' ' and
+            ((expr[i + 1] in "()[]{}=+-/* ") or
+                (expr[i - 1] in "()[]{}=+-/* "))):
+            continue
+        expr2 = expr2 + expr[i]
+    expr2 = expr2 + expr[-1]
     return expr2
 
+
 def markinnerspaces(line):
-    l = '';
+    l = ''
     f = 0
     cc = '\''
     cb = ''
@@ -1296,20 +1527,21 @@ def markinnerspaces(line):
             f = f + 1
         elif c == cc:
             f = f - 1
-        elif c==' ' and f == 1:
+        elif c == ' ' and f == 1:
             l = l + '@_@'
             continue
         l = l + c
         cb = c
     return l
 
+
 def updatevars(typespec, selector, attrspec, entitydecl):
     global groupcache, groupcounter
 
     last_name = None
-    kindselect, charselect, typename=cracktypespec(typespec, selector)
+    kindselect, charselect, typename = cracktypespec(typespec, selector)
     if attrspec:
-        attrspec=[x.strip() for x in markoutercomma(attrspec).split('@,@')]
+        attrspec = [x.strip() for x in markoutercomma(attrspec).split('@,@')]
         l = []
         c = re.compile(r'(?P<start>[a-zA-Z]+)')
         for a in attrspec:
@@ -1321,225 +1553,259 @@ def updatevars(typespec, selector, attrspec, entitydecl):
                 a = s + a[len(s):]
             l.append(a)
         attrspec = l
-    el=[x.strip() for x in markoutercomma(entitydecl).split('@,@')]
-    el1=[]
+    el = [x.strip() for x in markoutercomma(entitydecl).split('@,@')]
+    el1 = []
     for e in el:
         for e1 in [x.strip() for x in markoutercomma(removespaces(markinnerspaces(e)), comma=' ').split('@ @')]:
-            if e1: el1.append(e1.replace('@_@', ' '))
+            if e1:
+                el1.append(e1.replace('@_@', ' '))
     for e in el1:
-        m=namepattern.match(e)
+        m = namepattern.match(e)
         if not m:
-            outmess('updatevars: no name pattern found for entity=%s. Skipping.\n'%(repr(e)))
+            outmess(
+                'updatevars: no name pattern found for entity=%s. Skipping.\n' % (repr(e)))
             continue
-        ename=rmbadname1(m.group('name'))
-        edecl={}
+        ename = rmbadname1(m.group('name'))
+        edecl = {}
         if ename in groupcache[groupcounter]['vars']:
-            edecl=groupcache[groupcounter]['vars'][ename].copy()
+            edecl = groupcache[groupcounter]['vars'][ename].copy()
             not_has_typespec = 'typespec' not in edecl
             if not_has_typespec:
-                edecl['typespec']=typespec
-            elif typespec and (not typespec==edecl['typespec']):
-                outmess('updatevars: attempt to change the type of "%s" ("%s") to "%s". Ignoring.\n' % (ename, edecl['typespec'], typespec))
+                edecl['typespec'] = typespec
+            elif typespec and (not typespec == edecl['typespec']):
+                outmess('updatevars: attempt to change the type of "%s" ("%s") to "%s". Ignoring.\n' % (
+                    ename, edecl['typespec'], typespec))
             if 'kindselector' not in edecl:
-                edecl['kindselector']=copy.copy(kindselect)
+                edecl['kindselector'] = copy.copy(kindselect)
             elif kindselect:
                 for k in list(kindselect.keys()):
-                    if k in edecl['kindselector'] and (not kindselect[k]==edecl['kindselector'][k]):
-                        outmess('updatevars: attempt to change the kindselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (k, ename, edecl['kindselector'][k], kindselect[k]))
-                    else: edecl['kindselector'][k]=copy.copy(kindselect[k])
+                    if k in edecl['kindselector'] and (not kindselect[k] == edecl['kindselector'][k]):
+                        outmess('updatevars: attempt to change the kindselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (
+                            k, ename, edecl['kindselector'][k], kindselect[k]))
+                    else:
+                        edecl['kindselector'][k] = copy.copy(kindselect[k])
             if 'charselector' not in edecl and charselect:
                 if not_has_typespec:
-                    edecl['charselector']=charselect
+                    edecl['charselector'] = charselect
                 else:
-                    errmess('updatevars:%s: attempt to change empty charselector to %r. Ignoring.\n' \
-                            %(ename, charselect))
+                    errmess('updatevars:%s: attempt to change empty charselector to %r. Ignoring.\n'
+                            % (ename, charselect))
             elif charselect:
                 for k in list(charselect.keys()):
-                    if k in edecl['charselector'] and (not charselect[k]==edecl['charselector'][k]):
-                        outmess('updatevars: attempt to change the charselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (k, ename, edecl['charselector'][k], charselect[k]))
-                    else: edecl['charselector'][k]=copy.copy(charselect[k])
+                    if k in edecl['charselector'] and (not charselect[k] == edecl['charselector'][k]):
+                        outmess('updatevars: attempt to change the charselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (
+                            k, ename, edecl['charselector'][k], charselect[k]))
+                    else:
+                        edecl['charselector'][k] = copy.copy(charselect[k])
             if 'typename' not in edecl:
-                edecl['typename']=typename
-            elif typename and (not edecl['typename']==typename):
-                outmess('updatevars: attempt to change the typename of "%s" ("%s") to "%s". Ignoring.\n' % (ename, edecl['typename'], typename))
+                edecl['typename'] = typename
+            elif typename and (not edecl['typename'] == typename):
+                outmess('updatevars: attempt to change the typename of "%s" ("%s") to "%s". Ignoring.\n' % (
+                    ename, edecl['typename'], typename))
             if 'attrspec' not in edecl:
-                edecl['attrspec']=copy.copy(attrspec)
+                edecl['attrspec'] = copy.copy(attrspec)
             elif attrspec:
                 for a in attrspec:
                     if a not in edecl['attrspec']:
                         edecl['attrspec'].append(a)
         else:
-            edecl['typespec']=copy.copy(typespec)
-            edecl['kindselector']=copy.copy(kindselect)
-            edecl['charselector']=copy.copy(charselect)
-            edecl['typename']=typename
-            edecl['attrspec']=copy.copy(attrspec)
+            edecl['typespec'] = copy.copy(typespec)
+            edecl['kindselector'] = copy.copy(kindselect)
+            edecl['charselector'] = copy.copy(charselect)
+            edecl['typename'] = typename
+            edecl['attrspec'] = copy.copy(attrspec)
         if m.group('after'):
-            m1=lenarraypattern.match(markouterparen(m.group('after')))
+            m1 = lenarraypattern.match(markouterparen(m.group('after')))
             if m1:
-                d1=m1.groupdict()
+                d1 = m1.groupdict()
                 for lk in ['len', 'array', 'init']:
-                    if d1[lk+'2'] is not None: d1[lk]=d1[lk+'2']; del d1[lk+'2']
+                    if d1[lk + '2'] is not None:
+                        d1[lk] = d1[lk + '2']
+                        del d1[lk + '2']
                 for k in list(d1.keys()):
-                    if d1[k] is not None: d1[k]=unmarkouterparen(d1[k])
-                    else: del d1[k]
+                    if d1[k] is not None:
+                        d1[k] = unmarkouterparen(d1[k])
+                    else:
+                        del d1[k]
                 if 'len' in d1 and 'array' in d1:
-                    if d1['len']=='':
-                        d1['len']=d1['array']
+                    if d1['len'] == '':
+                        d1['len'] = d1['array']
                         del d1['array']
                     else:
-                        d1['array']=d1['array']+','+d1['len']
+                        d1['array'] = d1['array'] + ',' + d1['len']
                         del d1['len']
-                        errmess('updatevars: "%s %s" is mapped to "%s %s(%s)"\n'%(typespec, e, typespec, ename, d1['array']))
+                        errmess('updatevars: "%s %s" is mapped to "%s %s(%s)"\n' % (
+                            typespec, e, typespec, ename, d1['array']))
                 if 'array' in d1:
-                    dm = 'dimension(%s)'%d1['array']
+                    dm = 'dimension(%s)' % d1['array']
                     if 'attrspec' not in edecl or (not edecl['attrspec']):
-                        edecl['attrspec']=[dm]
+                        edecl['attrspec'] = [dm]
                     else:
                         edecl['attrspec'].append(dm)
                         for dm1 in edecl['attrspec']:
-                            if dm1[:9]=='dimension' and dm1!=dm:
+                            if dm1[:9] == 'dimension' and dm1 != dm:
                                 del edecl['attrspec'][-1]
-                                errmess('updatevars:%s: attempt to change %r to %r. Ignoring.\n' \
+                                errmess('updatevars:%s: attempt to change %r to %r. Ignoring.\n'
                                         % (ename, dm1, dm))
                                 break
 
                 if 'len' in d1:
                     if typespec in ['complex', 'integer', 'logical', 'real']:
                         if ('kindselector' not in edecl) or (not edecl['kindselector']):
-                            edecl['kindselector']={}
-                        edecl['kindselector']['*']=d1['len']
+                            edecl['kindselector'] = {}
+                        edecl['kindselector']['*'] = d1['len']
                     elif typespec == 'character':
                         if ('charselector' not in edecl) or (not edecl['charselector']):
-                            edecl['charselector']={}
+                            edecl['charselector'] = {}
                         if 'len' in edecl['charselector']:
                             del edecl['charselector']['len']
-                        edecl['charselector']['*']=d1['len']
+                        edecl['charselector']['*'] = d1['len']
                 if 'init' in d1:
-                    if '=' in edecl and (not edecl['=']==d1['init']):
-                        outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (ename, edecl['='], d1['init']))
+                    if '=' in edecl and (not edecl['='] == d1['init']):
+                        outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (
+                            ename, edecl['='], d1['init']))
                     else:
-                        edecl['=']=d1['init']
+                        edecl['='] = d1['init']
             else:
-                outmess('updatevars: could not crack entity declaration "%s". Ignoring.\n'%(ename+m.group('after')))
+                outmess('updatevars: could not crack entity declaration "%s". Ignoring.\n' % (
+                    ename + m.group('after')))
         for k in list(edecl.keys()):
             if not edecl[k]:
                 del edecl[k]
-        groupcache[groupcounter]['vars'][ename]=edecl
+        groupcache[groupcounter]['vars'][ename] = edecl
         if 'varnames' in groupcache[groupcounter]:
             groupcache[groupcounter]['varnames'].append(ename)
         last_name = ename
     return last_name
 
+
 def cracktypespec(typespec, selector):
-    kindselect=None
-    charselect=None
-    typename=None
+    kindselect = None
+    charselect = None
+    typename = None
     if selector:
         if typespec in ['complex', 'integer', 'logical', 'real']:
-            kindselect=kindselector.match(selector)
+            kindselect = kindselector.match(selector)
             if not kindselect:
-                outmess('cracktypespec: no kindselector pattern found for %s\n'%(repr(selector)))
+                outmess(
+                    'cracktypespec: no kindselector pattern found for %s\n' % (repr(selector)))
                 return
-            kindselect=kindselect.groupdict()
-            kindselect['*']=kindselect['kind2']
+            kindselect = kindselect.groupdict()
+            kindselect['*'] = kindselect['kind2']
             del kindselect['kind2']
             for k in list(kindselect.keys()):
-                if not kindselect[k]: del kindselect[k]
+                if not kindselect[k]:
+                    del kindselect[k]
             for k, i in list(kindselect.items()):
                 kindselect[k] = rmbadname1(i)
-        elif typespec=='character':
-            charselect=charselector.match(selector)
+        elif typespec == 'character':
+            charselect = charselector.match(selector)
             if not charselect:
-                outmess('cracktypespec: no charselector pattern found for %s\n'%(repr(selector)))
+                outmess(
+                    'cracktypespec: no charselector pattern found for %s\n' % (repr(selector)))
                 return
-            charselect=charselect.groupdict()
-            charselect['*']=charselect['charlen']
+            charselect = charselect.groupdict()
+            charselect['*'] = charselect['charlen']
             del charselect['charlen']
             if charselect['lenkind']:
-                lenkind=lenkindpattern.match(markoutercomma(charselect['lenkind']))
-                lenkind=lenkind.groupdict()
+                lenkind = lenkindpattern.match(
+                    markoutercomma(charselect['lenkind']))
+                lenkind = lenkind.groupdict()
                 for lk in ['len', 'kind']:
-                    if lenkind[lk+'2']:
-                        lenkind[lk]=lenkind[lk+'2']
-                    charselect[lk]=lenkind[lk]
-                    del lenkind[lk+'2']
+                    if lenkind[lk + '2']:
+                        lenkind[lk] = lenkind[lk + '2']
+                    charselect[lk] = lenkind[lk]
+                    del lenkind[lk + '2']
             del charselect['lenkind']
             for k in list(charselect.keys()):
-                if not charselect[k]: del charselect[k]
+                if not charselect[k]:
+                    del charselect[k]
             for k, i in list(charselect.items()):
                 charselect[k] = rmbadname1(i)
-        elif typespec=='type':
-            typename=re.match(r'\s*\(\s*(?P<name>\w+)\s*\)', selector, re.I)
-            if typename: typename=typename.group('name')
-            else: outmess('cracktypespec: no typename found in %s\n'%(repr(typespec+selector)))
+        elif typespec == 'type':
+            typename = re.match(r'\s*\(\s*(?P<name>\w+)\s*\)', selector, re.I)
+            if typename:
+                typename = typename.group('name')
+            else:
+                outmess('cracktypespec: no typename found in %s\n' %
+                        (repr(typespec + selector)))
         else:
-            outmess('cracktypespec: no selector used for %s\n'%(repr(selector)))
+            outmess('cracktypespec: no selector used for %s\n' %
+                    (repr(selector)))
     return kindselect, charselect, typename
 ######
-def setattrspec(decl,attr,force=0):
+
+
+def setattrspec(decl, attr, force=0):
     if not decl:
-        decl={}
+        decl = {}
     if not attr:
         return decl
     if 'attrspec' not in decl:
-        decl['attrspec']=[attr]
+        decl['attrspec'] = [attr]
         return decl
-    if force: decl['attrspec'].append(attr)
-    if attr in decl['attrspec']: return decl
-    if attr=='static' and 'automatic' not in decl['attrspec']:
+    if force:
         decl['attrspec'].append(attr)
-    elif attr=='automatic' and 'static' not in decl['attrspec']:
+    if attr in decl['attrspec']:
+        return decl
+    if attr == 'static' and 'automatic' not in decl['attrspec']:
         decl['attrspec'].append(attr)
-    elif attr=='public' and 'private' not in decl['attrspec']:
+    elif attr == 'automatic' and 'static' not in decl['attrspec']:
         decl['attrspec'].append(attr)
-    elif attr=='private' and 'public' not in decl['attrspec']:
+    elif attr == 'public' and 'private' not in decl['attrspec']:
+        decl['attrspec'].append(attr)
+    elif attr == 'private' and 'public' not in decl['attrspec']:
         decl['attrspec'].append(attr)
     else:
         decl['attrspec'].append(attr)
     return decl
 
-def setkindselector(decl,sel,force=0):
+
+def setkindselector(decl, sel, force=0):
     if not decl:
-        decl={}
+        decl = {}
     if not sel:
         return decl
     if 'kindselector' not in decl:
-        decl['kindselector']=sel
+        decl['kindselector'] = sel
         return decl
     for k in list(sel.keys()):
         if force or k not in decl['kindselector']:
-            decl['kindselector'][k]=sel[k]
+            decl['kindselector'][k] = sel[k]
     return decl
 
-def setcharselector(decl,sel,force=0):
+
+def setcharselector(decl, sel, force=0):
     if not decl:
-        decl={}
+        decl = {}
     if not sel:
         return decl
     if 'charselector' not in decl:
-        decl['charselector']=sel
+        decl['charselector'] = sel
         return decl
     for k in list(sel.keys()):
         if force or k not in decl['charselector']:
-            decl['charselector'][k]=sel[k]
+            decl['charselector'][k] = sel[k]
     return decl
 
-def getblockname(block,unknown='unknown'):
+
+def getblockname(block, unknown='unknown'):
     if 'name' in block:
         return block['name']
     return unknown
 
-###### post processing
+# post processing
+
 
 def setmesstext(block):
     global filepositiontext
 
     try:
-        filepositiontext='In: %s:%s\n'%(block['from'], block['name'])
+        filepositiontext = 'In: %s:%s\n' % (block['from'], block['name'])
     except:
         pass
 
+
 def get_usedict(block):
     usedict = {}
     if 'parent_block' in block:
@@ -1548,6 +1814,7 @@ def get_usedict(block):
         usedict.update(block['use'])
     return usedict
 
+
 def get_useparameters(block, param_map=None):
     global f90modulevars
 
@@ -1559,7 +1826,8 @@ def get_useparameters(block, param_map=None):
     for usename, mapping in list(usedict.items()):
         usename = usename.lower()
         if usename not in f90modulevars:
-            outmess('get_useparameters: no module %s info used by %s\n' % (usename, block.get('name')))
+            outmess('get_useparameters: no module %s info used by %s\n' %
+                    (usename, block.get('name')))
             continue
         mvars = f90modulevars[usename]
         params = get_parameters(mvars)
@@ -1570,13 +1838,14 @@ def get_useparameters(block, param_map=None):
             errmess('get_useparameters: mapping for %s not impl.' % (mapping))
         for k, v in list(params.items()):
             if k in param_map:
-                outmess('get_useparameters: overriding parameter %s with'\
+                outmess('get_useparameters: overriding parameter %s with'
                         ' value from module %s' % (repr(k), repr(usename)))
             param_map[k] = v
 
     return param_map
 
-def postcrack2(block,tab='',param_map=None):
+
+def postcrack2(block, tab='', param_map=None):
     global f90modulevars
 
     if not f90modulevars:
@@ -1584,11 +1853,11 @@ def postcrack2(block,tab='',param_map=None):
     if isinstance(block, list):
         ret = []
         for g in block:
-            g = postcrack2(g, tab=tab+'\t', param_map=param_map)
+            g = postcrack2(g, tab=tab + '\t', param_map=param_map)
             ret.append(g)
         return ret
     setmesstext(block)
-    outmess('%sBlock: %s\n'%(tab, block['name']), 0)
+    outmess('%sBlock: %s\n' % (tab, block['name']), 0)
 
     if param_map is None:
         param_map = get_useparameters(block)
@@ -1605,13 +1874,14 @@ def postcrack2(block,tab='',param_map=None):
                         kind['kind'] = param_map[val]
     new_body = []
     for b in block['body']:
-        b = postcrack2(b, tab=tab+'\t', param_map=param_map)
+        b = postcrack2(b, tab=tab + '\t', param_map=param_map)
         new_body.append(b)
     block['body'] = new_body
 
     return block
 
-def postcrack(block,args=None,tab=''):
+
+def postcrack(block, args=None, tab=''):
     """
     TODO:
           function return values
@@ -1620,22 +1890,23 @@ def postcrack(block,args=None,tab=''):
     global usermodules, onlyfunctions
 
     if isinstance(block, list):
-        gret=[]
-        uret=[]
+        gret = []
+        uret = []
         for g in block:
             setmesstext(g)
-            g=postcrack(g, tab=tab+'\t')
-            if 'name' in g and '__user__' in g['name']: # sort user routines to appear first
+            g = postcrack(g, tab=tab + '\t')
+            # sort user routines to appear first
+            if 'name' in g and '__user__' in g['name']:
                 uret.append(g)
             else:
                 gret.append(g)
-        return uret+gret
+        return uret + gret
     setmesstext(block)
     if not isinstance(block, dict) and 'block' not in block:
-        raise Exception('postcrack: Expected block dictionary instead of ' + \
+        raise Exception('postcrack: Expected block dictionary instead of ' +
                         str(block))
-    if 'name' in block and not block['name']=='unknown_interface':
-        outmess('%sBlock: %s\n'%(tab, block['name']), 0)
+    if 'name' in block and not block['name'] == 'unknown_interface':
+        outmess('%sBlock: %s\n' % (tab, block['name']), 0)
     block = analyzeargs(block)
     block = analyzecommon(block)
     block['vars'] = analyzevars(block)
@@ -1644,79 +1915,87 @@ def postcrack(block,args=None,tab=''):
         args = block['args']
     block['body'] = analyzebody(block, args, tab=tab)
 
-    userisdefined=[]
+    userisdefined = []
 ##     fromuser = []
     if 'use' in block:
-        useblock=block['use']
+        useblock = block['use']
         for k in list(useblock.keys()):
             if '__user__' in k:
                 userisdefined.append(k)
-##                 if 'map' in useblock[k]:
-##                     for n in useblock[k]['map'].itervalues():
+# if 'map' in useblock[k]:
+# for n in useblock[k]['map'].itervalues():
 ##                         if n not in fromuser: fromuser.append(n)
-    else: useblock={}
-    name=''
+    else:
+        useblock = {}
+    name = ''
     if 'name' in block:
-        name=block['name']
-    if 'externals' in block and block['externals']:# and not userisdefined: # Build a __user__ module
-        interfaced=[]
+        name = block['name']
+    # and not userisdefined: # Build a __user__ module
+    if 'externals' in block and block['externals']:
+        interfaced = []
         if 'interfaced' in block:
-            interfaced=block['interfaced']
-        mvars=copy.copy(block['vars'])
+            interfaced = block['interfaced']
+        mvars = copy.copy(block['vars'])
         if name:
-            mname=name+'__user__routines'
+            mname = name + '__user__routines'
         else:
-            mname='unknown__user__routines'
+            mname = 'unknown__user__routines'
         if mname in userisdefined:
-            i=1
-            while '%s_%i'%(mname, i) in userisdefined: i=i+1
-            mname='%s_%i'%(mname, i)
-        interface={'block':'interface','body':[],'vars':{},'name':name+'_user_interface'}
+            i = 1
+            while '%s_%i' % (mname, i) in userisdefined:
+                i = i + 1
+            mname = '%s_%i' % (mname, i)
+        interface = {'block': 'interface', 'body': [],
+                     'vars': {}, 'name': name + '_user_interface'}
         for e in block['externals']:
-##             if e in fromuser:
-##                 outmess('  Skipping %s that is defined explicitly in another use statement\n'%(`e`))
-##                 continue
+            # if e in fromuser:
+            #    outmess('  Skipping %s that is defined explicitly in another use statement\n'%(`e`))
+            #    continue
             if e in interfaced:
-                edef=[]
-                j=-1
+                edef = []
+                j = -1
                 for b in block['body']:
-                    j=j+1
-                    if b['block']=='interface':
-                        i=-1
+                    j = j + 1
+                    if b['block'] == 'interface':
+                        i = -1
                         for bb in b['body']:
-                            i=i+1
-                            if 'name' in bb and bb['name']==e:
-                                edef=copy.copy(bb)
+                            i = i + 1
+                            if 'name' in bb and bb['name'] == e:
+                                edef = copy.copy(bb)
                                 del b['body'][i]
                                 break
                         if edef:
-                            if not b['body']: del block['body'][j]
+                            if not b['body']:
+                                del block['body'][j]
                             del interfaced[interfaced.index(e)]
                             break
                 interface['body'].append(edef)
             else:
                 if e in mvars and not isexternal(mvars[e]):
-                    interface['vars'][e]=mvars[e]
+                    interface['vars'][e] = mvars[e]
         if interface['vars'] or interface['body']:
-            block['interfaced']=interfaced
-            mblock={'block':'python module','body':[interface],'vars':{},'name':mname,'interfaced':block['externals']}
-            useblock[mname]={}
+            block['interfaced'] = interfaced
+            mblock = {'block': 'python module', 'body': [
+                interface], 'vars': {}, 'name': mname, 'interfaced': block['externals']}
+            useblock[mname] = {}
             usermodules.append(mblock)
     if useblock:
-        block['use']=useblock
+        block['use'] = useblock
     return block
 
+
 def sortvarnames(vars):
     indep = []
     dep = []
     for v in list(vars.keys()):
         if 'depend' in vars[v] and vars[v]['depend']:
             dep.append(v)
-            #print '%s depends on %s'%(v,vars[v]['depend'])
-        else: indep.append(v)
+            # print '%s depends on %s'%(v,vars[v]['depend'])
+        else:
+            indep.append(v)
     n = len(dep)
     i = 0
-    while dep: #XXX: How to catch dependence cycles correctly?
+    while dep:  # XXX: How to catch dependence cycles correctly?
         v = dep[0]
         fl = 0
         for w in dep[1:]:
@@ -1724,12 +2003,12 @@ def sortvarnames(vars):
                 fl = 1
                 break
         if fl:
-            dep = dep[1:]+[v]
+            dep = dep[1:] + [v]
             i = i + 1
-            if i>n:
+            if i > n:
                 errmess('sortvarnames: failed to compute dependencies because'
                         ' of cyclic dependencies between '
-                        +', '.join(dep)+'\n')
+                        + ', '.join(dep) + '\n')
                 indep = indep + dep
                 break
         else:
@@ -1737,245 +2016,321 @@ def sortvarnames(vars):
             dep = dep[1:]
             n = len(dep)
             i = 0
-    #print indep
+    # print indep
     return indep
 
+
 def analyzecommon(block):
-    if not hascommon(block): return block
-    commonvars=[]
+    if not hascommon(block):
+        return block
+    commonvars = []
     for k in list(block['common'].keys()):
-        comvars=[]
+        comvars = []
         for e in block['common'][k]:
-            m=re.match(r'\A\s*\b(?P<name>.*?)\b\s*(\((?P<dims>.*?)\)|)\s*\Z', e, re.I)
+            m = re.match(
+                r'\A\s*\b(?P<name>.*?)\b\s*(\((?P<dims>.*?)\)|)\s*\Z', e, re.I)
             if m:
-                dims=[]
+                dims = []
                 if m.group('dims'):
-                    dims=[x.strip() for x in markoutercomma(m.group('dims')).split('@,@')]
-                n=m.group('name').strip()
+                    dims = [x.strip()
+                            for x in markoutercomma(m.group('dims')).split('@,@')]
+                n = m.group('name').strip()
                 if n in block['vars']:
                     if 'attrspec' in block['vars'][n]:
-                        block['vars'][n]['attrspec'].append('dimension(%s)'%(','.join(dims)))
+                        block['vars'][n]['attrspec'].append(
+                            'dimension(%s)' % (','.join(dims)))
                     else:
-                        block['vars'][n]['attrspec']=['dimension(%s)'%(','.join(dims))]
+                        block['vars'][n]['attrspec'] = [
+                            'dimension(%s)' % (','.join(dims))]
                 else:
                     if dims:
-                        block['vars'][n]={'attrspec':['dimension(%s)'%(','.join(dims))]}
-                    else: block['vars'][n]={}
-                if n not in commonvars: commonvars.append(n)
+                        block['vars'][n] = {
+                            'attrspec': ['dimension(%s)' % (','.join(dims))]}
+                    else:
+                        block['vars'][n] = {}
+                if n not in commonvars:
+                    commonvars.append(n)
             else:
-                n=e
-                errmess('analyzecommon: failed to extract "<name>[(<dims>)]" from "%s" in common /%s/.\n'%(e, k))
+                n = e
+                errmess(
+                    'analyzecommon: failed to extract "<name>[(<dims>)]" from "%s" in common /%s/.\n' % (e, k))
             comvars.append(n)
-        block['common'][k]=comvars
+        block['common'][k] = comvars
     if 'commonvars' not in block:
-        block['commonvars']=commonvars
+        block['commonvars'] = commonvars
     else:
-        block['commonvars']=block['commonvars']+commonvars
+        block['commonvars'] = block['commonvars'] + commonvars
     return block
 
-def analyzebody(block,args,tab=''):
+
+def analyzebody(block, args, tab=''):
     global usermodules, skipfuncs, onlyfuncs, f90modulevars
 
     setmesstext(block)
-    body=[]
+    body = []
     for b in block['body']:
         b['parent_block'] = block
         if b['block'] in ['function', 'subroutine']:
             if args is not None and b['name'] not in args:
                 continue
             else:
-                as_=b['args']
+                as_ = b['args']
             if b['name'] in skipfuncs:
                 continue
             if onlyfuncs and b['name'] not in onlyfuncs:
                 continue
-            b['saved_interface'] = crack2fortrangen(b, '\n'+' '*6, as_interface=True)
+            b['saved_interface'] = crack2fortrangen(
+                b, '\n' + ' ' * 6, as_interface=True)
 
-        else: as_=args
-        b=postcrack(b, as_, tab=tab+'\t')
-        if b['block']=='interface' and not b['body']:
+        else:
+            as_ = args
+        b = postcrack(b, as_, tab=tab + '\t')
+        if b['block'] == 'interface' and not b['body']:
             if 'f2pyenhancements' not in b:
                 continue
-        if b['block'].replace(' ', '')=='pythonmodule':
+        if b['block'].replace(' ', '') == 'pythonmodule':
             usermodules.append(b)
         else:
-            if b['block']=='module':
+            if b['block'] == 'module':
                 f90modulevars[b['name']] = b['vars']
             body.append(b)
     return body
 
+
 def buildimplicitrules(block):
     setmesstext(block)
-    implicitrules=defaultimplicitrules
-    attrrules={}
+    implicitrules = defaultimplicitrules
+    attrrules = {}
     if 'implicit' in block:
         if block['implicit'] is None:
-            implicitrules=None
-            if verbose>1:
-                outmess('buildimplicitrules: no implicit rules for routine %s.\n'%repr(block['name']))
+            implicitrules = None
+            if verbose > 1:
+                outmess(
+                    'buildimplicitrules: no implicit rules for routine %s.\n' % repr(block['name']))
         else:
             for k in list(block['implicit'].keys()):
                 if block['implicit'][k].get('typespec') not in ['static', 'automatic']:
-                    implicitrules[k]=block['implicit'][k]
+                    implicitrules[k] = block['implicit'][k]
                 else:
-                    attrrules[k]=block['implicit'][k]['typespec']
+                    attrrules[k] = block['implicit'][k]['typespec']
     return implicitrules, attrrules
 
-def myeval(e,g=None,l=None):
+
+def myeval(e, g=None, l=None):
     r = eval(e, g, l)
     if type(r) in [type(0), type(0.0)]:
         return r
     raise ValueError('r=%r' % (r))
 
 getlincoef_re_1 = re.compile(r'\A\b\w+\b\Z', re.I)
-def getlincoef(e, xset): # e = a*x+b ; x in xset
+
+
+def getlincoef(e, xset):  # e = a*x+b ; x in xset
     try:
         c = int(myeval(e, {}, {}))
         return 0, c, None
-    except: pass
+    except:
+        pass
     if getlincoef_re_1.match(e):
         return 1, 0, e
     len_e = len(e)
     for x in xset:
-        if len(x)>len_e: continue
-        if re.search(r'\w\s*\([^)]*\b'+x+r'\b', e):
+        if len(x) > len_e:
+            continue
+        if re.search(r'\w\s*\([^)]*\b' + x + r'\b', e):
             # skip function calls having x as an argument, e.g max(1, x)
             continue
-        re_1 = re.compile(r'(?P<before>.*?)\b'+x+r'\b(?P<after>.*)', re.I)
+        re_1 = re.compile(r'(?P<before>.*?)\b' + x + r'\b(?P<after>.*)', re.I)
         m = re_1.match(e)
         if m:
             try:
                 m1 = re_1.match(e)
                 while m1:
-                    ee = '%s(%s)%s'%(m1.group('before'), 0, m1.group('after'))
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 0, m1.group('after'))
                     m1 = re_1.match(ee)
                 b = myeval(ee, {}, {})
                 m1 = re_1.match(e)
                 while m1:
-                    ee = '%s(%s)%s'%(m1.group('before'), 1, m1.group('after'))
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 1, m1.group('after'))
                     m1 = re_1.match(ee)
                 a = myeval(ee, {}, {}) - b
                 m1 = re_1.match(e)
                 while m1:
-                    ee = '%s(%s)%s'%(m1.group('before'), 0.5, m1.group('after'))
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 0.5, m1.group('after'))
                     m1 = re_1.match(ee)
                 c = myeval(ee, {}, {})
                 # computing another point to be sure that expression is linear
                 m1 = re_1.match(e)
                 while m1:
-                    ee = '%s(%s)%s'%(m1.group('before'), 1.5, m1.group('after'))
+                    ee = '%s(%s)%s' % (
+                        m1.group('before'), 1.5, m1.group('after'))
                     m1 = re_1.match(ee)
                 c2 = myeval(ee, {}, {})
-                if (a*0.5+b==c and a*1.5+b==c2):
+                if (a * 0.5 + b == c and a * 1.5 + b == c2):
                     return a, b, x
-            except: pass
+            except:
+                pass
             break
     return None, None, None
 
 _varname_match = re.compile(r'\A[a-z]\w*\Z').match
-def getarrlen(dl,args,star='*'):
+
+
+def getarrlen(dl, args, star='*'):
     edl = []
-    try: edl.append(myeval(dl[0], {}, {}))
-    except: edl.append(dl[0])
-    try: edl.append(myeval(dl[1], {}, {}))
-    except: edl.append(dl[1])
+    try:
+        edl.append(myeval(dl[0], {}, {}))
+    except:
+        edl.append(dl[0])
+    try:
+        edl.append(myeval(dl[1], {}, {}))
+    except:
+        edl.append(dl[1])
     if isinstance(edl[0], int):
-        p1 = 1-edl[0]
-        if p1==0: d = str(dl[1])
-        elif p1<0: d = '%s-%s'%(dl[1], -p1)
-        else: d = '%s+%s'%(dl[1], p1)
+        p1 = 1 - edl[0]
+        if p1 == 0:
+            d = str(dl[1])
+        elif p1 < 0:
+            d = '%s-%s' % (dl[1], -p1)
+        else:
+            d = '%s+%s' % (dl[1], p1)
     elif isinstance(edl[1], int):
-        p1 = 1+edl[1]
-        if p1==0: d='-(%s)' % (dl[0])
-        else: d='%s-(%s)' % (p1, dl[0])
-    else: d = '%s-(%s)+1'%(dl[1], dl[0])
-    try: return repr(myeval(d, {}, {})), None, None
-    except: pass
-    d1, d2=getlincoef(dl[0], args), getlincoef(dl[1], args)
+        p1 = 1 + edl[1]
+        if p1 == 0:
+            d = '-(%s)' % (dl[0])
+        else:
+            d = '%s-(%s)' % (p1, dl[0])
+    else:
+        d = '%s-(%s)+1' % (dl[1], dl[0])
+    try:
+        return repr(myeval(d, {}, {})), None, None
+    except:
+        pass
+    d1, d2 = getlincoef(dl[0], args), getlincoef(dl[1], args)
     if None not in [d1[0], d2[0]]:
-        if (d1[0], d2[0])==(0, 0):
-            return repr(d2[1]-d1[1]+1), None, None
+        if (d1[0], d2[0]) == (0, 0):
+            return repr(d2[1] - d1[1] + 1), None, None
         b = d2[1] - d1[1] + 1
         d1 = (d1[0], 0, d1[2])
         d2 = (d2[0], b, d2[2])
-        if d1[0]==0 and d2[2] in args:
-            if b<0: return '%s * %s - %s'%(d2[0], d2[2], -b), d2[2], '+%s)/(%s)'%(-b, d2[0])
-            elif b: return '%s * %s + %s'%(d2[0], d2[2], b), d2[2], '-%s)/(%s)'%(b, d2[0])
-            else: return '%s * %s'%(d2[0], d2[2]), d2[2], ')/(%s)'%(d2[0])
-        if d2[0]==0 and d1[2] in args:
-
-            if b<0: return '%s * %s - %s'%(-d1[0], d1[2], -b), d1[2], '+%s)/(%s)'%(-b, -d1[0])
-            elif b: return '%s * %s + %s'%(-d1[0], d1[2], b), d1[2], '-%s)/(%s)'%(b, -d1[0])
-            else: return '%s * %s'%(-d1[0], d1[2]), d1[2], ')/(%s)'%(-d1[0])
-        if d1[2]==d2[2] and d1[2] in args:
+        if d1[0] == 0 and d2[2] in args:
+            if b < 0:
+                return '%s * %s - %s' % (d2[0], d2[2], -b), d2[2], '+%s)/(%s)' % (-b, d2[0])
+            elif b:
+                return '%s * %s + %s' % (d2[0], d2[2], b), d2[2], '-%s)/(%s)' % (b, d2[0])
+            else:
+                return '%s * %s' % (d2[0], d2[2]), d2[2], ')/(%s)' % (d2[0])
+        if d2[0] == 0 and d1[2] in args:
+
+            if b < 0:
+                return '%s * %s - %s' % (-d1[0], d1[2], -b), d1[2], '+%s)/(%s)' % (-b, -d1[0])
+            elif b:
+                return '%s * %s + %s' % (-d1[0], d1[2], b), d1[2], '-%s)/(%s)' % (b, -d1[0])
+            else:
+                return '%s * %s' % (-d1[0], d1[2]), d1[2], ')/(%s)' % (-d1[0])
+        if d1[2] == d2[2] and d1[2] in args:
             a = d2[0] - d1[0]
-            if not a: return repr(b), None, None
-            if b<0: return '%s * %s - %s'%(a, d1[2], -b), d2[2], '+%s)/(%s)'%(-b, a)
-            elif b: return '%s * %s + %s'%(a, d1[2], b), d2[2], '-%s)/(%s)'%(b, a)
-            else: return '%s * %s'%(a, d1[2]), d2[2], ')/(%s)'%(a)
-        if d1[0]==d2[0]==1:
+            if not a:
+                return repr(b), None, None
+            if b < 0:
+                return '%s * %s - %s' % (a, d1[2], -b), d2[2], '+%s)/(%s)' % (-b, a)
+            elif b:
+                return '%s * %s + %s' % (a, d1[2], b), d2[2], '-%s)/(%s)' % (b, a)
+            else:
+                return '%s * %s' % (a, d1[2]), d2[2], ')/(%s)' % (a)
+        if d1[0] == d2[0] == 1:
             c = str(d1[2])
             if c not in args:
                 if _varname_match(c):
                     outmess('\tgetarrlen:variable "%s" undefined\n' % (c))
-                c = '(%s)'%c
-            if b==0: d='%s-%s' % (d2[2], c)
-            elif b<0: d='%s-%s-%s' % (d2[2], c, -b)
-            else: d='%s-%s+%s' % (d2[2], c, b)
-        elif d1[0]==0:
+                c = '(%s)' % c
+            if b == 0:
+                d = '%s-%s' % (d2[2], c)
+            elif b < 0:
+                d = '%s-%s-%s' % (d2[2], c, -b)
+            else:
+                d = '%s-%s+%s' % (d2[2], c, b)
+        elif d1[0] == 0:
             c2 = str(d2[2])
             if c2 not in args:
                 if _varname_match(c2):
                     outmess('\tgetarrlen:variable "%s" undefined\n' % (c2))
-                c2 = '(%s)'%c2
-            if d2[0]==1: pass
-            elif d2[0]==-1: c2='-%s' %c2
-            else: c2='%s*%s'%(d2[0], c2)
-
-            if b==0: d=c2
-            elif b<0: d='%s-%s' % (c2, -b)
-            else: d='%s+%s' % (c2, b)
-        elif d2[0]==0:
+                c2 = '(%s)' % c2
+            if d2[0] == 1:
+                pass
+            elif d2[0] == -1:
+                c2 = '-%s' % c2
+            else:
+                c2 = '%s*%s' % (d2[0], c2)
+
+            if b == 0:
+                d = c2
+            elif b < 0:
+                d = '%s-%s' % (c2, -b)
+            else:
+                d = '%s+%s' % (c2, b)
+        elif d2[0] == 0:
             c1 = str(d1[2])
             if c1 not in args:
                 if _varname_match(c1):
                     outmess('\tgetarrlen:variable "%s" undefined\n' % (c1))
-                c1 = '(%s)'%c1
-            if d1[0]==1: c1='-%s'%c1
-            elif d1[0]==-1: c1='+%s'%c1
-            elif d1[0]<0: c1='+%s*%s'%(-d1[0], c1)
-            else: c1 = '-%s*%s' % (d1[0], c1)
-
-            if b==0: d=c1
-            elif b<0: d='%s-%s' % (c1, -b)
-            else: d='%s+%s' % (c1, b)
+                c1 = '(%s)' % c1
+            if d1[0] == 1:
+                c1 = '-%s' % c1
+            elif d1[0] == -1:
+                c1 = '+%s' % c1
+            elif d1[0] < 0:
+                c1 = '+%s*%s' % (-d1[0], c1)
+            else:
+                c1 = '-%s*%s' % (d1[0], c1)
+
+            if b == 0:
+                d = c1
+            elif b < 0:
+                d = '%s-%s' % (c1, -b)
+            else:
+                d = '%s+%s' % (c1, b)
         else:
             c1 = str(d1[2])
             if c1 not in args:
                 if _varname_match(c1):
                     outmess('\tgetarrlen:variable "%s" undefined\n' % (c1))
-                c1 = '(%s)'%c1
-            if d1[0]==1: c1='-%s'%c1
-            elif d1[0]==-1: c1='+%s'%c1
-            elif d1[0]<0: c1='+%s*%s'%(-d1[0], c1)
-            else: c1 = '-%s*%s' % (d1[0], c1)
+                c1 = '(%s)' % c1
+            if d1[0] == 1:
+                c1 = '-%s' % c1
+            elif d1[0] == -1:
+                c1 = '+%s' % c1
+            elif d1[0] < 0:
+                c1 = '+%s*%s' % (-d1[0], c1)
+            else:
+                c1 = '-%s*%s' % (d1[0], c1)
 
             c2 = str(d2[2])
             if c2 not in args:
                 if _varname_match(c2):
                     outmess('\tgetarrlen:variable "%s" undefined\n' % (c2))
-                c2 = '(%s)'%c2
-            if d2[0]==1: pass
-            elif d2[0]==-1: c2='-%s' %c2
-            else: c2='%s*%s'%(d2[0], c2)
-
-            if b==0: d='%s%s' % (c2, c1)
-            elif b<0: d='%s%s-%s' % (c2, c1, -b)
-            else: d='%s%s+%s' % (c2, c1, b)
+                c2 = '(%s)' % c2
+            if d2[0] == 1:
+                pass
+            elif d2[0] == -1:
+                c2 = '-%s' % c2
+            else:
+                c2 = '%s*%s' % (d2[0], c2)
+
+            if b == 0:
+                d = '%s%s' % (c2, c1)
+            elif b < 0:
+                d = '%s%s-%s' % (c2, c1, -b)
+            else:
+                d = '%s%s+%s' % (c2, c1, b)
     return d, None, None
 
 word_pattern = re.compile(r'\b[a-z][\w$]*\b', re.I)
 
+
 def _get_depend_dict(name, vars, deps):
     if name in vars:
         words = vars[name].get('depend', [])
@@ -1995,6 +2350,7 @@ def _get_depend_dict(name, vars, deps):
     deps[name] = words
     return words
 
+
 def _calc_depend_dict(vars):
     names = list(vars.keys())
     depend_dict = {}
@@ -2002,6 +2358,7 @@ def _calc_depend_dict(vars):
         _get_depend_dict(n, vars, depend_dict)
     return depend_dict
 
+
 def get_sorted_names(vars):
     """
     """
@@ -2021,31 +2378,41 @@ def get_sorted_names(vars):
                 depend_dict[name] = new_lst
     return [name for name in names if name in vars]
 
+
 def _kind_func(string):
-    #XXX: return something sensible.
+    # XXX: return something sensible.
     if string[0] in "'\"":
         string = string[1:-1]
     if real16pattern.match(string):
         return 8
     elif real8pattern.match(string):
         return 4
-    return 'kind('+string+')'
+    return 'kind(' + string + ')'
+
 
 def _selected_int_kind_func(r):
-    #XXX: This should be processor dependent
-    m = 10**r
-    if m<=2**8: return 1
-    if m<=2**16: return 2
-    if m<=2**32: return 4
-    if m<=2**63: return 8
-    if m<=2**128: return 16
+    # XXX: This should be processor dependent
+    m = 10 ** r
+    if m <= 2 ** 8:
+        return 1
+    if m <= 2 ** 16:
+        return 2
+    if m <= 2 ** 32:
+        return 4
+    if m <= 2 ** 63:
+        return 8
+    if m <= 2 ** 128:
+        return 16
     return -1
 
+
 def _selected_real_kind_func(p, r=0, radix=0):
-    #XXX: This should be processor dependent
+    # XXX: This should be processor dependent
     # This is only good for 0 <= p <= 20
-    if p < 7: return 4
-    if p < 16: return 8
+    if p < 7:
+        return 4
+    if p < 16:
+        return 8
     if platform.machine().lower().startswith('power'):
         if p <= 20:
             return 16
@@ -2056,13 +2423,13 @@ def _selected_real_kind_func(p, r=0, radix=0):
             return 16
     return -1
 
+
 def get_parameters(vars, global_params={}):
     params = copy.copy(global_params)
     g_params = copy.copy(global_params)
     for name, func in [('kind', _kind_func),
-                      ('selected_int_kind', _selected_int_kind_func),
-                      ('selected_real_kind', _selected_real_kind_func),
-                      ]:
+                       ('selected_int_kind', _selected_int_kind_func),
+                       ('selected_real_kind', _selected_real_kind_func), ]:
         if name not in g_params:
             g_params[name] = func
     param_names = []
@@ -2070,8 +2437,10 @@ def get_parameters(vars, global_params={}):
         if 'attrspec' in vars[n] and 'parameter' in vars[n]['attrspec']:
             param_names.append(n)
     kind_re = re.compile(r'\bkind\s*\(\s*(?P<value>.*)\s*\)', re.I)
-    selected_int_kind_re = re.compile(r'\bselected_int_kind\s*\(\s*(?P<value>.*)\s*\)', re.I)
-    selected_kind_re = re.compile(r'\bselected_(int|real)_kind\s*\(\s*(?P<value>.*)\s*\)', re.I)
+    selected_int_kind_re = re.compile(
+        r'\bselected_int_kind\s*\(\s*(?P<value>.*)\s*\)', re.I)
+    selected_kind_re = re.compile(
+        r'\bselected_(int|real)_kind\s*\(\s*(?P<value>.*)\s*\)', re.I)
     for n in param_names:
         if '=' in vars[n]:
             v = vars[n]['=']
@@ -2080,8 +2449,8 @@ def get_parameters(vars, global_params={}):
                 for repl in [
                     ('.false.', 'False'),
                     ('.true.', 'True'),
-                    #TODO: test .eq., .neq., etc replacements.
-                    ]:
+                    # TODO: test .eq., .neq., etc replacements.
+                ]:
                     v = v.replace(*repl)
             v = kind_re.sub(r'kind("\1")', v)
             v = selected_int_kind_re.sub(r'selected_int_kind(\1)', v)
@@ -2090,8 +2459,8 @@ def get_parameters(vars, global_params={}):
             if isdouble(vars[n]):
                 tt = list(v)
                 for m in real16pattern.finditer(v):
-                    tt[m.start():m.end()] = list(\
-                            v[m.start():m.end()].lower().replace('d', 'e'))
+                    tt[m.start():m.end()] = list(
+                        v[m.start():m.end()].lower().replace('d', 'e'))
                 v = ''.join(tt)
             if iscomplex(vars[n]):
                 if v[0] == '(' and v[-1] == ')':
@@ -2101,18 +2470,20 @@ def get_parameters(vars, global_params={}):
                 params[n] = eval(v, g_params, params)
             except Exception as msg:
                 params[n] = v
-                #print params
+                # print params
                 outmess('get_parameters: got "%s" on %s\n' % (msg, repr(v)))
             if isstring(vars[n]) and isinstance(params[n], int):
                 params[n] = chr(params[n])
             nl = n.lower()
-            if nl!=n:
+            if nl != n:
                 params[nl] = params[n]
         else:
             print(vars[n])
-            outmess('get_parameters:parameter %s does not have value?!\n'%(repr(n)))
+            outmess(
+                'get_parameters:parameter %s does not have value?!\n' % (repr(n)))
     return params
 
+
 def _eval_length(length, params):
     if length in ['(:)', '(*)', '*']:
         return '(*)'
@@ -2120,6 +2491,7 @@ def _eval_length(length, params):
 
 _is_kind_number = re.compile(r'\d+_').match
 
+
 def _eval_scalar(value, params):
     if _is_kind_number(value):
         value = value.split('_')[0]
@@ -2128,28 +2500,29 @@ def _eval_scalar(value, params):
     except (NameError, SyntaxError):
         return value
     except Exception as msg:
-        errmess('"%s" in evaluating %r '\
-                '(available names: %s)\n' \
+        errmess('"%s" in evaluating %r '
+                '(available names: %s)\n'
                 % (msg, value, list(params.keys())))
     return value
 
+
 def analyzevars(block):
     global f90modulevars
 
     setmesstext(block)
-    implicitrules, attrrules=buildimplicitrules(block)
-    vars=copy.copy(block['vars'])
-    if block['block']=='function' and block['name'] not in vars:
-        vars[block['name']]={}
+    implicitrules, attrrules = buildimplicitrules(block)
+    vars = copy.copy(block['vars'])
+    if block['block'] == 'function' and block['name'] not in vars:
+        vars[block['name']] = {}
     if '' in block['vars']:
         del vars['']
         if 'attrspec' in block['vars']['']:
-            gen=block['vars']['']['attrspec']
+            gen = block['vars']['']['attrspec']
             for n in list(vars.keys()):
                 for k in ['public', 'private']:
                     if k in gen:
-                        vars[n]=setattrspec(vars[n], k)
-    svars=[]
+                        vars[n] = setattrspec(vars[n], k)
+    svars = []
     args = block['args']
     for a in args:
         try:
@@ -2158,7 +2531,8 @@ def analyzevars(block):
         except KeyError:
             pass
     for n in list(vars.keys()):
-        if n not in args: svars.append(n)
+        if n not in args:
+            svars.append(n)
 
     params = get_parameters(vars, get_useparameters(block))
 
@@ -2171,24 +2545,25 @@ def analyzevars(block):
             try:
                 dep_matches[n]
             except KeyError:
-                dep_matches[n] = re.compile(r'.*\b%s\b'%(v), re.I).match
+                dep_matches[n] = re.compile(r'.*\b%s\b' % (v), re.I).match
     for n in svars:
         if n[0] in list(attrrules.keys()):
-            vars[n]=setattrspec(vars[n], attrrules[n[0]])
+            vars[n] = setattrspec(vars[n], attrrules[n[0]])
         if 'typespec' not in vars[n]:
             if not('attrspec' in vars[n] and 'external' in vars[n]['attrspec']):
                 if implicitrules:
                     ln0 = n[0].lower()
                     for k in list(implicitrules[ln0].keys()):
-                        if k=='typespec' and implicitrules[ln0][k]=='undefined':
+                        if k == 'typespec' and implicitrules[ln0][k] == 'undefined':
                             continue
                         if k not in vars[n]:
-                            vars[n][k]=implicitrules[ln0][k]
-                        elif k=='attrspec':
+                            vars[n][k] = implicitrules[ln0][k]
+                        elif k == 'attrspec':
                             for l in implicitrules[ln0][k]:
-                                vars[n]=setattrspec(vars[n], l)
+                                vars[n] = setattrspec(vars[n], l)
                 elif n in block['args']:
-                    outmess('analyzevars: typespec of variable %s is not defined in routine %s.\n'%(repr(n), block['name']))
+                    outmess('analyzevars: typespec of variable %s is not defined in routine %s.\n' % (
+                        repr(n), block['name']))
 
         if 'charselector' in vars[n]:
             if 'len' in vars[n]['charselector']:
@@ -2210,89 +2585,101 @@ def analyzevars(block):
 
         savelindims = {}
         if 'attrspec' in vars[n]:
-            attr=vars[n]['attrspec']
+            attr = vars[n]['attrspec']
             attr.reverse()
-            vars[n]['attrspec']=[]
-            dim, intent, depend, check, note=None, None, None, None, None
+            vars[n]['attrspec'] = []
+            dim, intent, depend, check, note = None, None, None, None, None
             for a in attr:
-                if a[:9]=='dimension': dim=(a[9:].strip())[1:-1]
-                elif a[:6]=='intent': intent=(a[6:].strip())[1:-1]
-                elif a[:6]=='depend': depend=(a[6:].strip())[1:-1]
-                elif a[:5]=='check': check=(a[5:].strip())[1:-1]
-                elif a[:4]=='note': note=(a[4:].strip())[1:-1]
-                else: vars[n]=setattrspec(vars[n], a)
+                if a[:9] == 'dimension':
+                    dim = (a[9:].strip())[1:-1]
+                elif a[:6] == 'intent':
+                    intent = (a[6:].strip())[1:-1]
+                elif a[:6] == 'depend':
+                    depend = (a[6:].strip())[1:-1]
+                elif a[:5] == 'check':
+                    check = (a[5:].strip())[1:-1]
+                elif a[:4] == 'note':
+                    note = (a[4:].strip())[1:-1]
+                else:
+                    vars[n] = setattrspec(vars[n], a)
                 if intent:
                     if 'intent' not in vars[n]:
-                        vars[n]['intent']=[]
+                        vars[n]['intent'] = []
                     for c in [x.strip() for x in markoutercomma(intent).split('@,@')]:
                         # Remove spaces so that 'in out' becomes 'inout'
                         tmp = c.replace(' ', '')
                         if tmp not in vars[n]['intent']:
                             vars[n]['intent'].append(tmp)
-                    intent=None
+                    intent = None
                 if note:
-                    note=note.replace('\\n\\n', '\n\n')
-                    note=note.replace('\\n ', '\n')
+                    note = note.replace('\\n\\n', '\n\n')
+                    note = note.replace('\\n ', '\n')
                     if 'note' not in vars[n]:
-                        vars[n]['note']=[note]
+                        vars[n]['note'] = [note]
                     else:
                         vars[n]['note'].append(note)
-                    note=None
+                    note = None
                 if depend is not None:
                     if 'depend' not in vars[n]:
-                        vars[n]['depend']=[]
+                        vars[n]['depend'] = []
                     for c in rmbadname([x.strip() for x in markoutercomma(depend).split('@,@')]):
                         if c not in vars[n]['depend']:
                             vars[n]['depend'].append(c)
-                    depend=None
+                    depend = None
                 if check is not None:
                     if 'check' not in vars[n]:
-                        vars[n]['check']=[]
+                        vars[n]['check'] = []
                     for c in [x.strip() for x in markoutercomma(check).split('@,@')]:
                         if c not in vars[n]['check']:
                             vars[n]['check'].append(c)
-                    check=None
+                    check = None
             if dim and 'dimension' not in vars[n]:
-                vars[n]['dimension']=[]
+                vars[n]['dimension'] = []
                 for d in rmbadname([x.strip() for x in markoutercomma(dim).split('@,@')]):
                     star = '*'
-                    if d==':':
-                        star=':'
+                    if d == ':':
+                        star = ':'
                     if d in params:
                         d = str(params[d])
                     for p in list(params.keys()):
-                        m = re.match(r'(?P<before>.*?)\b'+p+r'\b(?P<after>.*)', d, re.I)
+                        m = re.match(
+                            r'(?P<before>.*?)\b' + p + r'\b(?P<after>.*)', d, re.I)
                         if m:
                             #outmess('analyzevars:replacing parameter %s in %s (dimension of %s) with %s\n'%(`p`,`d`,`n`,`params[p]`))
-                            d = m.group('before')+str(params[p])+m.group('after')
-                    if d==star:
+                            d = m.group('before') + \
+                                str(params[p]) + m.group('after')
+                    if d == star:
                         dl = [star]
                     else:
-                        dl=markoutercomma(d, ':').split('@:@')
-                    if len(dl)==2 and '*' in dl: # e.g. dimension(5:*)
+                        dl = markoutercomma(d, ':').split('@:@')
+                    if len(dl) == 2 and '*' in dl:  # e.g. dimension(5:*)
                         dl = ['*']
                         d = '*'
-                    if len(dl)==1 and not dl[0]==star: dl = ['1', dl[0]]
-                    if len(dl)==2:
+                    if len(dl) == 1 and not dl[0] == star:
+                        dl = ['1', dl[0]]
+                    if len(dl) == 2:
                         d, v, di = getarrlen(dl, list(block['vars'].keys()))
-                        if d[:4] == '1 * ': d = d[4:]
-                        if di and di[-4:] == '/(1)': di = di[:-4]
-                        if v: savelindims[d] = v, di
+                        if d[:4] == '1 * ':
+                            d = d[4:]
+                        if di and di[-4:] == '/(1)':
+                            di = di[:-4]
+                        if v:
+                            savelindims[d] = v, di
                     vars[n]['dimension'].append(d)
         if 'dimension' in vars[n]:
             if isintent_c(vars[n]):
                 shape_macro = 'shape'
             else:
-                shape_macro = 'shape'#'fshape'
+                shape_macro = 'shape'  # 'fshape'
             if isstringarray(vars[n]):
                 if 'charselector' in vars[n]:
                     d = vars[n]['charselector']
                     if '*' in d:
                         d = d['*']
-                        errmess('analyzevars: character array "character*%s %s(%s)" is considered as "character %s(%s)"; "intent(c)" is forced.\n'\
-                                %(d, n,
-                                  ','.join(vars[n]['dimension']),
-                                  n, ','.join(vars[n]['dimension']+[d])))
+                        errmess('analyzevars: character array "character*%s %s(%s)" is considered as "character %s(%s)"; "intent(c)" is forced.\n'
+                                % (d, n,
+                                   ','.join(vars[n]['dimension']),
+                                   n, ','.join(vars[n]['dimension'] + [d])))
                         vars[n]['dimension'].append(d)
                         del vars[n]['charselector']
                         if 'intent' not in vars[n]:
@@ -2300,64 +2687,67 @@ def analyzevars(block):
                         if 'c' not in vars[n]['intent']:
                             vars[n]['intent'].append('c')
                     else:
-                        errmess("analyzevars: charselector=%r unhandled." % (d))
+                        errmess(
+                            "analyzevars: charselector=%r unhandled." % (d))
         if 'check' not in vars[n] and 'args' in block and n in block['args']:
             flag = 'depend' not in vars[n]
             if flag:
-                vars[n]['depend']=[]
-            vars[n]['check']=[]
+                vars[n]['depend'] = []
+            vars[n]['check'] = []
             if 'dimension' in vars[n]:
                 #/----< no check
-                #vars[n]['check'].append('rank(%s)==%s'%(n,len(vars[n]['dimension'])))
-                i=-1; ni=len(vars[n]['dimension'])
+                # vars[n]['check'].append('rank(%s)==%s'%(n,len(vars[n]['dimension'])))
+                i = -1
+                ni = len(vars[n]['dimension'])
                 for d in vars[n]['dimension']:
-                    ddeps=[] # dependecies of 'd'
-                    ad=''
-                    pd=''
+                    ddeps = []  # dependecies of 'd'
+                    ad = ''
+                    pd = ''
                     #origd = d
                     if d not in vars:
                         if d in savelindims:
-                            pd, ad='(', savelindims[d][1]
+                            pd, ad = '(', savelindims[d][1]
                             d = savelindims[d][0]
                         else:
                             for r in block['args']:
-                            #for r in block['vars'].iterkeys():
                                 if r not in vars:
                                     continue
-                                if re.match(r'.*?\b'+r+r'\b', d, re.I):
+                                if re.match(r'.*?\b' + r + r'\b', d, re.I):
                                     ddeps.append(r)
                     if d in vars:
                         if 'attrspec' in vars[d]:
                             for aa in vars[d]['attrspec']:
-                                if aa[:6]=='depend':
+                                if aa[:6] == 'depend':
                                     ddeps += aa[6:].strip()[1:-1].split(',')
                         if 'depend' in vars[d]:
-                            ddeps=ddeps+vars[d]['depend']
-                    i=i+1
+                            ddeps = ddeps + vars[d]['depend']
+                    i = i + 1
                     if d in vars and ('depend' not in vars[d]) \
                        and ('=' not in vars[d]) and (d not in vars[n]['depend']) \
                        and l_or(isintent_in, isintent_inout, isintent_inplace)(vars[n]):
-                        vars[d]['depend']=[n]
-                        if ni>1:
-                            vars[d]['=']='%s%s(%s,%s)%s'% (pd, shape_macro, n, i, ad)
+                        vars[d]['depend'] = [n]
+                        if ni > 1:
+                            vars[d]['='] = '%s%s(%s,%s)%s' % (
+                                pd, shape_macro, n, i, ad)
                         else:
-                            vars[d]['=']='%slen(%s)%s'% (pd, n, ad)
+                            vars[d]['='] = '%slen(%s)%s' % (pd, n, ad)
                         #  /---< no check
                         if 1 and 'check' not in vars[d]:
-                            if ni>1:
-                                vars[d]['check']=['%s%s(%s,%i)%s==%s'\
-                                                  %(pd, shape_macro, n, i, ad, d)]
+                            if ni > 1:
+                                vars[d]['check'] = ['%s%s(%s,%i)%s==%s'
+                                                    % (pd, shape_macro, n, i, ad, d)]
                             else:
-                                vars[d]['check']=['%slen(%s)%s>=%s'%(pd, n, ad, d)]
+                                vars[d]['check'] = [
+                                    '%slen(%s)%s>=%s' % (pd, n, ad, d)]
                         if 'attrspec' not in vars[d]:
-                            vars[d]['attrspec']=['optional']
+                            vars[d]['attrspec'] = ['optional']
                         if ('optional' not in vars[d]['attrspec']) and\
                            ('required' not in vars[d]['attrspec']):
                             vars[d]['attrspec'].append('optional')
                     elif d not in ['*', ':']:
                         #/----< no check
                         #if ni>1: vars[n]['check'].append('shape(%s,%i)==%s'%(n,i,d))
-                        #else: vars[n]['check'].append('len(%s)>=%s'%(n,d))
+                        # else: vars[n]['check'].append('len(%s)>=%s'%(n,d))
                         if flag:
                             if d in vars:
                                 if n not in ddeps:
@@ -2365,17 +2755,17 @@ def analyzevars(block):
                             else:
                                 vars[n]['depend'] = vars[n]['depend'] + ddeps
             elif isstring(vars[n]):
-                length='1'
+                length = '1'
                 if 'charselector' in vars[n]:
                     if '*' in vars[n]['charselector']:
                         length = _eval_length(vars[n]['charselector']['*'],
                                               params)
-                        vars[n]['charselector']['*']=length
+                        vars[n]['charselector']['*'] = length
                     elif 'len' in vars[n]['charselector']:
                         length = _eval_length(vars[n]['charselector']['len'],
                                               params)
                         del vars[n]['charselector']['len']
-                        vars[n]['charselector']['*']=length
+                        vars[n]['charselector']['*'] = length
 
             if not vars[n]['check']:
                 del vars[n]['check']
@@ -2383,54 +2773,66 @@ def analyzevars(block):
                 del vars[n]['depend']
         if '=' in vars[n]:
             if 'attrspec' not in vars[n]:
-                vars[n]['attrspec']=[]
+                vars[n]['attrspec'] = []
             if ('optional' not in vars[n]['attrspec']) and \
                ('required' not in vars[n]['attrspec']):
                 vars[n]['attrspec'].append('optional')
             if 'depend' not in vars[n]:
-                vars[n]['depend']=[]
+                vars[n]['depend'] = []
                 for v, m in list(dep_matches.items()):
-                    if m(vars[n]['=']): vars[n]['depend'].append(v)
-                if not vars[n]['depend']: del vars[n]['depend']
+                    if m(vars[n]['=']):
+                        vars[n]['depend'].append(v)
+                if not vars[n]['depend']:
+                    del vars[n]['depend']
             if isscalar(vars[n]):
                 vars[n]['='] = _eval_scalar(vars[n]['='], params)
 
     for n in list(vars.keys()):
-        if n==block['name']: # n is block name
+        if n == block['name']:  # n is block name
             if 'note' in vars[n]:
-                block['note']=vars[n]['note']
-            if block['block']=='function':
+                block['note'] = vars[n]['note']
+            if block['block'] == 'function':
                 if 'result' in block and block['result'] in vars:
-                    vars[n]=appenddecl(vars[n], vars[block['result']])
+                    vars[n] = appenddecl(vars[n], vars[block['result']])
                 if 'prefix' in block:
-                    pr=block['prefix']; ispure=0; isrec=1
-                    pr1=pr.replace('pure', '')
-                    ispure=(not pr==pr1)
-                    pr=pr1.replace('recursive', '')
-                    isrec=(not pr==pr1)
-                    m=typespattern[0].match(pr)
+                    pr = block['prefix']
+                    ispure = 0
+                    isrec = 1
+                    pr1 = pr.replace('pure', '')
+                    ispure = (not pr == pr1)
+                    pr = pr1.replace('recursive', '')
+                    isrec = (not pr == pr1)
+                    m = typespattern[0].match(pr)
                     if m:
-                        typespec, selector, attr, edecl=cracktypespec0(m.group('this'), m.group('after'))
-                        kindselect, charselect, typename=cracktypespec(typespec, selector)
-                        vars[n]['typespec']=typespec
+                        typespec, selector, attr, edecl = cracktypespec0(
+                            m.group('this'), m.group('after'))
+                        kindselect, charselect, typename = cracktypespec(
+                            typespec, selector)
+                        vars[n]['typespec'] = typespec
                         if kindselect:
                             if 'kind' in kindselect:
                                 try:
-                                    kindselect['kind'] = eval(kindselect['kind'], {}, params)
+                                    kindselect['kind'] = eval(
+                                        kindselect['kind'], {}, params)
                                 except:
                                     pass
-                            vars[n]['kindselector']=kindselect
-                        if charselect: vars[n]['charselector']=charselect
-                        if typename: vars[n]['typename']=typename
-                        if ispure: vars[n]=setattrspec(vars[n], 'pure')
-                        if isrec: vars[n]=setattrspec(vars[n], 'recursive')
+                            vars[n]['kindselector'] = kindselect
+                        if charselect:
+                            vars[n]['charselector'] = charselect
+                        if typename:
+                            vars[n]['typename'] = typename
+                        if ispure:
+                            vars[n] = setattrspec(vars[n], 'pure')
+                        if isrec:
+                            vars[n] = setattrspec(vars[n], 'recursive')
                     else:
-                        outmess('analyzevars: prefix (%s) were not used\n'%repr(block['prefix']))
+                        outmess(
+                            'analyzevars: prefix (%s) were not used\n' % repr(block['prefix']))
     if not block['block'] in ['module', 'pythonmodule', 'python module', 'block data']:
         if 'commonvars' in block:
-            neededvars=copy.copy(block['args']+block['commonvars'])
+            neededvars = copy.copy(block['args'] + block['commonvars'])
         else:
-            neededvars=copy.copy(block['args'])
+            neededvars = copy.copy(block['args'])
         for n in list(vars.keys()):
             if l_or(isintent_callback, isintent_aux)(vars[n]):
                 neededvars.append(n)
@@ -2440,7 +2842,7 @@ def analyzevars(block):
                 for n in block['entry'][k]:
                     if n not in neededvars:
                         neededvars.append(n)
-        if block['block']=='function':
+        if block['block'] == 'function':
             if 'result' in block:
                 neededvars.append(block['result'])
             else:
@@ -2457,126 +2859,141 @@ def analyzevars(block):
     return vars
 
 analyzeargs_re_1 = re.compile(r'\A[a-z]+[\w$]*\Z', re.I)
+
+
 def expr2name(a, block, args=[]):
     orig_a = a
     a_is_expr = not analyzeargs_re_1.match(a)
-    if a_is_expr: # `a` is an expression
-        implicitrules, attrrules=buildimplicitrules(block)
-        at=determineexprtype(a, block['vars'], implicitrules)
-        na='e_'
+    if a_is_expr:  # `a` is an expression
+        implicitrules, attrrules = buildimplicitrules(block)
+        at = determineexprtype(a, block['vars'], implicitrules)
+        na = 'e_'
         for c in a:
             c = c.lower()
-            if c not in string.ascii_lowercase+string.digits: c='_'
-            na=na+c
-        if na[-1]=='_': na=na+'e'
-        else: na=na+'_e'
-        a=na
+            if c not in string.ascii_lowercase + string.digits:
+                c = '_'
+            na = na + c
+        if na[-1] == '_':
+            na = na + 'e'
+        else:
+            na = na + '_e'
+        a = na
         while a in block['vars'] or a in block['args']:
-            a=a+'r'
+            a = a + 'r'
     if a in args:
         k = 1
         while a + str(k) in args:
             k = k + 1
         a = a + str(k)
     if a_is_expr:
-        block['vars'][a]=at
+        block['vars'][a] = at
     else:
         if a not in block['vars']:
             if orig_a in block['vars']:
                 block['vars'][a] = block['vars'][orig_a]
             else:
-                block['vars'][a]={}
-        if 'externals' in block and orig_a in block['externals']+block['interfaced']:
-            block['vars'][a]=setattrspec(block['vars'][a], 'external')
+                block['vars'][a] = {}
+        if 'externals' in block and orig_a in block['externals'] + block['interfaced']:
+            block['vars'][a] = setattrspec(block['vars'][a], 'external')
     return a
 
+
 def analyzeargs(block):
     setmesstext(block)
-    implicitrules, attrrules=buildimplicitrules(block)
+    implicitrules, attrrules = buildimplicitrules(block)
     if 'args' not in block:
-        block['args']=[]
-    args=[]
+        block['args'] = []
+    args = []
     for a in block['args']:
         a = expr2name(a, block, args)
         args.append(a)
-    block['args']=args
+    block['args'] = args
     if 'entry' in block:
         for k, args1 in list(block['entry'].items()):
             for a in args1:
                 if a not in block['vars']:
-                    block['vars'][a]={}
+                    block['vars'][a] = {}
 
     for b in block['body']:
         if b['name'] in args:
             if 'externals' not in block:
-                block['externals']=[]
+                block['externals'] = []
             if b['name'] not in block['externals']:
                 block['externals'].append(b['name'])
     if 'result' in block and block['result'] not in block['vars']:
-        block['vars'][block['result']]={}
+        block['vars'][block['result']] = {}
     return block
 
 determineexprtype_re_1 = re.compile(r'\A\(.+?[,].+?\)\Z', re.I)
 determineexprtype_re_2 = re.compile(r'\A[+-]?\d+(_(P<name>[\w]+)|)\Z', re.I)
-determineexprtype_re_3 = re.compile(r'\A[+-]?[\d.]+[\d+-de.]*(_(P<name>[\w]+)|)\Z', re.I)
+determineexprtype_re_3 = re.compile(
+    r'\A[+-]?[\d.]+[\d+-de.]*(_(P<name>[\w]+)|)\Z', re.I)
 determineexprtype_re_4 = re.compile(r'\A\(.*\)\Z', re.I)
 determineexprtype_re_5 = re.compile(r'\A(?P<name>\w+)\s*\(.*?\)\s*\Z', re.I)
+
+
 def _ensure_exprdict(r):
     if isinstance(r, int):
-        return {'typespec':'integer'}
+        return {'typespec': 'integer'}
     if isinstance(r, float):
-        return {'typespec':'real'}
+        return {'typespec': 'real'}
     if isinstance(r, complex):
-        return {'typespec':'complex'}
+        return {'typespec': 'complex'}
     if isinstance(r, dict):
         return r
     raise AssertionError(repr(r))
 
-def determineexprtype(expr,vars,rules={}):
+
+def determineexprtype(expr, vars, rules={}):
     if expr in vars:
         return _ensure_exprdict(vars[expr])
-    expr=expr.strip()
+    expr = expr.strip()
     if determineexprtype_re_1.match(expr):
-        return {'typespec':'complex'}
-    m=determineexprtype_re_2.match(expr)
+        return {'typespec': 'complex'}
+    m = determineexprtype_re_2.match(expr)
     if m:
         if 'name' in m.groupdict() and m.group('name'):
-            outmess('determineexprtype: selected kind types not supported (%s)\n'%repr(expr))
-        return {'typespec':'integer'}
+            outmess(
+                'determineexprtype: selected kind types not supported (%s)\n' % repr(expr))
+        return {'typespec': 'integer'}
     m = determineexprtype_re_3.match(expr)
     if m:
         if 'name' in m.groupdict() and m.group('name'):
-            outmess('determineexprtype: selected kind types not supported (%s)\n'%repr(expr))
-        return {'typespec':'real'}
+            outmess(
+                'determineexprtype: selected kind types not supported (%s)\n' % repr(expr))
+        return {'typespec': 'real'}
     for op in ['+', '-', '*', '/']:
-        for e in [x.strip() for x in markoutercomma(expr, comma=op).split('@'+op+'@')]:
+        for e in [x.strip() for x in markoutercomma(expr, comma=op).split('@' + op + '@')]:
             if e in vars:
                 return _ensure_exprdict(vars[e])
-    t={}
-    if determineexprtype_re_4.match(expr): # in parenthesis
-        t=determineexprtype(expr[1:-1], vars, rules)
+    t = {}
+    if determineexprtype_re_4.match(expr):  # in parenthesis
+        t = determineexprtype(expr[1:-1], vars, rules)
     else:
         m = determineexprtype_re_5.match(expr)
         if m:
-            rn=m.group('name')
-            t=determineexprtype(m.group('name'), vars, rules)
+            rn = m.group('name')
+            t = determineexprtype(m.group('name'), vars, rules)
             if t and 'attrspec' in t:
                 del t['attrspec']
             if not t:
                 if rn[0] in rules:
                     return _ensure_exprdict(rules[rn[0]])
     if expr[0] in '\'"':
-        return {'typespec':'character','charselector':{'*':'*'}}
+        return {'typespec': 'character', 'charselector': {'*': '*'}}
     if not t:
-        outmess('determineexprtype: could not determine expressions (%s) type.\n'%(repr(expr)))
+        outmess(
+            'determineexprtype: could not determine expressions (%s) type.\n' % (repr(expr)))
     return t
 
 ######
-def crack2fortrangen(block,tab='\n', as_interface=False):
+
+
+def crack2fortrangen(block, tab='\n', as_interface=False):
     global skipfuncs, onlyfuncs
 
     setmesstext(block)
-    ret=''
+    ret = ''
     if isinstance(block, list):
         for g in block:
             if g and g['block'] in ['function', 'subroutine']:
@@ -2584,94 +3001,105 @@ def crack2fortrangen(block,tab='\n', as_interface=False):
                     continue
                 if onlyfuncs and g['name'] not in onlyfuncs:
                     continue
-            ret=ret+crack2fortrangen(g, tab, as_interface=as_interface)
+            ret = ret + crack2fortrangen(g, tab, as_interface=as_interface)
         return ret
-    prefix=''
-    name=''
-    args=''
+    prefix = ''
+    name = ''
+    args = ''
     blocktype = block['block']
     if blocktype == 'program':
         return ''
     argsl = []
     if 'name' in block:
-        name=block['name']
+        name = block['name']
     if 'args' in block:
         vars = block['vars']
         for a in block['args']:
             a = expr2name(a, block, argsl)
             if not isintent_callback(vars[a]):
                 argsl.append(a)
-        if block['block']=='function' or argsl:
-            args='(%s)'%','.join(argsl)
+        if block['block'] == 'function' or argsl:
+            args = '(%s)' % ','.join(argsl)
     f2pyenhancements = ''
     if 'f2pyenhancements' in block:
         for k in list(block['f2pyenhancements'].keys()):
-            f2pyenhancements = '%s%s%s %s'%(f2pyenhancements, tab+tabchar, k, block['f2pyenhancements'][k])
+            f2pyenhancements = '%s%s%s %s' % (
+                f2pyenhancements, tab + tabchar, k, block['f2pyenhancements'][k])
     intent_lst = block.get('intent', [])[:]
     if blocktype == 'function' and 'callback' in intent_lst:
         intent_lst.remove('callback')
     if intent_lst:
-        f2pyenhancements = '%s%sintent(%s) %s'%\
-                           (f2pyenhancements, tab+tabchar,
+        f2pyenhancements = '%s%sintent(%s) %s' %\
+                           (f2pyenhancements, tab + tabchar,
                             ','.join(intent_lst), name)
-    use=''
+    use = ''
     if 'use' in block:
-        use=use2fortran(block['use'], tab+tabchar)
-    common=''
+        use = use2fortran(block['use'], tab + tabchar)
+    common = ''
     if 'common' in block:
-        common=common2fortran(block['common'], tab+tabchar)
-    if name=='unknown_interface': name=''
-    result=''
+        common = common2fortran(block['common'], tab + tabchar)
+    if name == 'unknown_interface':
+        name = ''
+    result = ''
     if 'result' in block:
-        result=' result (%s)'%block['result']
+        result = ' result (%s)' % block['result']
         if block['result'] not in argsl:
             argsl.append(block['result'])
-    #if 'prefix' in block:
+    # if 'prefix' in block:
     #    prefix=block['prefix']+' '
-    body=crack2fortrangen(block['body'], tab+tabchar)
-    vars=vars2fortran(block, block['vars'], argsl, tab+tabchar, as_interface=as_interface)
-    mess=''
+    body = crack2fortrangen(block['body'], tab + tabchar)
+    vars = vars2fortran(
+        block, block['vars'], argsl, tab + tabchar, as_interface=as_interface)
+    mess = ''
     if 'from' in block and not as_interface:
-        mess='! in %s'%block['from']
+        mess = '! in %s' % block['from']
     if 'entry' in block:
         entry_stmts = ''
         for k, i in list(block['entry'].items()):
             entry_stmts = '%s%sentry %s(%s)' \
-                          % (entry_stmts, tab+tabchar, k, ','.join(i))
+                          % (entry_stmts, tab + tabchar, k, ','.join(i))
         body = body + entry_stmts
     if blocktype == 'block data' and name == '_BLOCK_DATA_':
         name = ''
-    ret='%s%s%s %s%s%s %s%s%s%s%s%s%send %s %s'%(tab, prefix, blocktype, name, args, result, mess, f2pyenhancements, use, vars, common, body, tab, blocktype, name)
+    ret = '%s%s%s %s%s%s %s%s%s%s%s%s%send %s %s' % (
+        tab, prefix, blocktype, name, args, result, mess, f2pyenhancements, use, vars, common, body, tab, blocktype, name)
     return ret
 
-def common2fortran(common,tab=''):
-    ret=''
+
+def common2fortran(common, tab=''):
+    ret = ''
     for k in list(common.keys()):
-        if k=='_BLNK_':
-            ret='%s%scommon %s'%(ret, tab, ','.join(common[k]))
+        if k == '_BLNK_':
+            ret = '%s%scommon %s' % (ret, tab, ','.join(common[k]))
         else:
-            ret='%s%scommon /%s/ %s'%(ret, tab, k, ','.join(common[k]))
+            ret = '%s%scommon /%s/ %s' % (ret, tab, k, ','.join(common[k]))
     return ret
 
-def use2fortran(use,tab=''):
-    ret=''
+
+def use2fortran(use, tab=''):
+    ret = ''
     for m in list(use.keys()):
-        ret='%s%suse %s,'%(ret, tab, m)
-        if use[m]=={}:
-            if ret and ret[-1]==',': ret=ret[:-1]
+        ret = '%s%suse %s,' % (ret, tab, m)
+        if use[m] == {}:
+            if ret and ret[-1] == ',':
+                ret = ret[:-1]
             continue
         if 'only' in use[m] and use[m]['only']:
-            ret='%s only:'%(ret)
+            ret = '%s only:' % (ret)
         if 'map' in use[m] and use[m]['map']:
-            c=' '
+            c = ' '
             for k in list(use[m]['map'].keys()):
-                if k==use[m]['map'][k]:
-                    ret='%s%s%s'%(ret, c, k); c=','
+                if k == use[m]['map'][k]:
+                    ret = '%s%s%s' % (ret, c, k)
+                    c = ','
                 else:
-                    ret='%s%s%s=>%s'%(ret, c, k, use[m]['map'][k]); c=','
-        if ret and ret[-1]==',': ret=ret[:-1]
+                    ret = '%s%s%s=>%s' % (ret, c, k, use[m]['map'][k])
+                    c = ','
+        if ret and ret[-1] == ',':
+            ret = ret[:-1]
     return ret
 
+
 def true_intent_list(var):
     lst = var['intent']
     ret = []
@@ -2684,15 +3112,16 @@ def true_intent_list(var):
             ret.append(intent)
     return ret
 
-def vars2fortran(block,vars,args,tab='', as_interface=False):
+
+def vars2fortran(block, vars, args, tab='', as_interface=False):
     """
     TODO:
     public sub
     ...
     """
     setmesstext(block)
-    ret=''
-    nout=[]
+    ret = ''
+    nout = []
     for a in args:
         if a in block['vars']:
             nout.append(a)
@@ -2702,7 +3131,8 @@ def vars2fortran(block,vars,args,tab='', as_interface=False):
                 if a not in nout:
                     nout.append(a)
             else:
-                errmess('vars2fortran: Confused?!: "%s" is not defined in vars.\n'%a)
+                errmess(
+                    'vars2fortran: Confused?!: "%s" is not defined in vars.\n' % a)
     if 'varnames' in block:
         nout.extend(block['varnames'])
     if not as_interface:
@@ -2713,82 +3143,86 @@ def vars2fortran(block,vars,args,tab='', as_interface=False):
         if 'depend' in vars[a]:
             for d in vars[a]['depend']:
                 if d in vars and 'depend' in vars[d] and a in vars[d]['depend']:
-                    errmess('vars2fortran: Warning: cross-dependence between variables "%s" and "%s"\n'%(a, d))
+                    errmess(
+                        'vars2fortran: Warning: cross-dependence between variables "%s" and "%s"\n' % (a, d))
         if 'externals' in block and a in block['externals']:
             if isintent_callback(vars[a]):
-                ret='%s%sintent(callback) %s'%(ret, tab, a)
-            ret='%s%sexternal %s'%(ret, tab, a)
+                ret = '%s%sintent(callback) %s' % (ret, tab, a)
+            ret = '%s%sexternal %s' % (ret, tab, a)
             if isoptional(vars[a]):
-                ret='%s%soptional %s'%(ret, tab, a)
+                ret = '%s%soptional %s' % (ret, tab, a)
             if a in vars and 'typespec' not in vars[a]:
                 continue
-            cont=1
+            cont = 1
             for b in block['body']:
-                if a==b['name'] and b['block']=='function':
-                    cont=0;break
+                if a == b['name'] and b['block'] == 'function':
+                    cont = 0
+                    break
             if cont:
                 continue
         if a not in vars:
             show(vars)
-            outmess('vars2fortran: No definition for argument "%s".\n'%a)
+            outmess('vars2fortran: No definition for argument "%s".\n' % a)
             continue
-        if a==block['name'] and not block['block']=='function':
+        if a == block['name'] and not block['block'] == 'function':
             continue
         if 'typespec' not in vars[a]:
             if 'attrspec' in vars[a] and 'external' in vars[a]['attrspec']:
                 if a in args:
-                    ret='%s%sexternal %s'%(ret, tab, a)
+                    ret = '%s%sexternal %s' % (ret, tab, a)
                 continue
             show(vars[a])
-            outmess('vars2fortran: No typespec for argument "%s".\n'%a)
+            outmess('vars2fortran: No typespec for argument "%s".\n' % a)
             continue
-        vardef=vars[a]['typespec']
-        if vardef=='type' and 'typename' in vars[a]:
-            vardef='%s(%s)'%(vardef, vars[a]['typename'])
-        selector={}
+        vardef = vars[a]['typespec']
+        if vardef == 'type' and 'typename' in vars[a]:
+            vardef = '%s(%s)' % (vardef, vars[a]['typename'])
+        selector = {}
         if 'kindselector' in vars[a]:
-            selector=vars[a]['kindselector']
+            selector = vars[a]['kindselector']
         elif 'charselector' in vars[a]:
-            selector=vars[a]['charselector']
+            selector = vars[a]['charselector']
         if '*' in selector:
             if selector['*'] in ['*', ':']:
-                vardef='%s*(%s)'%(vardef, selector['*'])
+                vardef = '%s*(%s)' % (vardef, selector['*'])
             else:
-                vardef='%s*%s'%(vardef, selector['*'])
+                vardef = '%s*%s' % (vardef, selector['*'])
         else:
             if 'len' in selector:
-                vardef='%s(len=%s'%(vardef, selector['len'])
+                vardef = '%s(len=%s' % (vardef, selector['len'])
                 if 'kind' in selector:
-                    vardef='%s,kind=%s)'%(vardef, selector['kind'])
+                    vardef = '%s,kind=%s)' % (vardef, selector['kind'])
                 else:
-                    vardef='%s)'%(vardef)
+                    vardef = '%s)' % (vardef)
             elif 'kind' in selector:
-                vardef='%s(kind=%s)'%(vardef, selector['kind'])
-        c=' '
+                vardef = '%s(kind=%s)' % (vardef, selector['kind'])
+        c = ' '
         if 'attrspec' in vars[a]:
-            attr=[]
+            attr = []
             for l in vars[a]['attrspec']:
                 if l not in ['external']:
                     attr.append(l)
             if attr:
-                vardef='%s, %s'%(vardef, ','.join(attr))
-                c=','
+                vardef = '%s, %s' % (vardef, ','.join(attr))
+                c = ','
         if 'dimension' in vars[a]:
-#             if not isintent_c(vars[a]):
-#                 vars[a]['dimension'].reverse()
-            vardef='%s%sdimension(%s)'%(vardef, c, ','.join(vars[a]['dimension']))
-            c=','
+            # if not isintent_c(vars[a]):
+            #    vars[a]['dimension'].reverse()
+            vardef = '%s%sdimension(%s)' % (
+                vardef, c, ','.join(vars[a]['dimension']))
+            c = ','
         if 'intent' in vars[a]:
             lst = true_intent_list(vars[a])
             if lst:
-                vardef='%s%sintent(%s)'%(vardef, c, ','.join(lst))
-            c=','
+                vardef = '%s%sintent(%s)' % (vardef, c, ','.join(lst))
+            c = ','
         if 'check' in vars[a]:
-            vardef='%s%scheck(%s)'%(vardef, c, ','.join(vars[a]['check']))
-            c=','
+            vardef = '%s%scheck(%s)' % (vardef, c, ','.join(vars[a]['check']))
+            c = ','
         if 'depend' in vars[a]:
-            vardef='%s%sdepend(%s)'%(vardef, c, ','.join(vars[a]['depend']))
-            c=','
+            vardef = '%s%sdepend(%s)' % (
+                vardef, c, ','.join(vars[a]['depend']))
+            c = ','
         if '=' in vars[a]:
             v = vars[a]['=']
             if vars[a]['typespec'] in ['complex', 'double complex']:
@@ -2797,89 +3231,95 @@ def vars2fortran(block,vars,args,tab='', as_interface=False):
                     v = '(%s,%s)' % (v.real, v.imag)
                 except:
                     pass
-            vardef='%s :: %s=%s'%(vardef, a, v)
+            vardef = '%s :: %s=%s' % (vardef, a, v)
         else:
-            vardef='%s :: %s'%(vardef, a)
-        ret='%s%s%s'%(ret, tab, vardef)
+            vardef = '%s :: %s' % (vardef, a)
+        ret = '%s%s%s' % (ret, tab, vardef)
     return ret
 ######
 
+
 def crackfortran(files):
     global usermodules
 
     outmess('Reading fortran codes...\n', 0)
     readfortrancode(files, crackline)
     outmess('Post-processing...\n', 0)
-    usermodules=[]
-    postlist=postcrack(grouplist[0])
+    usermodules = []
+    postlist = postcrack(grouplist[0])
     outmess('Post-processing (stage 2)...\n', 0)
-    postlist=postcrack2(postlist)
-    return usermodules+postlist
+    postlist = postcrack2(postlist)
+    return usermodules + postlist
+
 
 def crack2fortran(block):
     global f2py_version
 
-    pyf=crack2fortrangen(block)+'\n'
-    header="""!    -*- f90 -*-
+    pyf = crack2fortrangen(block) + '\n'
+    header = """!    -*- f90 -*-
 ! Note: the context of this file is case sensitive.
 """
-    footer="""
+    footer = """
 ! This file was auto-generated with f2py (version:%s).
 ! See http://cens.ioc.ee/projects/f2py2e/
-"""%(f2py_version)
-    return header+pyf+footer
+""" % (f2py_version)
+    return header + pyf + footer
 
 if __name__ == "__main__":
-    files=[]
-    funcs=[]
-    f=1;f2=0;f3=0
-    showblocklist=0
+    files = []
+    funcs = []
+    f = 1
+    f2 = 0
+    f3 = 0
+    showblocklist = 0
     for l in sys.argv[1:]:
-        if l=='': pass
-        elif l[0]==':':
-            f=0
-        elif l=='-quiet':
-            quiet=1
-            verbose=0
-        elif l=='-verbose':
-            verbose=2
-            quiet=0
-        elif l=='-fix':
+        if l == '':
+            pass
+        elif l[0] == ':':
+            f = 0
+        elif l == '-quiet':
+            quiet = 1
+            verbose = 0
+        elif l == '-verbose':
+            verbose = 2
+            quiet = 0
+        elif l == '-fix':
             if strictf77:
-                outmess('Use option -f90 before -fix if Fortran 90 code is in fix form.\n', 0)
-            skipemptyends=1
-            sourcecodeform='fix'
-        elif l=='-skipemptyends':
-            skipemptyends=1
-        elif l=='--ignore-contains':
-            ignorecontains=1
-        elif l=='-f77':
-            strictf77=1
-            sourcecodeform='fix'
-        elif l=='-f90':
-            strictf77=0
-            sourcecodeform='free'
-            skipemptyends=1
-        elif l=='-h':
-            f2=1
-        elif l=='-show':
-            showblocklist=1
-        elif l=='-m':
-            f3=1
-        elif l[0]=='-':
-            errmess('Unknown option %s\n'%repr(l))
+                outmess(
+                    'Use option -f90 before -fix if Fortran 90 code is in fix form.\n', 0)
+            skipemptyends = 1
+            sourcecodeform = 'fix'
+        elif l == '-skipemptyends':
+            skipemptyends = 1
+        elif l == '--ignore-contains':
+            ignorecontains = 1
+        elif l == '-f77':
+            strictf77 = 1
+            sourcecodeform = 'fix'
+        elif l == '-f90':
+            strictf77 = 0
+            sourcecodeform = 'free'
+            skipemptyends = 1
+        elif l == '-h':
+            f2 = 1
+        elif l == '-show':
+            showblocklist = 1
+        elif l == '-m':
+            f3 = 1
+        elif l[0] == '-':
+            errmess('Unknown option %s\n' % repr(l))
         elif f2:
-            f2=0
-            pyffilename=l
+            f2 = 0
+            pyffilename = l
         elif f3:
-            f3=0
-            f77modulename=l
+            f3 = 0
+            f77modulename = l
         elif f:
             try:
                 open(l).close()
                 files.append(l)
             except IOError as detail:
-                errmess('IOError: %s\n'%str(detail))
+                errmess('IOError: %s\n' % str(detail))
         else:
             funcs.append(l)
     if not strictf77 and f77modulename and not skipemptyends:
@@ -2890,11 +3330,11 @@ if __name__ == "__main__":
   and also be sure that the files do not contain programs without program statement).
 """, 0)
 
-    postlist=crackfortran(files, funcs)
+    postlist = crackfortran(files, funcs)
     if pyffilename:
-        outmess('Writing fortran code to file %s\n'%repr(pyffilename), 0)
-        pyf=crack2fortran(postlist)
-        f=open(pyffilename, 'w')
+        outmess('Writing fortran code to file %s\n' % repr(pyffilename), 0)
+        pyf = crack2fortran(postlist)
+        f = open(pyffilename, 'w')
         f.write(pyf)
         f.close()
     if showblocklist:
diff --git a/numpy/f2py/diagnose.py b/numpy/f2py/diagnose.py
index 683a8c7e3..0241fed12 100644
--- a/numpy/f2py/diagnose.py
+++ b/numpy/f2py/diagnose.py
@@ -5,11 +5,13 @@ import os
 import sys
 import tempfile
 
+
 def run_command(cmd):
     print('Running %r:' % (cmd))
     os.system(cmd)
     print('------')
 
+
 def run():
     _path = os.getcwd()
     os.chdir(tempfile.gettempdir())
@@ -54,7 +56,7 @@ def run():
 
     if has_newnumpy:
         try:
-            print('Found new numpy version %r in %s' % \
+            print('Found new numpy version %r in %s' %
                   (numpy.__version__, numpy.__file__))
         except Exception as msg:
             print('error:', msg)
@@ -62,7 +64,7 @@ def run():
 
     if has_f2py2e:
         try:
-            print('Found f2py2e version %r in %s' % \
+            print('Found f2py2e version %r in %s' %
                   (f2py2e.__version__.version, f2py2e.__file__))
         except Exception as msg:
             print('error:', msg)
@@ -71,25 +73,27 @@ def run():
     if has_numpy_distutils:
         try:
             if has_numpy_distutils == 2:
-                print('Found numpy.distutils version %r in %r' % (\
-            numpy.distutils.__version__,
-            numpy.distutils.__file__))
+                print('Found numpy.distutils version %r in %r' % (
+                    numpy.distutils.__version__,
+                    numpy.distutils.__file__))
             else:
-                print('Found numpy_distutils version %r in %r' % (\
-            numpy_distutils.numpy_distutils_version.numpy_distutils_version,
-            numpy_distutils.__file__))
+                print('Found numpy_distutils version %r in %r' % (
+                    numpy_distutils.numpy_distutils_version.numpy_distutils_version,
+                    numpy_distutils.__file__))
             print('------')
         except Exception as msg:
             print('error:', msg)
             print('------')
         try:
             if has_numpy_distutils == 1:
-                print('Importing numpy_distutils.command.build_flib ...', end=' ')
+                print(
+                    'Importing numpy_distutils.command.build_flib ...', end=' ')
                 import numpy_distutils.command.build_flib as build_flib
                 print('ok')
                 print('------')
                 try:
-                    print('Checking availability of supported Fortran compilers:')
+                    print(
+                        'Checking availability of supported Fortran compilers:')
                     for compiler_class in build_flib.all_compilers:
                         compiler_class(verbose=1).is_available()
                         print('------')
@@ -97,7 +101,8 @@ def run():
                     print('error:', msg)
                     print('------')
         except Exception as msg:
-            print('error:', msg, '(ignore it, build_flib is obsolute for numpy.distutils 0.2.2 and up)')
+            print(
+                'error:', msg, '(ignore it, build_flib is obsolute for numpy.distutils 0.2.2 and up)')
             print('------')
         try:
             if has_numpy_distutils == 2:
@@ -126,7 +131,8 @@ def run():
                 print('------')
             else:
                 try:
-                    print('Importing numpy_distutils.command.cpuinfo ...', end=' ')
+                    print(
+                        'Importing numpy_distutils.command.cpuinfo ...', end=' ')
                     from numpy_distutils.command.cpuinfo import cpuinfo
                     print('ok')
                     print('------')
@@ -139,7 +145,7 @@ def run():
             cpu = cpuinfo()
             print('CPU information:', end=' ')
             for name in dir(cpuinfo):
-                if name[0]=='_' and name[1]!='_' and getattr(cpu, name[1:])():
+                if name[0] == '_' and name[1] != '_' and getattr(cpu, name[1:])():
                     print(name[1:], end=' ')
             print('------')
         except Exception as msg:
diff --git a/numpy/f2py/f2py_testing.py b/numpy/f2py/f2py_testing.py
index 4cec4baad..13724d942 100644
--- a/numpy/f2py/f2py_testing.py
+++ b/numpy/f2py/f2py_testing.py
@@ -5,8 +5,9 @@ import re
 
 from numpy.testing.utils import jiffies, memusage
 
+
 def cmdline():
-    m=re.compile(r'\A\d+\Z')
+    m = re.compile(r'\A\d+\Z')
     args = []
     repeat = 1
     for a in sys.argv[1:]:
@@ -17,30 +18,32 @@ def cmdline():
     f2py_opts = ' '.join(args)
     return repeat, f2py_opts
 
-def run(runtest,test_functions,repeat=1):
+
+def run(runtest, test_functions, repeat=1):
     l = [(t, repr(t.__doc__.split('\n')[1].strip())) for t in test_functions]
     #l = [(t,'') for t in test_functions]
     start_memusage = memusage()
     diff_memusage = None
     start_jiffies = jiffies()
     i = 0
-    while i<repeat:
+    while i < repeat:
         i += 1
         for t, fname in l:
             runtest(t)
-            if start_memusage is None: continue
+            if start_memusage is None:
+                continue
             if diff_memusage is None:
                 diff_memusage = memusage() - start_memusage
             else:
                 diff_memusage2 = memusage() - start_memusage
-                if diff_memusage2!=diff_memusage:
-                    print('memory usage change at step %i:' % i,\
-                          diff_memusage2-diff_memusage,\
+                if diff_memusage2 != diff_memusage:
+                    print('memory usage change at step %i:' % i,
+                          diff_memusage2 - diff_memusage,
                           fname)
                     diff_memusage = diff_memusage2
     current_memusage = memusage()
-    print('run', repeat*len(test_functions), 'tests',\
-          'in %.2f seconds' % ((jiffies()-start_jiffies)/100.0))
+    print('run', repeat * len(test_functions), 'tests',
+          'in %.2f seconds' % ((jiffies() - start_jiffies) / 100.0))
     if start_memusage:
         print('initial virtual memory size:', start_memusage, 'bytes')
         print('current virtual memory size:', current_memusage, 'bytes')
diff --git a/numpy/f2py/f90mod_rules.py b/numpy/f2py/f90mod_rules.py
index 21e1bd4a9..ce7e61750 100644
--- a/numpy/f2py/f90mod_rules.py
+++ b/numpy/f2py/f90mod_rules.py
@@ -17,28 +17,33 @@ from __future__ import division, absolute_import, print_function
 
 __version__ = "$Revision: 1.27 $"[10:-1]
 
-f2py_version='See `f2py -v`'
+f2py_version = 'See `f2py -v`'
 
 import numpy as np
 
 from .auxfuncs import (
-    applyrules, dictappend, hasbody,hasnote, isallocatable, isfunction,
-    isintent_hide, ismodule, isprivate, isroutine,isstringarray, l_or,
+    applyrules, dictappend, hasbody, hasnote, isallocatable, isfunction,
+    isintent_hide, ismodule, isprivate, isroutine, isstringarray, l_or,
     outmess
 )
 from . import capi_maps
 from . import func2subr
 from .crackfortran import undo_rmbadname, undo_rmbadname1
 
-options={}
+options = {}
+
 
 def findf90modules(m):
-    if ismodule(m): return [m]
-    if not hasbody(m): return []
+    if ismodule(m):
+        return [m]
+    if not hasbody(m):
+        return []
     ret = []
     for b in m['body']:
-        if ismodule(b): ret.append(b)
-        else: ret=ret+findf90modules(b)
+        if ismodule(b):
+            ret.append(b)
+        else:
+            ret = ret + findf90modules(b)
     return ret
 
 fgetdims1 = """\
@@ -59,7 +64,7 @@ fgetdims1 = """\
       end if
       if ((.not.allocated(d)).and.(s(1).ge.1)) then""" % np.intp().itemsize
 
-fgetdims2="""\
+fgetdims2 = """\
       end if
       if (allocated(d)) then
          do i=1,r
@@ -69,7 +74,7 @@ fgetdims2="""\
       flag = 1
       call f2pysetdata(d,allocated(d))"""
 
-fgetdims2_sa="""\
+fgetdims2_sa = """\
       end if
       if (allocated(d)) then
          do i=1,r
@@ -84,41 +89,53 @@ fgetdims2_sa="""\
 def buildhooks(pymod):
     global fgetdims1, fgetdims2
     from . import rules
-    ret = {'f90modhooks':[],'initf90modhooks':[],'body':[],
-           'need':['F_FUNC', 'arrayobject.h'],
-           'separatorsfor':{'includes0':'\n','includes':'\n'},
-           'docs':['"Fortran 90/95 modules:\\n"'],
-           'latexdoc':[]}
-    fhooks=['']
-    def fadd(line,s=fhooks): s[0] = '%s\n      %s'%(s[0], line)
+    ret = {'f90modhooks': [], 'initf90modhooks': [], 'body': [],
+           'need': ['F_FUNC', 'arrayobject.h'],
+           'separatorsfor': {'includes0': '\n', 'includes': '\n'},
+           'docs': ['"Fortran 90/95 modules:\\n"'],
+           'latexdoc': []}
+    fhooks = ['']
+
+    def fadd(line, s=fhooks):
+        s[0] = '%s\n      %s' % (s[0], line)
     doc = ['']
-    def dadd(line,s=doc): s[0] = '%s\n%s'%(s[0], line)
+
+    def dadd(line, s=doc):
+        s[0] = '%s\n%s' % (s[0], line)
     for m in findf90modules(pymod):
-        sargs, fargs, efargs, modobjs, notvars, onlyvars=[], [], [], [], [m['name']], []
+        sargs, fargs, efargs, modobjs, notvars, onlyvars = [], [], [], [], [
+            m['name']], []
         sargsp = []
         ifargs = []
         mfargs = []
         if hasbody(m):
-            for b in m['body']: notvars.append(b['name'])
+            for b in m['body']:
+                notvars.append(b['name'])
         for n in m['vars'].keys():
             var = m['vars'][n]
             if (n not in notvars) and (not l_or(isintent_hide, isprivate)(var)):
                 onlyvars.append(n)
                 mfargs.append(n)
-        outmess('\t\tConstructing F90 module support for "%s"...\n'%(m['name']))
+        outmess('\t\tConstructing F90 module support for "%s"...\n' %
+                (m['name']))
         if onlyvars:
-            outmess('\t\t  Variables: %s\n'%(' '.join(onlyvars)))
-        chooks=['']
-        def cadd(line,s=chooks): s[0] = '%s\n%s'%(s[0], line)
-        ihooks=['']
-        def iadd(line,s=ihooks): s[0] = '%s\n%s'%(s[0], line)
-
-        vrd=capi_maps.modsign2map(m)
-        cadd('static FortranDataDef f2py_%s_def[] = {'%(m['name']))
-        dadd('\\subsection{Fortran 90/95 module \\texttt{%s}}\n'%(m['name']))
+            outmess('\t\t  Variables: %s\n' % (' '.join(onlyvars)))
+        chooks = ['']
+
+        def cadd(line, s=chooks):
+            s[0] = '%s\n%s' % (s[0], line)
+        ihooks = ['']
+
+        def iadd(line, s=ihooks):
+            s[0] = '%s\n%s' % (s[0], line)
+
+        vrd = capi_maps.modsign2map(m)
+        cadd('static FortranDataDef f2py_%s_def[] = {' % (m['name']))
+        dadd('\\subsection{Fortran 90/95 module \\texttt{%s}}\n' % (m['name']))
         if hasnote(m):
             note = m['note']
-            if isinstance(note, list): note='\n'.join(note)
+            if isinstance(note, list):
+                note = '\n'.join(note)
             dadd(note)
         if onlyvars:
             dadd('\\begin{description}')
@@ -130,41 +147,49 @@ def buildhooks(pymod):
             dm = capi_maps.getarrdims(n, var)
             dms = dm['dims'].replace('*', '-1').strip()
             dms = dms.replace(':', '-1').strip()
-            if not dms: dms='-1'
+            if not dms:
+                dms = '-1'
             use_fgetdims2 = fgetdims2
             if isstringarray(var):
                 if 'charselector' in var and 'len' in var['charselector']:
-                    cadd('\t{"%s",%s,{{%s,%s}},%s},'\
-                         %(undo_rmbadname1(n), dm['rank'], dms, var['charselector']['len'], at))
+                    cadd('\t{"%s",%s,{{%s,%s}},%s},'
+                         % (undo_rmbadname1(n), dm['rank'], dms, var['charselector']['len'], at))
                     use_fgetdims2 = fgetdims2_sa
                 else:
-                    cadd('\t{"%s",%s,{{%s}},%s},'%(undo_rmbadname1(n), dm['rank'], dms, at))
+                    cadd('\t{"%s",%s,{{%s}},%s},' %
+                         (undo_rmbadname1(n), dm['rank'], dms, at))
             else:
-                cadd('\t{"%s",%s,{{%s}},%s},'%(undo_rmbadname1(n), dm['rank'], dms, at))
-            dadd('\\item[]{{}\\verb@%s@{}}'%(capi_maps.getarrdocsign(n, var)))
+                cadd('\t{"%s",%s,{{%s}},%s},' %
+                     (undo_rmbadname1(n), dm['rank'], dms, at))
+            dadd('\\item[]{{}\\verb@%s@{}}' %
+                 (capi_maps.getarrdocsign(n, var)))
             if hasnote(var):
                 note = var['note']
-                if isinstance(note, list): note='\n'.join(note)
-                dadd('--- %s'%(note))
+                if isinstance(note, list):
+                    note = '\n'.join(note)
+                dadd('--- %s' % (note))
             if isallocatable(var):
-                fargs.append('f2py_%s_getdims_%s'%(m['name'], n))
+                fargs.append('f2py_%s_getdims_%s' % (m['name'], n))
                 efargs.append(fargs[-1])
-                sargs.append('void (*%s)(int*,int*,void(*)(char*,int*),int*)'%(n))
+                sargs.append(
+                    'void (*%s)(int*,int*,void(*)(char*,int*),int*)' % (n))
                 sargsp.append('void (*)(int*,int*,void(*)(char*,int*),int*)')
-                iadd('\tf2py_%s_def[i_f2py++].func = %s;'%(m['name'], n))
-                fadd('subroutine %s(r,s,f2pysetdata,flag)'%(fargs[-1]))
-                fadd('use %s, only: d => %s\n'%(m['name'], undo_rmbadname1(n)))
+                iadd('\tf2py_%s_def[i_f2py++].func = %s;' % (m['name'], n))
+                fadd('subroutine %s(r,s,f2pysetdata,flag)' % (fargs[-1]))
+                fadd('use %s, only: d => %s\n' %
+                     (m['name'], undo_rmbadname1(n)))
                 fadd('integer flag\n')
-                fhooks[0]=fhooks[0]+fgetdims1
-                dms = eval('range(1,%s+1)'%(dm['rank']))
-                fadd(' allocate(d(%s))\n'%(','.join(['s(%s)'%i for i in dms])))
-                fhooks[0]=fhooks[0]+use_fgetdims2
-                fadd('end subroutine %s'%(fargs[-1]))
+                fhooks[0] = fhooks[0] + fgetdims1
+                dms = eval('range(1,%s+1)' % (dm['rank']))
+                fadd(' allocate(d(%s))\n' %
+                     (','.join(['s(%s)' % i for i in dms])))
+                fhooks[0] = fhooks[0] + use_fgetdims2
+                fadd('end subroutine %s' % (fargs[-1]))
             else:
                 fargs.append(n)
-                sargs.append('char *%s'%(n))
+                sargs.append('char *%s' % (n))
                 sargsp.append('char*')
-                iadd('\tf2py_%s_def[i_f2py++].data = %s;'%(m['name'], n))
+                iadd('\tf2py_%s_def[i_f2py++].data = %s;' % (m['name'], n))
         if onlyvars:
             dadd('\\end{description}')
         if hasbody(m):
@@ -172,74 +197,81 @@ def buildhooks(pymod):
                 if not isroutine(b):
                     print('Skipping', b['block'], b['name'])
                     continue
-                modobjs.append('%s()'%(b['name']))
+                modobjs.append('%s()' % (b['name']))
                 b['modulename'] = m['name']
-                api, wrap=rules.buildapi(b)
+                api, wrap = rules.buildapi(b)
                 if isfunction(b):
-                    fhooks[0]=fhooks[0]+wrap
-                    fargs.append('f2pywrap_%s_%s'%(m['name'], b['name']))
-                    #efargs.append(fargs[-1])
+                    fhooks[0] = fhooks[0] + wrap
+                    fargs.append('f2pywrap_%s_%s' % (m['name'], b['name']))
+                    # efargs.append(fargs[-1])
                     ifargs.append(func2subr.createfuncwrapper(b, signature=1))
                 else:
                     if wrap:
-                        fhooks[0]=fhooks[0]+wrap
-                        fargs.append('f2pywrap_%s_%s'%(m['name'], b['name']))
-                        ifargs.append(func2subr.createsubrwrapper(b, signature=1))
+                        fhooks[0] = fhooks[0] + wrap
+                        fargs.append('f2pywrap_%s_%s' % (m['name'], b['name']))
+                        ifargs.append(
+                            func2subr.createsubrwrapper(b, signature=1))
                     else:
                         fargs.append(b['name'])
                         mfargs.append(fargs[-1])
-                    #if '--external-modroutines' in options and options['--external-modroutines']:
+                    # if '--external-modroutines' in options and options['--external-modroutines']:
                     #    outmess('\t\t\tapplying --external-modroutines for %s\n'%(b['name']))
                     #     efargs.append(fargs[-1])
-                api['externroutines']=[]
-                ar=applyrules(api, vrd)
-                ar['docs']=[]
-                ar['docshort']=[]
-                ret=dictappend(ret, ar)
-                cadd('\t{"%s",-1,{{-1}},0,NULL,(void *)f2py_rout_#modulename#_%s_%s,doc_f2py_rout_#modulename#_%s_%s},'%(b['name'], m['name'], b['name'], m['name'], b['name']))
-                sargs.append('char *%s'%(b['name']))
+                api['externroutines'] = []
+                ar = applyrules(api, vrd)
+                ar['docs'] = []
+                ar['docshort'] = []
+                ret = dictappend(ret, ar)
+                cadd('\t{"%s",-1,{{-1}},0,NULL,(void *)f2py_rout_#modulename#_%s_%s,doc_f2py_rout_#modulename#_%s_%s},' %
+                     (b['name'], m['name'], b['name'], m['name'], b['name']))
+                sargs.append('char *%s' % (b['name']))
                 sargsp.append('char *')
-                iadd('\tf2py_%s_def[i_f2py++].data = %s;'%(m['name'], b['name']))
+                iadd('\tf2py_%s_def[i_f2py++].data = %s;' %
+                     (m['name'], b['name']))
         cadd('\t{NULL}\n};\n')
         iadd('}')
-        ihooks[0]='static void f2py_setup_%s(%s) {\n\tint i_f2py=0;%s'%(m['name'], ','.join(sargs), ihooks[0])
+        ihooks[0] = 'static void f2py_setup_%s(%s) {\n\tint i_f2py=0;%s' % (
+            m['name'], ','.join(sargs), ihooks[0])
         if '_' in m['name']:
-            F_FUNC='F_FUNC_US'
+            F_FUNC = 'F_FUNC_US'
         else:
-            F_FUNC='F_FUNC'
-        iadd('extern void %s(f2pyinit%s,F2PYINIT%s)(void (*)(%s));'\
-             %(F_FUNC, m['name'], m['name'].upper(), ','.join(sargsp)))
-        iadd('static void f2py_init_%s(void) {'%(m['name']))
-        iadd('\t%s(f2pyinit%s,F2PYINIT%s)(f2py_setup_%s);'\
-             %(F_FUNC, m['name'], m['name'].upper(), m['name']))
+            F_FUNC = 'F_FUNC'
+        iadd('extern void %s(f2pyinit%s,F2PYINIT%s)(void (*)(%s));'
+             % (F_FUNC, m['name'], m['name'].upper(), ','.join(sargsp)))
+        iadd('static void f2py_init_%s(void) {' % (m['name']))
+        iadd('\t%s(f2pyinit%s,F2PYINIT%s)(f2py_setup_%s);'
+             % (F_FUNC, m['name'], m['name'].upper(), m['name']))
         iadd('}\n')
-        ret['f90modhooks']=ret['f90modhooks']+chooks+ihooks
-        ret['initf90modhooks']=['\tPyDict_SetItemString(d, "%s", PyFortranObject_New(f2py_%s_def,f2py_init_%s));'%(m['name'], m['name'], m['name'])]+ret['initf90modhooks']
+        ret['f90modhooks'] = ret['f90modhooks'] + chooks + ihooks
+        ret['initf90modhooks'] = ['\tPyDict_SetItemString(d, "%s", PyFortranObject_New(f2py_%s_def,f2py_init_%s));' % (
+            m['name'], m['name'], m['name'])] + ret['initf90modhooks']
         fadd('')
-        fadd('subroutine f2pyinit%s(f2pysetupfunc)'%(m['name']))
+        fadd('subroutine f2pyinit%s(f2pysetupfunc)' % (m['name']))
         #fadd('use %s'%(m['name']))
         if mfargs:
             for a in undo_rmbadname(mfargs):
-                fadd('use %s, only : %s'%(m['name'], a))
+                fadd('use %s, only : %s' % (m['name'], a))
         if ifargs:
-            fadd(' '.join(['interface']+ifargs))
+            fadd(' '.join(['interface'] + ifargs))
             fadd('end interface')
         fadd('external f2pysetupfunc')
         if efargs:
             for a in undo_rmbadname(efargs):
-                fadd('external %s'%(a))
-        fadd('call f2pysetupfunc(%s)'%(','.join(undo_rmbadname(fargs))))
-        fadd('end subroutine f2pyinit%s\n'%(m['name']))
+                fadd('external %s' % (a))
+        fadd('call f2pysetupfunc(%s)' % (','.join(undo_rmbadname(fargs))))
+        fadd('end subroutine f2pyinit%s\n' % (m['name']))
 
-        dadd('\n'.join(ret['latexdoc']).replace(r'\subsection{', r'\subsubsection{'))
+        dadd('\n'.join(ret['latexdoc']).replace(
+            r'\subsection{', r'\subsubsection{'))
 
-        ret['latexdoc']=[]
-        ret['docs'].append('"\t%s --- %s"'%(m['name'],
-                                            ','.join(undo_rmbadname(modobjs))))
+        ret['latexdoc'] = []
+        ret['docs'].append('"\t%s --- %s"' % (m['name'],
+                                              ','.join(undo_rmbadname(modobjs))))
 
-    ret['routine_defs']=''
-    ret['doc']=[]
-    ret['docshort']=[]
-    ret['latexdoc']=doc[0]
-    if len(ret['docs'])<=1: ret['docs']=''
+    ret['routine_defs'] = ''
+    ret['doc'] = []
+    ret['docshort'] = []
+    ret['latexdoc'] = doc[0]
+    if len(ret['docs']) <= 1:
+        ret['docs'] = ''
     return ret, fhooks[0]
diff --git a/numpy/f2py/func2subr.py b/numpy/f2py/func2subr.py
index 39410feef..723d6508e 100644
--- a/numpy/f2py/func2subr.py
+++ b/numpy/f2py/func2subr.py
@@ -23,60 +23,61 @@ import copy
 
 from .auxfuncs import (
     getfortranname, isexternal, isfunction, isfunction_wrap, isintent_in,
-    isintent_out, islogicalfunction,ismoduleroutine, isscalar,
+    isintent_out, islogicalfunction, ismoduleroutine, isscalar,
     issubroutine, issubroutine_wrap, outmess, show
 )
 
 
-def var2fixfortran(vars,a,fa=None,f90mode=None):
+def var2fixfortran(vars, a, fa=None, f90mode=None):
     if fa is None:
         fa = a
     if a not in vars:
         show(vars)
-        outmess('var2fixfortran: No definition for argument "%s".\n'%a)
+        outmess('var2fixfortran: No definition for argument "%s".\n' % a)
         return ''
     if 'typespec' not in vars[a]:
         show(vars[a])
-        outmess('var2fixfortran: No typespec for argument "%s".\n'%a)
+        outmess('var2fixfortran: No typespec for argument "%s".\n' % a)
         return ''
-    vardef=vars[a]['typespec']
-    if vardef=='type' and 'typename' in vars[a]:
-        vardef='%s(%s)'%(vardef, vars[a]['typename'])
-    selector={}
+    vardef = vars[a]['typespec']
+    if vardef == 'type' and 'typename' in vars[a]:
+        vardef = '%s(%s)' % (vardef, vars[a]['typename'])
+    selector = {}
     lk = ''
     if 'kindselector' in vars[a]:
-        selector=vars[a]['kindselector']
+        selector = vars[a]['kindselector']
         lk = 'kind'
     elif 'charselector' in vars[a]:
-        selector=vars[a]['charselector']
+        selector = vars[a]['charselector']
         lk = 'len'
     if '*' in selector:
         if f90mode:
             if selector['*'] in ['*', ':', '(*)']:
-                vardef='%s(len=*)'%(vardef)
+                vardef = '%s(len=*)' % (vardef)
             else:
-                vardef='%s(%s=%s)'%(vardef, lk, selector['*'])
+                vardef = '%s(%s=%s)' % (vardef, lk, selector['*'])
         else:
             if selector['*'] in ['*', ':']:
-                vardef='%s*(%s)'%(vardef, selector['*'])
+                vardef = '%s*(%s)' % (vardef, selector['*'])
             else:
-                vardef='%s*%s'%(vardef, selector['*'])
+                vardef = '%s*%s' % (vardef, selector['*'])
     else:
         if 'len' in selector:
-            vardef='%s(len=%s'%(vardef, selector['len'])
+            vardef = '%s(len=%s' % (vardef, selector['len'])
             if 'kind' in selector:
-                vardef='%s,kind=%s)'%(vardef, selector['kind'])
+                vardef = '%s,kind=%s)' % (vardef, selector['kind'])
             else:
-                vardef='%s)'%(vardef)
+                vardef = '%s)' % (vardef)
         elif 'kind' in selector:
-            vardef='%s(kind=%s)'%(vardef, selector['kind'])
+            vardef = '%s(kind=%s)' % (vardef, selector['kind'])
 
-    vardef='%s %s'%(vardef, fa)
+    vardef = '%s %s' % (vardef, fa)
     if 'dimension' in vars[a]:
-        vardef='%s(%s)'%(vardef, ','.join(vars[a]['dimension']))
+        vardef = '%s(%s)' % (vardef, ','.join(vars[a]['dimension']))
     return vardef
 
-def createfuncwrapper(rout,signature=0):
+
+def createfuncwrapper(rout, signature=0):
     assert isfunction(rout)
 
     extra_args = []
@@ -84,7 +85,7 @@ def createfuncwrapper(rout,signature=0):
     for a in rout['args']:
         v = rout['vars'][a]
         for i, d in enumerate(v.get('dimension', [])):
-            if d==':':
+            if d == ':':
                 dn = 'f2py_%s_d%s' % (a, i)
                 dv = dict(typespec='integer', intent=['hide'])
                 dv['='] = 'shape(%s, %s)' % (a, i)
@@ -95,36 +96,40 @@ def createfuncwrapper(rout,signature=0):
     need_interface = bool(extra_args)
 
     ret = ['']
-    def add(line,ret=ret):
-        ret[0] = '%s\n      %s'%(ret[0], line)
+
+    def add(line, ret=ret):
+        ret[0] = '%s\n      %s' % (ret[0], line)
     name = rout['name']
     fortranname = getfortranname(rout)
     f90mode = ismoduleroutine(rout)
-    newname = '%sf2pywrap'%(name)
+    newname = '%sf2pywrap' % (name)
 
     if newname not in vars:
         vars[newname] = vars[name]
-        args = [newname]+rout['args'][1:]
+        args = [newname] + rout['args'][1:]
     else:
-        args = [newname]+rout['args']
+        args = [newname] + rout['args']
 
     l = var2fixfortran(vars, name, newname, f90mode)
-    if l[:13]=='character*(*)':
-        if f90mode: l = 'character(len=10)'+l[13:]
-        else: l = 'character*10'+l[13:]
+    if l[:13] == 'character*(*)':
+        if f90mode:
+            l = 'character(len=10)' + l[13:]
+        else:
+            l = 'character*10' + l[13:]
         charselect = vars[name]['charselector']
-        if charselect.get('*', '')=='(*)':
+        if charselect.get('*', '') == '(*)':
             charselect['*'] = '10'
     sargs = ', '.join(args)
     if f90mode:
-        add('subroutine f2pywrap_%s_%s (%s)'%(rout['modulename'], name, sargs))
+        add('subroutine f2pywrap_%s_%s (%s)' %
+            (rout['modulename'], name, sargs))
         if not signature:
-            add('use %s, only : %s'%(rout['modulename'], fortranname))
+            add('use %s, only : %s' % (rout['modulename'], fortranname))
     else:
-        add('subroutine f2pywrap%s (%s)'%(name, sargs))
+        add('subroutine f2pywrap%s (%s)' % (name, sargs))
         if not need_interface:
-            add('external %s'%(fortranname))
-            l = l + ', '+fortranname
+            add('external %s' % (fortranname))
+            l = l + ', ' + fortranname
     if need_interface:
         for line in rout['saved_interface'].split('\n'):
             if line.lstrip().startswith('use '):
@@ -134,20 +139,23 @@ def createfuncwrapper(rout,signature=0):
     dumped_args = []
     for a in args:
         if isexternal(vars[a]):
-            add('external %s'%(a))
+            add('external %s' % (a))
             dumped_args.append(a)
     for a in args:
-        if a in dumped_args: continue
+        if a in dumped_args:
+            continue
         if isscalar(vars[a]):
             add(var2fixfortran(vars, a, f90mode=f90mode))
             dumped_args.append(a)
     for a in args:
-        if a in dumped_args: continue
+        if a in dumped_args:
+            continue
         if isintent_in(vars[a]):
             add(var2fixfortran(vars, a, f90mode=f90mode))
             dumped_args.append(a)
     for a in args:
-        if a in dumped_args: continue
+        if a in dumped_args:
+            continue
         add(var2fixfortran(vars, a, f90mode=f90mode))
 
     add(l)
@@ -165,19 +173,20 @@ def createfuncwrapper(rout,signature=0):
 
     if not signature:
         if islogicalfunction(rout):
-            add('%s = .not.(.not.%s(%s))'%(newname, fortranname, sargs))
+            add('%s = .not.(.not.%s(%s))' % (newname, fortranname, sargs))
         else:
-            add('%s = %s(%s)'%(newname, fortranname, sargs))
+            add('%s = %s(%s)' % (newname, fortranname, sargs))
     if f90mode:
-        add('end subroutine f2pywrap_%s_%s'%(rout['modulename'], name))
+        add('end subroutine f2pywrap_%s_%s' % (rout['modulename'], name))
     else:
         add('end')
-    #print '**'*10
-    #print ret[0]
-    #print '**'*10
+    # print '**'*10
+    # print ret[0]
+    # print '**'*10
     return ret[0]
 
-def createsubrwrapper(rout,signature=0):
+
+def createsubrwrapper(rout, signature=0):
     assert issubroutine(rout)
 
     extra_args = []
@@ -185,7 +194,7 @@ def createsubrwrapper(rout,signature=0):
     for a in rout['args']:
         v = rout['vars'][a]
         for i, d in enumerate(v.get('dimension', [])):
-            if d==':':
+            if d == ':':
                 dn = 'f2py_%s_d%s' % (a, i)
                 dv = dict(typespec='integer', intent=['hide'])
                 dv['='] = 'shape(%s, %s)' % (a, i)
@@ -196,8 +205,9 @@ def createsubrwrapper(rout,signature=0):
     need_interface = bool(extra_args)
 
     ret = ['']
-    def add(line,ret=ret):
-        ret[0] = '%s\n      %s'%(ret[0], line)
+
+    def add(line, ret=ret):
+        ret[0] = '%s\n      %s' % (ret[0], line)
     name = rout['name']
     fortranname = getfortranname(rout)
     f90mode = ismoduleroutine(rout)
@@ -206,13 +216,14 @@ def createsubrwrapper(rout,signature=0):
 
     sargs = ', '.join(args)
     if f90mode:
-        add('subroutine f2pywrap_%s_%s (%s)'%(rout['modulename'], name, sargs))
+        add('subroutine f2pywrap_%s_%s (%s)' %
+            (rout['modulename'], name, sargs))
         if not signature:
-            add('use %s, only : %s'%(rout['modulename'], fortranname))
+            add('use %s, only : %s' % (rout['modulename'], fortranname))
     else:
-        add('subroutine f2pywrap%s (%s)'%(name, sargs))
+        add('subroutine f2pywrap%s (%s)' % (name, sargs))
         if not need_interface:
-            add('external %s'%(fortranname))
+            add('external %s' % (fortranname))
 
     if need_interface:
         for line in rout['saved_interface'].split('\n'):
@@ -222,15 +233,17 @@ def createsubrwrapper(rout,signature=0):
     dumped_args = []
     for a in args:
         if isexternal(vars[a]):
-            add('external %s'%(a))
+            add('external %s' % (a))
             dumped_args.append(a)
     for a in args:
-        if a in dumped_args: continue
+        if a in dumped_args:
+            continue
         if isscalar(vars[a]):
             add(var2fixfortran(vars, a, f90mode=f90mode))
             dumped_args.append(a)
     for a in args:
-        if a in dumped_args: continue
+        if a in dumped_args:
+            continue
         add(var2fixfortran(vars, a, f90mode=f90mode))
 
     if need_interface:
@@ -245,14 +258,14 @@ def createsubrwrapper(rout,signature=0):
     sargs = ', '.join([a for a in args if a not in extra_args])
 
     if not signature:
-        add('call %s(%s)'%(fortranname, sargs))
+        add('call %s(%s)' % (fortranname, sargs))
     if f90mode:
-        add('end subroutine f2pywrap_%s_%s'%(rout['modulename'], name))
+        add('end subroutine f2pywrap_%s_%s' % (rout['modulename'], name))
     else:
         add('end')
-    #print '**'*10
-    #print ret[0]
-    #print '**'*10
+    # print '**'*10
+    # print ret[0]
+    # print '**'*10
     return ret[0]
 
 
@@ -260,19 +273,20 @@ def assubr(rout):
     if isfunction_wrap(rout):
         fortranname = getfortranname(rout)
         name = rout['name']
-        outmess('\t\tCreating wrapper for Fortran function "%s"("%s")...\n'%(name, fortranname))
+        outmess('\t\tCreating wrapper for Fortran function "%s"("%s")...\n' % (
+            name, fortranname))
         rout = copy.copy(rout)
         fname = name
         rname = fname
         if 'result' in rout:
             rname = rout['result']
-            rout['vars'][fname]=rout['vars'][rname]
+            rout['vars'][fname] = rout['vars'][rname]
         fvar = rout['vars'][fname]
         if not isintent_out(fvar):
             if 'intent' not in fvar:
-                fvar['intent']=[]
+                fvar['intent'] = []
             fvar['intent'].append('out')
-            flag=1
+            flag = 1
             for i in fvar['intent']:
                 if i.startswith('out='):
                     flag = 0
@@ -284,7 +298,8 @@ def assubr(rout):
     if issubroutine_wrap(rout):
         fortranname = getfortranname(rout)
         name = rout['name']
-        outmess('\t\tCreating wrapper for Fortran subroutine "%s"("%s")...\n'%(name, fortranname))
+        outmess('\t\tCreating wrapper for Fortran subroutine "%s"("%s")...\n' % (
+            name, fortranname))
         rout = copy.copy(rout)
         return rout, createsubrwrapper(rout)
     return rout, ''
diff --git a/numpy/f2py/rules.py b/numpy/f2py/rules.py
index fb76e032a..cf304edef 100644
--- a/numpy/f2py/rules.py
+++ b/numpy/f2py/rules.py
@@ -85,8 +85,8 @@ from . import use_rules
 from . import f90mod_rules
 from . import func2subr
 
-options={}
-sepdict={}
+options = {}
+sepdict = {}
 #for k in ['need_cfuncs']: sepdict[k]=','
 for k in ['decl',
           'frompyobj',
@@ -103,20 +103,20 @@ for k in ['decl',
           'initf2pywraphooks',
           'commonhooks', 'initcommonhooks',
           'f90modhooks', 'initf90modhooks']:
-    sepdict[k]='\n'
+    sepdict[k] = '\n'
 
 #################### Rules for C/API module #################
 
-module_rules={
-    'modulebody':"""\
+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:$
+ * 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!!!
  */
 
@@ -124,53 +124,53 @@ module_rules={
 extern \"C\" {
 #endif
 
-"""+gentitle("See f2py2e/cfuncs.py: includes")+"""
+""" + gentitle("See f2py2e/cfuncs.py: includes") + """
 #includes#
 #includes0#
 
-"""+gentitle("See f2py2e/rules.py: mod_rules['modulebody']")+"""
+""" + gentitle("See f2py2e/rules.py: mod_rules['modulebody']") + """
 static PyObject *#modulename#_error;
 static PyObject *#modulename#_module;
 
-"""+gentitle("See f2py2e/cfuncs.py: typedefs")+"""
+""" + gentitle("See f2py2e/cfuncs.py: typedefs") + """
 #typedefs#
 
-"""+gentitle("See f2py2e/cfuncs.py: typedefs_generated")+"""
+""" + gentitle("See f2py2e/cfuncs.py: typedefs_generated") + """
 #typedefs_generated#
 
-"""+gentitle("See f2py2e/cfuncs.py: cppmacros")+"""
+""" + gentitle("See f2py2e/cfuncs.py: cppmacros") + """
 #cppmacros#
 
-"""+gentitle("See f2py2e/cfuncs.py: cfuncs")+"""
+""" + gentitle("See f2py2e/cfuncs.py: cfuncs") + """
 #cfuncs#
 
-"""+gentitle("See f2py2e/cfuncs.py: userincludes")+"""
+""" + gentitle("See f2py2e/cfuncs.py: userincludes") + """
 #userincludes#
 
-"""+gentitle("See f2py2e/capi_rules.py: usercode")+"""
+""" + gentitle("See f2py2e/capi_rules.py: usercode") + """
 #usercode#
 
 /* See f2py2e/rules.py */
 #externroutines#
 
-"""+gentitle("See f2py2e/capi_rules.py: usercode1")+"""
+""" + gentitle("See f2py2e/capi_rules.py: usercode1") + """
 #usercode1#
 
-"""+gentitle("See f2py2e/cb_rules.py: buildcallback")+"""
+""" + gentitle("See f2py2e/cb_rules.py: buildcallback") + """
 #callbacks#
 
-"""+gentitle("See f2py2e/rules.py: buildapi")+"""
+""" + gentitle("See f2py2e/rules.py: buildapi") + """
 #body#
 
-"""+gentitle("See f2py2e/f90mod_rules.py: buildhooks")+"""
+""" + gentitle("See f2py2e/f90mod_rules.py: buildhooks") + """
 #f90modhooks#
 
-"""+gentitle("See f2py2e/rules.py: module_rules['modulebody']")+"""
+""" + gentitle("See f2py2e/rules.py: module_rules['modulebody']") + """
 
-"""+gentitle("See f2py2e/common_rules.py: buildhooks")+"""
+""" + gentitle("See f2py2e/common_rules.py: buildhooks") + """
 #commonhooks#
 
-"""+gentitle("See f2py2e/rules.py")+"""
+""" + gentitle("See f2py2e/rules.py") + """
 
 static FortranDataDef f2py_routine_defs[] = {
 #routine_defs#
@@ -215,7 +215,7 @@ PyMODINIT_FUNC init#modulename#(void) {
 \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: $\");
+\ts = PyString_FromString(\"$R""" + """evision: $\");
 \tPyDict_SetItemString(d, \"__version__\", s);
 #if PY_VERSION_HEX >= 0x03000000
 \ts = PyUnicode_FromString(
@@ -244,16 +244,16 @@ PyMODINIT_FUNC init#modulename#(void) {
 }
 #endif
 """,
-    'separatorsfor':{'latexdoc':'\n\n',
-                     'restdoc':'\n\n'},
-    'latexdoc':['\\section{Module \\texttt{#texmodulename#}}\n',
-                '#modnote#\n',
-                '#latexdoc#'],
-    'restdoc':['Module #modulename#\n'+'='*80,
-               '\n#restdoc#']
-    }
+    '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=[
+defmod_rules = [
     {'body': '/*eof body*/',
      'method': '/*eof method*/',
      'externroutines': '/*eof externroutines*/',
@@ -263,13 +263,13 @@ defmod_rules=[
      'initcommonhooks': '/*eof initcommonhooks*/',
      'latexdoc': '',
      'restdoc': '',
-     'modnote': {hasnote:'#note#',l_not(hasnote):''},
+     'modnote': {hasnote: '#note#', l_not(hasnote): ''},
      }
-    ]
+]
 
-routine_rules={
-    'separatorsfor':sepdict,
-    'body':"""
+routine_rules = {
+    'separatorsfor': sepdict,
+    'body': """
 #begintitle#
 static char doc_#apiname#[] = \"\\\n#docreturn##name#(#docsignatureshort#)\\n\\nWrapper for ``#name#``.\\\n\\n#docstrsigns#\";
 /* #declfortranroutine# */
@@ -325,112 +325,115 @@ f2py_stop_clock();
 }
 #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',
-                """
+    '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,
+    '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):''},
+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#_#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:"""\
+        '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#;
+            {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)):'''
+            {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#");
@@ -442,30 +445,32 @@ rout_rules=[
 #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:"""\
+        '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)):'''
+            {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#");
@@ -477,124 +482,128 @@ rout_rules=[
 #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:"""\
+        '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):"""\
+            {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)):"""\
+                               {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:"""\
+                               ],
+        '_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#;
+            {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:"""\
+            {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'},
-                          """\
+                              {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
+                              {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
+    {  # 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 ##################
 
@@ -611,169 +620,170 @@ typedef_need_dict = {islong_long: 'long_long',
                      issigned_long_longarray: 'long_long',
                      }
 
-aux_rules=[
+aux_rules = [
     {
-    'separatorsfor':sepdict
+        '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,
+    {  # 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)),
+    # 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),
+        '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
+    # 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
+    # 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
+    # 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)
+    # 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': isint1array,
+     '_depend': ''
      },
-# Integer*-1 array
-    {'need':'#ctype#',
-     '_check':isunsigned_chararray,
-     '_depend':''
+    # Integer*-1 array
+    {'need': '#ctype#',
+     '_check': isunsigned_chararray,
+     '_depend': ''
      },
-# Integer*-2 array
-    {'need':'#ctype#',
-     '_check':isunsigned_shortarray,
-     '_depend':''
+    # Integer*-2 array
+    {'need': '#ctype#',
+     '_check': isunsigned_shortarray,
+     '_depend': ''
      },
-# Integer*-8 array
-    {'need':'#ctype#',
-     '_check':isunsigned_long_longarray,
-     '_depend':''
+    # Integer*-8 array
+    {'need': '#ctype#',
+     '_check': isunsigned_long_longarray,
+     '_depend': ''
      },
-# Complexarray
-    {'need':'#ctype#',
-     '_check':iscomplexarray,
-     '_depend':''
+    # Complexarray
+    {'need': '#ctype#',
+     '_check': iscomplexarray,
+     '_depend': ''
      },
-# Stringarray
-     {
-     'callfortranappend':{isarrayofstrings:'flen(#varname#),'},
-     'need':'string',
-     '_check':isstringarray
-     }
-    ]
+    # Stringarray
+    {
+        'callfortranappend': {isarrayofstrings: 'flen(#varname#),'},
+        'need': 'string',
+        '_check': isstringarray
+    }
+]
 
-arg_rules=[
+arg_rules = [
     {
-    'separatorsfor':sepdict
+        '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,
+    {  # 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
+    # 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':''
+        '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
+    # Required/Optional arguments
     {
-    'kwlist':'"#varname#",',
-    'docsign':'#varname#,',
-    '_check':l_and(isintent_nothide, l_not(isoptional))
+        '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)
+        'kwlistopt': '"#varname#",',
+        'docsignopt': '#varname#=#showinit#,',
+        'docsignoptshort': '#varname#,',
+        '_check': l_and(isintent_nothide, isoptional)
     },
-# Docstring/BuildValue
+    # Docstring/BuildValue
     {
-    'docreturn':'#outvarname#,',
-    'returnformat':'#varrformat#',
-    '_check':isintent_out
+        '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
+    # 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):"""\
+        'frompyobj': [{l_not(isintent_callback): """\
 if(F2PyCapsule_Check(#varname#_capi)) {
   #varname#_cptr = F2PyCapsule_AsVoidPtr(#varname#_capi);
 } else {
   #varname#_cptr = #cbname#;
 }
-"""}, {isintent_callback:"""\
+"""}, {isintent_callback: """\
 if (#varname#_capi==Py_None) {
   #varname#_capi = PyObject_GetAttrString(#modulename#_module,\"#varname#\");
   if (#varname#_capi) {
@@ -797,27 +807,27 @@ if (#varname#_capi==Py_None) {
   }
 }
 """},
-##    {l_not(isintent_callback):"""\
-## if (#varname#_capi==Py_None) {
-## printf(\"hoi\\n\");
-## }
-## """},
-"""\
+            # {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:["""\
+            {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#);"""}]},
-          """\
+                         {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':
-"""\
+        ],
+        'cleanupfrompyobj':
+        """\
 \t\tCFUNCSMESS(\"Restoring jmpbuf for `#varname#`.\\n\");
 \t\t#cbname#_capi = #varname#_capi;
 \t\tPy_DECREF(#cbname#_args_capi);
@@ -825,246 +835,249 @@ if (#varname#_capi==Py_None) {
 \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':''
+        '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))
+    # 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:"""\
+        '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)
+        '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):'''\
+        '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:'''\
+            {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':''
+        ],
+        '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:"""\
+    # 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)
+        '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: '\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': {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':''
+        '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':"""\
+    # 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':"""\
+        '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:'''\
+        '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)
+        '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':''
+        '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),
+    # 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': '',
+        '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': '',
+    {  # 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 (PyArray_NDIM((PyArrayObject *)#varname#_capi) != PyArray_NDIM(capi_#varname#_tmp)) {
-# \t\t\tif (#varname#_capi != PyArray_BASE(capi_#varname#_tmp))
-# \t\t\t\tcopy_ND_array(PyArray_BASE((PyArrayObject *)capi_#varname#_tmp),(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)
+        '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 (PyArray_NDIM((PyArrayObject *)#varname#_capi) != PyArray_NDIM(capi_#varname#_tmp)) {
+        # \t\t\tif (#varname#_capi != PyArray_BASE(capi_#varname#_tmp))
+        # \t\t\t\tcopy_ND_array(PyArray_BASE((PyArrayObject *)capi_#varname#_tmp),(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);'},
-                 """\
+        '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;'},
-    """\
+                      {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)) {
@@ -1077,89 +1090,89 @@ if (#varname#_capi==Py_None) {
 \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)):"""\
+                      ],
+        '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':''
+            {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)
+    # { # 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': isint1array,
+     '_depend': ''
      },
-# Integer*-1 array
-    {'need':'#ctype#',
-     '_check':isunsigned_chararray,
-     '_depend':''
+    # Integer*-1 array
+    {'need': '#ctype#',
+     '_check': isunsigned_chararray,
+     '_depend': ''
      },
-# Integer*-2 array
-    {'need':'#ctype#',
-     '_check':isunsigned_shortarray,
-     '_depend':''
+    # Integer*-2 array
+    {'need': '#ctype#',
+     '_check': isunsigned_shortarray,
+     '_depend': ''
      },
-# Integer*-8 array
-    {'need':'#ctype#',
-     '_check':isunsigned_long_longarray,
-     '_depend':''
+    # Integer*-8 array
+    {'need': '#ctype#',
+     '_check': isunsigned_long_longarray,
+     '_depend': ''
      },
-# Complexarray
-    {'need':'#ctype#',
-     '_check':iscomplexarray,
-     '_depend':''
+    # Complexarray
+    {'need': '#ctype#',
+     '_check': iscomplexarray,
+     '_depend': ''
      },
-# Stringarray
-     {
-     'callfortranappend':{isarrayofstrings:'flen(#varname#),'},
-     'need':'string',
-     '_check':isstringarray
-     }
-    ]
+    # Stringarray
+    {
+        'callfortranappend': {isarrayofstrings: 'flen(#varname#),'},
+        'need': 'string',
+        '_check': isstringarray
+    }
+]
 
 ################# Rules for checking ###############
 
-check_rules=[
+check_rules = [
     {
-    'frompyobj':{debugcapi:'\tfprintf(stderr,\"debug-capi:Checking `#check#\'\\n\");'},
-    'need':'len..'
+        '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': '\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':''
+        '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': '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#)*/',
+        'need': 'CHECKGENERIC',
+        'frompyobj': '\tCHECKGENERIC(#check#,\"#check#\",\"#nth# #varname#\") {',
+        'cleanupfrompyobj': '\t} /*CHECKGENERIC(#check#)*/',
     }
 ]
 
@@ -1167,29 +1180,33 @@ check_rules=[
 
 #################### Build C/API module #######################
 
+
 def buildmodule(m, um):
     """
     Return
     """
     global f2py_version, options
-    outmess('\tBuilding module "%s"...\n'%(m['name']))
+    outmess('\tBuilding module "%s"...\n' % (m['name']))
     ret = {}
-    mod_rules=defmod_rules[:]
+    mod_rules = defmod_rules[:]
     vrd = capi_maps.modsign2map(m)
-    rd=dictappend({'f2py_version':f2py_version}, vrd)
+    rd = dictappend({'f2py_version': f2py_version}, vrd)
     funcwrappers = []
-    funcwrappers2 = [] # F90 codes
+    funcwrappers2 = []  # F90 codes
     for n in m['interfaced']:
-        nb=None
+        nb = None
         for bi in m['body']:
-            if not bi['block']=='interface':
+            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 b['name'] == n:
+                    nb = b
+                    break
 
         if not nb:
-            errmess('buildmodule: Could not found the body of interfaced routine "%s". Skipping.\n'%(n))
+            errmess(
+                'buildmodule: Could not found the body of interfaced routine "%s". Skipping.\n' % (n))
             continue
         nb_list = [nb]
         if 'entry' in nb:
@@ -1200,184 +1217,202 @@ def buildmodule(m, um):
                 nb1['args'] = a
                 nb_list.append(nb1)
         for nb in nb_list:
-            api, wrap=buildapi(nb)
+            api, wrap = buildapi(nb)
             if wrap:
                 if ismoduleroutine(nb):
                     funcwrappers2.append(wrap)
                 else:
                     funcwrappers.append(wrap)
-            ar=applyrules(api, vrd)
-            rd=dictappend(rd, ar)
+            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)
+    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)
+    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)
+        ar = use_rules.buildusevars(u, m['use'][u['name']])
+        rd = dictappend(rd, ar)
 
-    needs=cfuncs.get_needs()
-    code={}
+    needs = cfuncs.get_needs()
+    code = {}
     for n in needs.keys():
-        code[n]=[]
+        code[n] = []
         for k in needs[n]:
-            c=''
+            c = ''
             if k in cfuncs.includes0:
-                c=cfuncs.includes0[k]
+                c = cfuncs.includes0[k]
             elif k in cfuncs.includes:
-                c=cfuncs.includes[k]
+                c = cfuncs.includes[k]
             elif k in cfuncs.userincludes:
-                c=cfuncs.userincludes[k]
+                c = cfuncs.userincludes[k]
             elif k in cfuncs.typedefs:
-                c=cfuncs.typedefs[k]
+                c = cfuncs.typedefs[k]
             elif k in cfuncs.typedefs_generated:
-                c=cfuncs.typedefs_generated[k]
+                c = cfuncs.typedefs_generated[k]
             elif k in cfuncs.cppmacros:
-                c=cfuncs.cppmacros[k]
+                c = cfuncs.cppmacros[k]
             elif k in cfuncs.cfuncs:
-                c=cfuncs.cfuncs[k]
+                c = cfuncs.cfuncs[k]
             elif k in cfuncs.callbacks:
-                c=cfuncs.callbacks[k]
+                c = cfuncs.callbacks[k]
             elif k in cfuncs.f90modhooks:
-                c=cfuncs.f90modhooks[k]
+                c = cfuncs.f90modhooks[k]
             elif k in cfuncs.commonhooks:
-                c=cfuncs.commonhooks[k]
+                c = cfuncs.commonhooks[k]
             else:
-                errmess('buildmodule: unknown need %s.\n'%(repr(k)));continue
+                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)
+            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 = 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))
+    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')
+        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']))
+        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')
+        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))
+        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(
+                '\\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']))
+        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 = 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')
+        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     &')
+        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.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))
+        outmess('\tFortran 77 wrappers are saved to "%s"\n' % (wn))
     if funcwrappers2:
-        wn = os.path.join(options['buildpath'], '%s-f2pywrappers2.f90'%(vrd['modulename']))
+        wn = os.path.join(
+            options['buildpath'], '%s-f2pywrappers2.f90' % (vrd['modulename']))
         ret['fsrc'] = wn
-        f=open(wn, 'w')
+        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')
+        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     &')
+        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     &')
+                while len(l) > 66:
+                    lines.append(l[:66] + '&\n     &')
                     l = l[66:]
-                lines.append(l+'\n')
-            else: lines.append(l+'\n')
+                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))
+        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'}
+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']
+    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']))
+        outmess('\t\t\tConstructing wrapper function "%s.%s"...\n' %
+                (rout['modulename'], rout['name']))
     else:
-        outmess('\t\tConstructing wrapper function "%s"...\n'%(rout['name']))
+        outmess('\t\tConstructing wrapper function "%s"...\n' % (rout['name']))
     # Routine
     vrd = capi_maps.routsign2map(rout)
-    rd=dictappend({}, vrd)
+    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)
+            ar = applyrules(r, vrd, rout)
+            rd = dictappend(rd, ar)
 
     # Args
-    nth, nthk=0, 0
-    savevrd={}
+    nth, nthk = 0, 0
+    savevrd = {}
     for a in args:
-        vrd=capi_maps.sign2map(a, var[a])
+        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'
+                    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
+                    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)
+                ar = applyrules(r, vrd, var[a])
+                rd = dictappend(rd, ar)
                 if '_break' in r:
                     break
     for a in depargs:
@@ -1385,59 +1420,64 @@ def buildapi(rout):
             _rules = aux_rules
         else:
             _rules = arg_rules
-        vrd=savevrd[a]
+        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)
+                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)
+                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']}))
+    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']}))
+        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
+        rd['callcompaqfortran'] = cfs
+    rd['callfortran'] = cfs
     if isinstance(rd['docreturn'], list):
-        rd['docreturn']=stripcomma(replace('#docreturn#', {'docreturn':rd['docreturn']}))+' = '
-    rd['docstrsigns']=[]
-    rd['latexdocstrsigns']=[]
+        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
+            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}']
+            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']:
@@ -1445,14 +1485,15 @@ def buildapi(rout):
         if isinstance(argformat, list):
             argformat.append('|')
         else:
-            assert isinstance(argformat, str), repr((argformat, type(argformat)))
+            assert isinstance(argformat, str), repr(
+                (argformat, type(argformat)))
             rd['argformat'] += '|'
 
-    ar=applyrules(routine_rules, rd)
+    ar = applyrules(routine_rules, rd)
     if ismoduleroutine(rout):
-        outmess('\t\t\t  %s\n'%(ar['docshort']))
+        outmess('\t\t\t  %s\n' % (ar['docshort']))
     else:
-        outmess('\t\t  %s\n'%(ar['docshort']))
+        outmess('\t\t  %s\n' % (ar['docshort']))
     return ar, wrap
 
 
diff --git a/numpy/f2py/setup.py b/numpy/f2py/setup.py
index 656013fad..3204129ec 100644
--- a/numpy/f2py/setup.py
+++ b/numpy/f2py/setup.py
@@ -43,7 +43,7 @@ def _get_f2py_shebang():
     return '#!' + sys.executable
 
 
-def configuration(parent_package='',top_path=None):
+def configuration(parent_package='', top_path=None):
     config = Configuration('f2py', parent_package, top_path)
 
     config.add_data_dir('tests')
@@ -55,8 +55,8 @@ def configuration(parent_package='',top_path=None):
     config.make_svn_version_py()
 
     def generate_f2py_py(build_dir):
-        f2py_exe = 'f2py'+os.path.basename(sys.executable)[6:]
-        if f2py_exe[-4:]=='.exe':
+        f2py_exe = 'f2py' + os.path.basename(sys.executable)[6:]
+        if f2py_exe[-4:] == '.exe':
             f2py_exe = f2py_exe[:-4] + '.py'
         if 'bdist_wininst' in sys.argv and f2py_exe[-3:] != '.py':
             f2py_exe = f2py_exe + '.py'
@@ -97,21 +97,21 @@ if __name__ == "__main__":
         'Programming Language :: Python',
         'Topic :: Scientific/Engineering',
         'Topic :: Software Development :: Code Generators',
-        ]
+    ]
     setup(version=version,
-          description       = "F2PY - Fortran to Python Interface Generaton",
-          author            = "Pearu Peterson",
-          author_email      = "pearu@cens.ioc.ee",
-          maintainer        = "Pearu Peterson",
-          maintainer_email  = "pearu@cens.ioc.ee",
-          license           = "BSD",
-          platforms         = "Unix, Windows (mingw|cygwin), Mac OSX",
-          long_description  = """\
+          description="F2PY - Fortran to Python Interface Generaton",
+          author="Pearu Peterson",
+          author_email="pearu@cens.ioc.ee",
+          maintainer="Pearu Peterson",
+          maintainer_email="pearu@cens.ioc.ee",
+          license="BSD",
+          platforms="Unix, Windows (mingw|cygwin), Mac OSX",
+          long_description="""\
 The Fortran to Python Interface Generator, or F2PY for short, is a
 command line tool (f2py) for generating Python C/API modules for
 wrapping Fortran 77/90/95 subroutines, accessing common blocks from
 Python, and calling Python functions from Fortran (call-backs).
 Interfacing subroutines/data from Fortran 90/95 modules is supported.""",
-          url               = "http://cens.ioc.ee/projects/f2py2e/",
-          keywords          = ['Fortran', 'f2py'],
+          url="http://cens.ioc.ee/projects/f2py2e/",
+          keywords=['Fortran', 'f2py'],
           **config)
diff --git a/numpy/f2py/use_rules.py b/numpy/f2py/use_rules.py
index 8c87de745..6f44f1634 100644
--- a/numpy/f2py/use_rules.py
+++ b/numpy/f2py/use_rules.py
@@ -19,16 +19,16 @@ from __future__ import division, absolute_import, print_function
 
 __version__ = "$Revision: 1.3 $"[10:-1]
 
-f2py_version='See `f2py -v`'
+f2py_version = 'See `f2py -v`'
 
 
 from .auxfuncs import (
-    applyrules,dictappend, gentitle, hasnote, outmess
+    applyrules, dictappend, gentitle, hasnote, outmess
 )
 
 
-usemodule_rules={
-    'body':"""
+usemodule_rules = {
+    'body': """
 #begintitle#
 static char doc_#apiname#[] = \"\\\nVariable wrapper signature:\\n\\
 \t #name# = get_#name#()\\n\\
@@ -44,61 +44,70 @@ capi_fail:
 \treturn NULL;
 }
 """,
-    'method':'\t{\"get_#name#\",#apiname#,METH_VARARGS|METH_KEYWORDS,doc_#apiname#},',
-    'need':['F_MODFUNC']
-    }
+    'method': '\t{\"get_#name#\",#apiname#,METH_VARARGS|METH_KEYWORDS,doc_#apiname#},',
+    'need': ['F_MODFUNC']
+}
 
 ################
 
+
 def buildusevars(m, r):
-    ret={}
-    outmess('\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n'%(m['name']))
-    varsmap={}
-    revmap={}
+    ret = {}
+    outmess(
+        '\t\tBuilding use variable hooks for module "%s" (feature only for F90/F95)...\n' % (m['name']))
+    varsmap = {}
+    revmap = {}
     if 'map' in r:
         for k in r['map'].keys():
             if r['map'][k] in revmap:
-                outmess('\t\t\tVariable "%s<=%s" is already mapped by "%s". Skipping.\n'%(r['map'][k], k, revmap[r['map'][k]]))
+                outmess('\t\t\tVariable "%s<=%s" is already mapped by "%s". Skipping.\n' % (
+                    r['map'][k], k, revmap[r['map'][k]]))
             else:
-                revmap[r['map'][k]]=k
+                revmap[r['map'][k]] = k
     if 'only' in r and r['only']:
         for v in r['map'].keys():
             if r['map'][v] in m['vars']:
 
-                if revmap[r['map'][v]]==v:
-                    varsmap[v]=r['map'][v]
+                if revmap[r['map'][v]] == v:
+                    varsmap[v] = r['map'][v]
                 else:
-                    outmess('\t\t\tIgnoring map "%s=>%s". See above.\n'%(v, r['map'][v]))
+                    outmess('\t\t\tIgnoring map "%s=>%s". See above.\n' %
+                            (v, r['map'][v]))
             else:
-                outmess('\t\t\tNo definition for variable "%s=>%s". Skipping.\n'%(v, r['map'][v]))
+                outmess(
+                    '\t\t\tNo definition for variable "%s=>%s". Skipping.\n' % (v, r['map'][v]))
     else:
         for v in m['vars'].keys():
             if v in revmap:
-                varsmap[v]=revmap[v]
+                varsmap[v] = revmap[v]
             else:
-                varsmap[v]=v
+                varsmap[v] = v
     for v in varsmap.keys():
-        ret=dictappend(ret, buildusevar(v, varsmap[v], m['vars'], m['name']))
+        ret = dictappend(ret, buildusevar(v, varsmap[v], m['vars'], m['name']))
     return ret
+
+
 def buildusevar(name, realname, vars, usemodulename):
-    outmess('\t\t\tConstructing wrapper function for variable "%s=>%s"...\n'%(name, realname))
-    ret={}
-    vrd={'name':name,
-         'realname':realname,
-         'REALNAME':realname.upper(),
-         'usemodulename':usemodulename,
-         'USEMODULENAME':usemodulename.upper(),
-         'texname':name.replace('_', '\\_'),
-         'begintitle':gentitle('%s=>%s'%(name, realname)),
-         'endtitle':gentitle('end of %s=>%s'%(name, realname)),
-         'apiname':'#modulename#_use_%s_from_%s'%(realname, usemodulename)
-         }
-    nummap={0:'Ro',1:'Ri',2:'Rii',3:'Riii',4:'Riv',5:'Rv',6:'Rvi',7:'Rvii',8:'Rviii',9:'Rix'}
-    vrd['texnamename']=name
+    outmess('\t\t\tConstructing wrapper function for variable "%s=>%s"...\n' % (
+        name, realname))
+    ret = {}
+    vrd = {'name': name,
+           'realname': realname,
+           'REALNAME': realname.upper(),
+           'usemodulename': usemodulename,
+           'USEMODULENAME': usemodulename.upper(),
+           'texname': name.replace('_', '\\_'),
+           'begintitle': gentitle('%s=>%s' % (name, realname)),
+           'endtitle': gentitle('end of %s=>%s' % (name, realname)),
+           'apiname': '#modulename#_use_%s_from_%s' % (realname, usemodulename)
+           }
+    nummap = {0: 'Ro', 1: 'Ri', 2: 'Rii', 3: 'Riii', 4: 'Riv',
+              5: 'Rv', 6: 'Rvi', 7: 'Rvii', 8: 'Rviii', 9: 'Rix'}
+    vrd['texnamename'] = name
     for i in nummap.keys():
-        vrd['texnamename']=vrd['texnamename'].replace(repr(i), nummap[i])
+        vrd['texnamename'] = vrd['texnamename'].replace(repr(i), nummap[i])
     if hasnote(vars[realname]):
-        vrd['note']=vars[realname]['note']
+        vrd['note'] = vars[realname]['note']
     rd = dictappend({}, vrd)
 
     print(name, realname, vars[realname])