STY: Giant comma spacing fixup.

Run the 2to3 ws_comma fixer on *.py files. Some lines are now too long
and will need to be broken at some point. OTOH, some lines were already
too long and need to be broken at some point. Now seems as good a time
as any to do this with open PRs at a minimum.

1 files changed, 400 insertions, 400 deletions

diff --git a/numpy/f2py/crackfortran.py b/numpy/f2py/crackfortran.py
index 8b455c8ad..34b6192e4 100755
--- a/numpy/f2py/crackfortran.py
+++ b/numpy/f2py/crackfortran.py
@@ -204,21 +204,21 @@ for c in "ijklmn": defaultimplicitrules[c]={'typespec':'integer'}
 del c
 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',
-          'continue','else','inline','extern','delete','const','auto',
-          'len','rank','shape','index','slen','size','_i',
+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',
+          'continue', 'else', 'inline', 'extern', 'delete', 'const', 'auto',
+          'len', 'rank', 'shape', 'index', 'slen', 'size', '_i',
           'max', 'min',
-          'flen','fshape',
-          'string','complex_double','float_double','stdin','stderr','stdout',
-          'type','default']:
+          'flen', 'fshape',
+          'string', 'complex_double', 'float_double', 'stdin', 'stderr', 'stdout',
+          'type', 'default']:
     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
 
@@ -227,7 +227,7 @@ 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]))
+                %(name, invbadnames[name]))
         return invbadnames[name]
     return name
 
@@ -240,17 +240,17 @@ def getextension(name):
     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
+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
     # signs of free format are detected.
     result = 0
-    f = open(file,'r')
+    f = open(file, 'r')
     line = f.readline()
     n = 15 # the number of non-comment lines to scan for hints
     if _has_f_header(line):
@@ -277,23 +277,23 @@ def readfortrancode(ffile,dowithline=show,istop=1):
      2) Call dowithline(line) on every line.
      3) Recursively call itself when statement \"include '<filename>'\" is met.
     """
-    global gotnextfile,filepositiontext,currentfilename,sourcecodeform,strictf77,\
-           beginpattern,quiet,verbose,dolowercase,include_paths
+    global gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
+           beginpattern, quiet, verbose, dolowercase, include_paths
     if not istop:
-        saveglobals=gotnextfile,filepositiontext,currentfilename,sourcecodeform,strictf77,\
-           beginpattern,quiet,verbose,dolowercase
+        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)
+    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='',''
+    if istop: dowithline('', -1)
+    ll, l1='', ''
     spacedigits=[' '] + [str(_m) for _m in range(10)]
     filepositiontext=''
     fin=fileinput.FileInput(ffile)
@@ -316,10 +316,10 @@ def readfortrancode(ffile,dowithline=show,istop=1):
             if strictf77: beginpattern=beginpattern77
             else: beginpattern=beginpattern90
             outmess('\tReading file %s (format:%s%s)\n'\
-                    %(repr(currentfilename),sourcecodeform,
+                    %(repr(currentfilename), sourcecodeform,
                       strictf77 and ',strict' or ''))
 
-        l=l.expandtabs().replace('\xa0',' ')
+        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]
@@ -337,7 +337,7 @@ def readfortrancode(ffile,dowithline=show,istop=1):
             cont=0
             continue
         if sourcecodeform=='fix':
-            if l[0] in ['*','c','!','C','#']:
+            if l[0] in ['*', 'c', '!', 'C', '#']:
                 if l[1:5].lower()=='f2py': # f2py directive
                     l='     '+l[5:]
                 else: # Skip comment line
@@ -404,20 +404,20 @@ def readfortrancode(ffile,dowithline=show,istop=1):
             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)
+        filepositiontext='Line #%d in %s:"%s"\n\t' % (fin.filelineno()-1, currentfilename, l1)
         m=includeline.match(origfinalline)
         if m:
             fn=m.group('name')
             if os.path.isfile(fn):
-                readfortrancode(fn,dowithline=dowithline,istop=0)
+                readfortrancode(fn, dowithline=dowithline, istop=0)
             else:
                 include_dirs = [os.path.dirname(currentfilename)] + include_paths
                 foundfile = 0
                 for inc_dir in include_dirs:
-                    fn1 = os.path.join(inc_dir,fn)
+                    fn1 = os.path.join(inc_dir, fn)
                     if os.path.isfile(fn1):
                         foundfile = 1
-                        readfortrancode(fn1,dowithline=dowithline,istop=0)
+                        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)))
@@ -428,20 +428,20 @@ def readfortrancode(ffile,dowithline=show,istop=1):
         finalline=ll.lower()
     else: finalline=ll
     origfinalline = ll
-    filepositiontext='Line #%d in %s:"%s"\n\t' % (fin.filelineno()-1,currentfilename,l1)
+    filepositiontext='Line #%d in %s:"%s"\n\t' % (fin.filelineno()-1, currentfilename, l1)
     m=includeline.match(origfinalline)
     if m:
         fn=m.group('name')
         if os.path.isfile(fn):
-            readfortrancode(fn,dowithline=dowithline,istop=0)
+            readfortrancode(fn, dowithline=dowithline, istop=0)
         else:
             include_dirs = [os.path.dirname(currentfilename)] + include_paths
             foundfile = 0
             for inc_dir in include_dirs:
-                fn1 = os.path.join(inc_dir,fn)
+                fn1 = os.path.join(inc_dir, fn)
                 if os.path.isfile(fn1):
                     foundfile = 1
-                    readfortrancode(fn1,dowithline=dowithline,istop=0)
+                    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)))
@@ -449,10 +449,10 @@ def readfortrancode(ffile,dowithline=show,istop=1):
         dowithline(finalline)
     filepositiontext=''
     fin.close()
-    if istop: dowithline('',1)
+    if istop: dowithline('', 1)
     else:
-        gotnextfile,filepositiontext,currentfilename,sourcecodeform,strictf77,\
-           beginpattern,quiet,verbose,dolowercase=saveglobals
+        gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
+           beginpattern, quiet, verbose, dolowercase=saveglobals
 
 ########### Crack line
 beforethisafter=r'\s*(?P<before>%s(?=\s*(\b(%s)\b)))'+ \
@@ -460,55 +460,55 @@ beforethisafter=r'\s*(?P<before>%s(?=\s*(\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)
+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'
+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'
+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'
+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'
+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'
+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'
+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'
+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('@,@'):
         for r in '(),':
-            n = n.replace(r,'_')
+            n = n.replace(r, '_')
         a.append(n)
     return ','.join(a)
 
-crackline_re_1 = re.compile(r'\s*(?P<result>\b[a-z]+[\w]*\b)\s*[=].*',re.I)
+crackline_re_1 = re.compile(r'\s*(?P<result>\b[a-z]+[\w]*\b)\s*[=].*', re.I)
 def crackline(line,reset=0):
     """
     reset=-1  --- initialize
@@ -517,14 +517,14 @@ def crackline(line,reset=0):
 
     Cracked data is saved in grouplist[0].
     """
-    global beginpattern,groupcounter,groupname,groupcache,grouplist,gotnextfile,\
-           filepositiontext,currentfilename,neededmodule,expectbegin,skipblocksuntil,\
-           skipemptyends,previous_context
+    global beginpattern, groupcounter, groupname, groupcache, grouplist, gotnextfile,\
+           filepositiontext, currentfilename, neededmodule, expectbegin, skipblocksuntil,\
+           skipemptyends, previous_context
     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
-            crackline(l,reset)
+            assert reset==0, repr(reset) # XXX: non-zero reset values need testing
+            crackline(l, reset)
         return
     if reset<0:
         groupcounter=0
@@ -542,7 +542,7 @@ def crackline(line,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: 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]
@@ -561,15 +561,15 @@ def crackline(line,reset=0):
         return
     if line=='': return
     flag=0
-    for pat in [dimensionpattern,externalpattern,intentpattern,optionalpattern,
+    for pat in [dimensionpattern, externalpattern, intentpattern, optionalpattern,
                 requiredpattern,
-                parameterpattern,datapattern,publicpattern,privatepattern,
+                parameterpattern, datapattern, publicpattern, privatepattern,
                 intrisicpattern,
-                endifpattern,endpattern,
+                endifpattern, endpattern,
                 formatpattern,
-                beginpattern,functionpattern,subroutinepattern,
-                implicitpattern,typespattern,commonpattern,
-                callpattern,usepattern,containspattern,
+                beginpattern, functionpattern, subroutinepattern,
+                implicitpattern, typespattern, commonpattern,
+                callpattern, usepattern, containspattern,
                 entrypattern,
                 f2pyenhancementspattern,
                 multilinepattern
@@ -587,18 +587,18 @@ def crackline(line,reset=0):
                     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))
                         return
-                    analyzeline(m,'callfun',line)
+                    analyzeline(m, 'callfun', line)
                     return
         if verbose>1 or (verbose==1 and currentfilename.lower().endswith('.pyf')):
             previous_context = None
@@ -632,7 +632,7 @@ def crackline(line,reset=0):
             groupcounter=groupcounter+1
             return
         gotnextfile=0
-        analyzeline(m,pat[1],line)
+        analyzeline(m, pat[1], line)
         expectbegin=0
     elif pat[1]=='endif':
         pass
@@ -642,7 +642,7 @@ def crackline(line,reset=0):
         skipblocksuntil=groupcounter
     else:
         if 0<=skipblocksuntil<=groupcounter:return
-        analyzeline(m,pat[1],line)
+        analyzeline(m, pat[1], line)
 
 def markouterparen(line):
     l='';f=0
@@ -673,10 +673,10 @@ def markoutercomma(line,comma=','):
             l=l+'@'+comma+'@'
             continue
         l=l+c
-    assert not f,repr((f,line,l,cc))
+    assert not f, repr((f, line, l, cc))
     return l
 def unmarkouterparen(line):
-    r = line.replace('@(@','(').replace('@)@',')')
+    r = line.replace('@(@', '(').replace('@)@', ')')
     return r
 def appenddecl(decl,decl2,force=1):
     if not decl: decl={}
@@ -688,32 +688,32 @@ def appenddecl(decl,decl2,force=1):
                 decl[k]=decl2[k]
         elif k=='attrspec':
             for l in decl2[k]:
-                decl=setattrspec(decl,l,force)
+                decl=setattrspec(decl, l, force)
         elif k=='kindselector':
-            decl=setkindselector(decl,decl2[k],force)
+            decl=setkindselector(decl, decl2[k], force)
         elif k=='charselector':
-            decl=setcharselector(decl,decl2[k],force)
-        elif k in ['=','typename']:
+            decl=setcharselector(decl, decl2[k], force)
+        elif k in ['=', 'typename']:
             if force or k not in decl:
                 decl[k]=decl2[k]
         elif k=='note':
             pass
-        elif k in ['intent','check','dimension','optional','required']:
+        elif k in ['intent', 'check', 'dimension', 'optional', 'required']:
             errmess('appenddecl: "%s" not implemented.\n'%k)
         else:
             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)
+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)
+_intentcallbackpattern = re.compile(r'intent\s*\(.*?\bcallback\b', re.I)
 def _is_intent_callback(vdecl):
-    for a in vdecl.get('attrspec',[]):
+    for a in vdecl.get('attrspec', []):
         if _intentcallbackpattern.match(a):
             return 1
     return 0
@@ -722,20 +722,20 @@ def _resolvenameargspattern(line):
     line = markouterparen(line)
     m1=nameargspattern.match(line)
     if m1:
-        return m1.group('name'),m1.group('args'),m1.group('result'), m1.group('bind')
+        return m1.group('name'), m1.group('args'), m1.group('result'), m1.group('bind')
     m1=callnameargspattern.match(line)
     if m1:
-        return m1.group('name'),m1.group('args'),None, None
-    return None,[],None, None
+        return m1.group('name'), m1.group('args'), None, None
+    return None, [], None, None
 
-def analyzeline(m,case,line):
-    global groupcounter,groupname,groupcache,grouplist,filepositiontext,\
-           currentfilename,f77modulename,neededinterface,neededmodule,expectbegin,\
-           gotnextfile,previous_context
+def analyzeline(m, case, line):
+    global groupcounter, groupname, groupcache, grouplist, filepositiontext,\
+           currentfilename, f77modulename, neededinterface, neededmodule, expectbegin,\
+           gotnextfile, previous_context
     block=m.group('this')
     if case != 'multiline':
         previous_context = None
-    if expectbegin and case not in ['begin','call','callfun','type'] \
+    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)
@@ -750,21 +750,21 @@ def analyzeline(m,case,line):
         groupcache[groupcounter]['name']=newname
         groupcache[groupcounter]['from']='fromsky'
         expectbegin=0
-    if case in ['begin','call','callfun']:
+    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'
-        name,args,result,bind = _resolvenameargspattern(m.group('after'))
+        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':
                 name = '_BLOCK_DATA_'
             else:
                 name = ''
-            if block not in ['interface','block data']:
+            if block not in ['interface', 'block data']:
                 outmess('analyzeline: No name/args pattern found for line.\n')
 
-        previous_context = (block,name,groupcounter)
+        previous_context = (block, name, groupcounter)
         if args: args=rmbadname([x.strip() for x in markoutercomma(args).split('@,@')])
         else: args=[]
         if '' in args:
@@ -776,7 +776,7 @@ def analyzeline(m,case,line):
         needmodule=0
         needinterface=0
 
-        if case in ['call','callfun']:
+        if case in ['call', 'callfun']:
             needinterface=1
             if 'args' not in groupcache[groupcounter]:
                 return
@@ -799,7 +799,7 @@ def analyzeline(m,case,line):
         grouplist[groupcounter]=[]
         if needmodule:
             if verbose>1:
-                outmess('analyzeline: Creating module block %s\n'%repr(f77modulename),0)
+                outmess('analyzeline: Creating module block %s\n'%repr(f77modulename), 0)
             groupname[groupcounter]='module'
             groupcache[groupcounter]['block']='python module'
             groupcache[groupcounter]['name']=f77modulename
@@ -813,11 +813,11 @@ def analyzeline(m,case,line):
             grouplist[groupcounter]=[]
         if needinterface:
             if verbose>1:
-                outmess('analyzeline: Creating additional interface block (groupcounter=%s).\n' % (groupcounter),0)
+                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]['from']='%s:%s'%(groupcache[groupcounter-1]['from'], groupcache[groupcounter-1]['name'])
             groupcache[groupcounter]['body']=[]
             groupcache[groupcounter]['externals']=[]
             groupcache[groupcounter]['interfaced']=[]
@@ -835,9 +835,9 @@ def analyzeline(m,case,line):
             groupcache[groupcounter]['from']=currentfilename
         else:
             if f77modulename and groupcounter==3:
-                groupcache[groupcounter]['from']='%s:%s'%(groupcache[groupcounter-1]['from'],currentfilename)
+                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]
@@ -852,7 +852,7 @@ def analyzeline(m,case,line):
         if block=='type':
             groupcache[groupcounter]['varnames'] = []
 
-        if case in ['call','callfun']: # set parents variables
+        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'])
@@ -860,23 +860,23 @@ def analyzeline(m,case,line):
             #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'][''])
+        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])
+                        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'))
-                updatevars(typespec,selector,attr,edecl)
+                typespec, selector, attr, edecl=cracktypespec0(t.group('this'), t.group('after'))
+                updatevars(typespec, selector, attr, edecl)
 
-        if case in ['call','callfun']:
+        if case in ['call', 'callfun']:
             grouplist[groupcounter-1].append(groupcache[groupcounter])
             grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
             del grouplist[groupcounter]
@@ -887,20 +887,20 @@ def analyzeline(m,case,line):
             groupcounter=groupcounter-1 # end interface
 
     elif case=='entry':
-        name,args,result,bind=_resolvenameargspattern(m.group('after'))
+        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=[]
-            assert result is None,repr(result)
+            assert result is None, repr(result)
             groupcache[groupcounter]['entry'][name] = args
-            previous_context = ('entry',name,groupcounter)
+            previous_context = ('entry', name, groupcounter)
     elif case=='type':
-        typespec,selector,attr,edecl=cracktypespec0(block,m.group('after'))
-        last_name = updatevars(typespec,selector,attr,edecl)
+        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']:
+            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('::')
@@ -909,7 +909,7 @@ def analyzeline(m,case,line):
             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]))
+                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:]
@@ -922,10 +922,10 @@ def analyzeline(m,case,line):
         for e in [x.strip() for x in markoutercomma(ll).split('@,@')]:
             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'))
@@ -942,14 +942,14 @@ def analyzeline(m,case,line):
                                 outmess('analyzeline: missing __user__ module (could be nothing)\n')
                             if k!=groupcache[groupcounter]['name']: # fixes ticket 1693
                                 outmess('analyzeline: appending intent(callback) %s'\
-                                        ' to %s arguments\n' % (k,groupcache[groupcounter]['name']))
+                                        ' to %s arguments\n' % (k, groupcache[groupcounter]['name']))
                                 groupcache[groupcounter]['args'].append(k)
                         else:
                             errmess('analyzeline: intent(callback) %s is ignored' % (k))
                     else:
                         errmess('analyzeline: intent(callback) %s is already'\
                                 ' in argument list' % (k))
-            if case in ['optional','required','public','external','private','intrisic']:
+            if case in ['optional', 'required', 'public', 'external', 'private', 'intrisic']:
                 ap=case
             if 'attrspec' in edecl[k]:
                 edecl[k]['attrspec'].append(ap)
@@ -968,23 +968,23 @@ def analyzeline(m,case,line):
             last_name = k
         groupcache[groupcounter]['vars']=edecl
         if last_name is not None:
-            previous_context = ('variable',last_name,groupcounter)
+            previous_context = ('variable', last_name, groupcounter)
     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)
             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))
-            t = determineexprtype(initexpr,params)
+                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':
                     tt = list(initexpr)
@@ -993,11 +993,11 @@ def analyzeline(m,case,line):
                             initexpr[m.start():m.end()].lower().replace('d', 'e'))
                     initexpr = ''.join(tt)
                 elif t.get('typespec')=='complex':
-                    initexpr = initexpr[1:].lower().replace('d','e').\
-                               replace(',','+1j*(')
+                    initexpr = initexpr[1:].lower().replace('d', 'e').\
+                               replace(',', '+1j*(')
             try:
-                v = eval(initexpr,{},params)
-            except (SyntaxError,NameError,TypeError) as msg:
+                v = eval(initexpr, {}, params)
+            except (SyntaxError, NameError, TypeError) as msg:
                 errmess('analyzeline: Failed to evaluate %r. Ignoring: %s\n'\
                         % (initexpr, msg))
                 continue
@@ -1008,7 +1008,7 @@ def analyzeline(m,case,line):
             last_name = k
         groupcache[groupcounter]['vars']=edecl
         if last_name is not None:
-            previous_context = ('variable',last_name,groupcounter)
+            previous_context = ('variable', last_name, groupcounter)
     elif case=='implicit':
         if m.group('after').strip().lower()=='none':
             groupcache[groupcounter]['implicit']=None
@@ -1021,14 +1021,14 @@ def analyzeline(m,case,line):
                 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)
+                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'))
                 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)
+                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
@@ -1037,13 +1037,13 @@ def analyzeline(m,case,line):
                     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):
+                    for o in range(ord(begc), ord(endc)+1):
                         impl[chr(o)]=decl
             groupcache[groupcounter]['implicit']=impl
     elif case=='data':
@@ -1061,13 +1061,13 @@ def analyzeline(m,case,line):
                 dl = dl.strip()
                 if dl.startswith(','):
                     dl = dl[1:].strip()
-                ll.append([dl,il])
+                ll.append([dl, il])
                 dl=c;il='';f=0
         if f==2:
             dl = dl.strip()
             if dl.startswith(','):
                 dl = dl[1:].strip()
-            ll.append([dl,il])
+            ll.append([dl, il])
         vars={}
         if 'vars' in groupcache[groupcounter]:
             vars=groupcache[groupcounter]['vars']
@@ -1097,13 +1097,13 @@ def analyzeline(m,case,line):
                 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]))
+                    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
         if last_name is not None:
-            previous_context = ('variable',last_name,groupcounter)
+            previous_context = ('variable', last_name, groupcounter)
     elif case=='common':
         line=m.group('after').strip()
         if not line[0]=='/':line='//'+line
@@ -1114,13 +1114,13 @@ def analyzeline(m,case,line):
             if f>=3:
                 bn = bn.strip()
                 if not bn: bn='_BLNK_'
-                cl.append([bn,ol])
+                cl.append([bn, ol])
                 f=f-2;bn='';ol=''
             if f%2: bn=bn+c
             else: ol=ol+c
         bn = bn.strip()
         if not bn: bn='_BLNK_'
-        cl.append([bn,ol])
+        cl.append([bn, ol])
         commonkey={}
         if 'common' in groupcache[groupcounter]:
             commonkey=groupcache[groupcounter]['common']
@@ -1132,9 +1132,9 @@ def analyzeline(m,case,line):
             for i in [x.strip() for x in markoutercomma(c[1]).split('@,@')]:
                 if i: commonkey[c[0]].append(i)
         groupcache[groupcounter]['common']=commonkey
-        previous_context = ('common',bn,groupcounter)
+        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)
+        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()
             if 'use' not in groupcache[groupcounter]:
@@ -1150,7 +1150,7 @@ def analyzeline(m,case,line):
                 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)
+                        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))
@@ -1187,7 +1187,7 @@ def analyzeline(m,case,line):
             print(m.groupdict())
             outmess('analyzeline: No code implemented for line.\n')
 
-def appendmultiline(group, context_name,ml):
+def appendmultiline(group, context_name, ml):
     if 'f2pymultilines' not in group:
         group['f2pymultilines'] = {}
     d = group['f2pymultilines']
@@ -1196,11 +1196,11 @@ def appendmultiline(group, context_name,ml):
     d[context_name].append(ml)
     return
 
-def cracktypespec0(typespec,ll):
+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'
+    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:
@@ -1208,25 +1208,25 @@ def cracktypespec0(typespec,ll):
         return
     d=m1.groupdict()
     for k in list(d.keys()): d[k]=unmarkouterparen(d[k])
-    if typespec in ['complex','integer','logical','real','character','type']:
+    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:]
-    return typespec,selector,attr,ll
+    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):
+    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]
@@ -1238,20 +1238,20 @@ def markinnerspaces(line):
     cc1='"'
     cb=''
     for c in line:
-        if cb=='\\' and c in ['\\','\'','"']:
+        if cb=='\\' and c in ['\\', '\'', '"']:
             l=l+c;
             cb=c
             continue
-        if f==0 and c in ['\'','"']: cc=c; cc1={'\'':'"','"':'\''}[c]
+        if f==0 and c in ['\'', '"']: cc=c; cc1={'\'':'"','"':'\''}[c]
         if c==cc:f=f+1
         elif c==cc:f=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
+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('@,@')]
         l = []
@@ -1268,8 +1268,8 @@ def updatevars(typespec,selector,attrspec,entitydecl):
     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('@_@',' '))
+        for e1 in [x.strip() for x in markoutercomma(removespaces(markinnerspaces(e)), comma=' ').split('@ @')]:
+            if e1: el1.append(e1.replace('@_@', ' '))
     for e in el1:
         m=namepattern.match(e)
         if not m:
@@ -1283,29 +1283,29 @@ def updatevars(typespec,selector,attrspec,entitydecl):
             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))
+                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)
             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]))
+                        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
                 else:
                     errmess('updatevars:%s: attempt to change empty charselector to %r. Ignoring.\n' \
-                            %(ename,charselect))
+                            %(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]))
+                        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))
+                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)
             elif attrspec:
@@ -1322,7 +1322,7 @@ def updatevars(typespec,selector,attrspec,entitydecl):
             m1=lenarraypattern.match(markouterparen(m.group('after')))
             if m1:
                 d1=m1.groupdict()
-                for lk in ['len','array','init']:
+                for lk in ['len', 'array', 'init']:
                     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])
@@ -1334,7 +1334,7 @@ def updatevars(typespec,selector,attrspec,entitydecl):
                     else:
                         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']
                     if 'attrspec' not in edecl or (not edecl['attrspec']):
@@ -1345,11 +1345,11 @@ def updatevars(typespec,selector,attrspec,entitydecl):
                             if dm1[:9]=='dimension' and dm1!=dm:
                                 del edecl['attrspec'][-1]
                                 errmess('updatevars:%s: attempt to change %r to %r. Ignoring.\n' \
-                                        % (ename,dm1,dm))
+                                        % (ename, dm1, dm))
                                 break
 
                 if 'len' in d1:
-                    if typespec in ['complex','integer','logical','real']:
+                    if typespec in ['complex', 'integer', 'logical', 'real']:
                         if ('kindselector' not in edecl) or (not edecl['kindselector']):
                             edecl['kindselector']={}
                         edecl['kindselector']['*']=d1['len']
@@ -1361,7 +1361,7 @@ def updatevars(typespec,selector,attrspec,entitydecl):
                         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']))
+                        outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (ename, edecl['='], d1['init']))
                     else:
                         edecl['=']=d1['init']
             else:
@@ -1375,12 +1375,12 @@ def updatevars(typespec,selector,attrspec,entitydecl):
         last_name = ename
     return last_name
 
-def cracktypespec(typespec,selector):
+def cracktypespec(typespec, selector):
     kindselect=None
     charselect=None
     typename=None
     if selector:
-        if typespec in ['complex','integer','logical','real']:
+        if typespec in ['complex', 'integer', 'logical', 'real']:
             kindselect=kindselector.match(selector)
             if not kindselect:
                 outmess('cracktypespec: no kindselector pattern found for %s\n'%(repr(selector)))
@@ -1390,7 +1390,7 @@ def cracktypespec(typespec,selector):
             del kindselect['kind2']
             for k in list(kindselect.keys()):
                 if not kindselect[k]: del kindselect[k]
-            for k,i in list(kindselect.items()):
+            for k, i in list(kindselect.items()):
                 kindselect[k] = rmbadname1(i)
         elif typespec=='character':
             charselect=charselector.match(selector)
@@ -1403,7 +1403,7 @@ def cracktypespec(typespec,selector):
             if charselect['lenkind']:
                 lenkind=lenkindpattern.match(markoutercomma(charselect['lenkind']))
                 lenkind=lenkind.groupdict()
-                for lk in ['len','kind']:
+                for lk in ['len', 'kind']:
                     if lenkind[lk+'2']:
                         lenkind[lk]=lenkind[lk+'2']
                     charselect[lk]=lenkind[lk]
@@ -1411,15 +1411,15 @@ def cracktypespec(typespec,selector):
             del charselect['lenkind']
             for k in list(charselect.keys()):
                 if not charselect[k]: del charselect[k]
-            for k,i in list(charselect.items()):
+            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)
+            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)))
-    return kindselect,charselect,typename
+    return kindselect, charselect, typename
 ######
 def setattrspec(decl,attr,force=0):
     if not decl:
@@ -1479,7 +1479,7 @@ def getblockname(block,unknown='unknown'):
 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
 
@@ -1498,7 +1498,7 @@ def get_useparameters(block, param_map=None):
     usedict = get_usedict(block)
     if not usedict:
         return param_map
-    for usename,mapping in list(usedict.items()):
+    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')))
@@ -1510,10 +1510,10 @@ def get_useparameters(block, param_map=None):
         # XXX: apply mapping
         if mapping:
             errmess('get_useparameters: mapping for %s not impl.' % (mapping))
-        for k,v in list(params.items()):
+        for k, v in list(params.items()):
             if k in param_map:
                 outmess('get_useparameters: overriding parameter %s with'\
-                        ' value from module %s' % (repr(k),repr(usename)))
+                        ' value from module %s' % (repr(k), repr(usename)))
             param_map[k] = v
 
     return param_map
@@ -1525,11 +1525,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)
@@ -1546,7 +1546,7 @@ 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
 
@@ -1558,13 +1558,13 @@ def postcrack(block,args=None,tab=''):
           function return values
           determine expression types if in argument list
     """
-    global usermodules,onlyfunctions
+    global usermodules, onlyfunctions
     if isinstance(block, list):
         gret=[]
         uret=[]
         for g in block:
             setmesstext(g)
-            g=postcrack(g,tab=tab+'\t')
+            g=postcrack(g, tab=tab+'\t')
             if 'name' in g and '__user__' in g['name']: # sort user routines to appear first
                 uret.append(g)
             else:
@@ -1575,7 +1575,7 @@ def postcrack(block,args=None,tab=''):
         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)
+        outmess('%sBlock: %s\n'%(tab, block['name']), 0)
     blocktype=block['block']
     block=analyzeargs(block)
     block=analyzecommon(block)
@@ -1583,7 +1583,7 @@ def postcrack(block,args=None,tab=''):
     block['sortvars']=sortvarnames(block['vars'])
     if 'args' in block and block['args']:
         args=block['args']
-    block['body']=analyzebody(block,args,tab=tab)
+    block['body']=analyzebody(block, args, tab=tab)
 
     userisdefined=[]
 ##     fromuser = []
@@ -1610,8 +1610,8 @@ def postcrack(block,args=None,tab=''):
             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)
+            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:
@@ -1687,7 +1687,7 @@ def analyzecommon(block):
     for k in list(block['common'].keys()):
         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=[]
                 if m.group('dims'):
@@ -1705,7 +1705,7 @@ def analyzecommon(block):
                 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))
+                errmess('analyzecommon: failed to extract "<name>[(<dims>)]" from "%s" in common /%s/.\n'%(e, k))
             comvars.append(n)
         block['common'][k]=comvars
     if 'commonvars' not in block:
@@ -1715,12 +1715,12 @@ def analyzecommon(block):
     return block
 
 def analyzebody(block,args,tab=''):
-    global usermodules,skipfuncs,onlyfuncs,f90modulevars
+    global usermodules, skipfuncs, onlyfuncs, f90modulevars
     setmesstext(block)
     body=[]
     for b in block['body']:
         b['parent_block'] = block
-        if b['block'] in ['function','subroutine']:
+        if b['block'] in ['function', 'subroutine']:
             if args is not None and b['name'] not in args:
                 continue
             else:
@@ -1732,11 +1732,11 @@ def analyzebody(block,args,tab=''):
             b['saved_interface'] = crack2fortrangen(b, '\n'+' '*6, as_interface=True)
 
         else: as_=args
-        b=postcrack(b,as_,tab=tab+'\t')
+        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':
@@ -1755,113 +1755,113 @@ def buildimplicitrules(block):
                 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']:
+                if block['implicit'][k].get('typespec') not in ['static', 'automatic']:
                     implicitrules[k]=block['implicit'][k]
                 else:
                     attrrules[k]=block['implicit'][k]['typespec']
-    return implicitrules,attrrules
+    return implicitrules, attrrules
 
 def myeval(e,g=None,l=None):
-    r = eval(e,g,l)
-    if type(r) in [type(0),type(0.0)]:
+    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
+getlincoef_re_1 = re.compile(r'\A\b\w+\b\Z', re.I)
+def getlincoef(e, xset): # e = a*x+b ; x in xset
     try:
-        c = int(myeval(e,{},{}))
-        return 0,c,None
+        c = int(myeval(e, {}, {}))
+        return 0, c, None
     except: pass
     if getlincoef_re_1.match(e):
-        return 1,0,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):
             # 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,{},{})
+                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
+                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,{},{})
+                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,{},{})
+                c2 = myeval(ee, {}, {})
                 if (a*0.5+b==c and a*1.5+b==c2):
-                    return a,b,x
+                    return a, b, x
             except: pass
             break
-    return None,None,None
+    return None, None, None
 
 _varname_match = re.compile(r'\A[a-z]\w*\Z').match
 def getarrlen(dl,args,star='*'):
     edl = []
-    try: edl.append(myeval(dl[0],{},{}))
+    try: edl.append(myeval(dl[0], {}, {}))
     except: edl.append(dl[0])
-    try: edl.append(myeval(dl[1],{},{}))
+    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)
+        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
+        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
+    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
         b = d2[1] - d1[1] + 1
-        d1 = (d1[0],0,d1[2])
-        d2 = (d2[0],b,d2[2])
+        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 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 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 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)
+            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:
@@ -1870,11 +1870,11 @@ def getarrlen(dl,args,star='*'):
                 c2 = '(%s)'%c2
             if d2[0]==1: pass
             elif d2[0]==-1: c2='-%s' %c2
-            else: c2='%s*%s'%(d2[0],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 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:
@@ -1883,12 +1883,12 @@ def getarrlen(dl,args,star='*'):
                 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)
+            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)
+            elif b<0: d='%s-%s' % (c1, -b)
+            else: d='%s+%s' % (c1, b)
         else:
             c1 = str(d1[2])
             if c1 not in args:
@@ -1897,8 +1897,8 @@ def getarrlen(dl,args,star='*'):
                 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)
+            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:
@@ -1907,25 +1907,25 @@ def getarrlen(dl,args,star='*'):
                 c2 = '(%s)'%c2
             if d2[0]==1: pass
             elif d2[0]==-1: c2='-%s' %c2
-            else: c2='%s*%s'%(d2[0],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
+            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)
+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',[])
+        words = vars[name].get('depend', [])
 
         if '=' in vars[name] and not isstring(vars[name]):
             for word in word_pattern.findall(vars[name]['=']):
                 if word not in words and word in vars:
                     words.append(word)
         for word in words[:]:
-            for w in deps.get(word,[]) \
+            for w in deps.get(word, []) \
                     or _get_depend_dict(word, vars, deps):
                 if w not in words:
                     words.append(w)
@@ -1999,9 +1999,9 @@ def _selected_real_kind_func(p, r=0, radix=0):
 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),
+    for name, func in [('kind', _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
@@ -2009,22 +2009,22 @@ def get_parameters(vars, global_params={}):
     for n in get_sorted_names(vars):
         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)
+    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)
     for n in param_names:
         if '=' in vars[n]:
             v = vars[n]['=']
             if islogical(vars[n]):
                 v = v.lower()
                 for repl in [
-                    ('.false.','False'),
-                    ('.true.','True'),
+                    ('.false.', 'False'),
+                    ('.true.', 'True'),
                     #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)
+            v = kind_re.sub(r'kind("\1")', v)
+            v = selected_int_kind_re.sub(r'selected_int_kind(\1)', v)
             if isinteger(vars[n]) and not selected_kind_re.match(v):
                 v = v.split('_')[0]
             if isdouble(vars[n]):
@@ -2037,11 +2037,11 @@ def get_parameters(vars, global_params={}):
                 if v[0]=='(' and v[-1]==')':
                     l = markoutercomma(v[1:-1]).split('@,@')
             try:
-                params[n] = eval(v,g_params,params)
+                params[n] = eval(v, g_params, params)
             except Exception as msg:
                 params[n] = v
                 #print params
-                outmess('get_parameters: got "%s" on %s\n' % (msg,repr(v)))
+                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()
@@ -2052,30 +2052,30 @@ def get_parameters(vars, global_params={}):
             outmess('get_parameters:parameter %s does not have value?!\n'%(repr(n)))
     return params
 
-def _eval_length(length,params):
-    if length in ['(:)','(*)','*']:
+def _eval_length(length, params):
+    if length in ['(:)', '(*)', '*']:
         return '(*)'
-    return _eval_scalar(length,params)
+    return _eval_scalar(length, params)
 
 _is_kind_number = re.compile(r'\d+_').match
 
-def _eval_scalar(value,params):
+def _eval_scalar(value, params):
     if _is_kind_number(value):
         value = value.split('_')[0]
     try:
-        value = str(eval(value,{},params))
+        value = str(eval(value, {}, params))
     except (NameError, SyntaxError):
         return value
     except Exception as msg:
         errmess('"%s" in evaluating %r '\
                 '(available names: %s)\n' \
-                % (msg,value,list(params.keys())))
+                % (msg, value, list(params.keys())))
     return value
 
 def analyzevars(block):
     global f90modulevars
     setmesstext(block)
-    implicitrules,attrrules=buildimplicitrules(block)
+    implicitrules, attrrules=buildimplicitrules(block)
     vars=copy.copy(block['vars'])
     if block['block']=='function' and block['name'] not in vars:
         vars[block['name']]={}
@@ -2084,9 +2084,9 @@ def analyzevars(block):
         if 'attrspec' in block['vars']['']:
             gen=block['vars']['']['attrspec']
             for n in list(vars.keys()):
-                for k in ['public','private']:
+                for k in ['public', 'private']:
                     if k in gen:
-                        vars[n]=setattrspec(vars[n],k)
+                        vars[n]=setattrspec(vars[n], k)
     svars=[]
     args = block['args']
     for a in args:
@@ -2109,10 +2109,10 @@ 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:
@@ -2124,15 +2124,15 @@ def analyzevars(block):
                             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']:
                 l = vars[n]['charselector']['len']
                 try:
-                    l = str(eval(l,{},params))
+                    l = str(eval(l, {}, params))
                 except:
                     pass
                 vars[n]['charselector']['len'] = l
@@ -2141,7 +2141,7 @@ def analyzevars(block):
             if 'kind' in vars[n]['kindselector']:
                 l = vars[n]['kindselector']['kind']
                 try:
-                    l = str(eval(l,{},params))
+                    l = str(eval(l, {}, params))
                 except:
                     pass
                 vars[n]['kindselector']['kind'] = l
@@ -2151,14 +2151,14 @@ def analyzevars(block):
             attr=vars[n]['attrspec']
             attr.reverse()
             vars[n]['attrspec']=[]
-            dim,intent,depend,check,note=None,None,None,None,None
+            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)
+                else: vars[n]=setattrspec(vars[n], a)
                 if intent:
                     if 'intent' not in vars[n]:
                         vars[n]['intent']=[]
@@ -2167,8 +2167,8 @@ def analyzevars(block):
                             vars[n]['intent'].append(c)
                     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]
                     else:
@@ -2197,23 +2197,23 @@ def analyzevars(block):
                     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:
                         dl = [star]
                     else:
-                        dl=markoutercomma(d,':').split('@:@')
+                        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)==1 and not dl[0]==star: dl = ['1', dl[0]]
                     if len(dl)==2:
-                        d,v,di = getarrlen(dl,list(block['vars'].keys()))
+                        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 v: savelindims[d] = v, di
                     vars[n]['dimension'].append(d)
         if 'dimension' in vars[n]:
             if isintent_c(vars[n]):
@@ -2226,9 +2226,9 @@ def analyzevars(block):
                     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,
+                                %(d, n,
                                   ','.join(vars[n]['dimension']),
-                                  n,','.join(vars[n]['dimension']+[d])))
+                                  n, ','.join(vars[n]['dimension']+[d])))
                         vars[n]['dimension'].append(d)
                         del vars[n]['charselector']
                         if 'intent' not in vars[n]:
@@ -2253,14 +2253,14 @@ def analyzevars(block):
                     #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]:
@@ -2275,22 +2275,22 @@ def analyzevars(block):
                        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]['=']='%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)]
+                                                  %(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']
                         if ('optional' not in vars[d]['attrspec']) and\
                            ('required' not in vars[d]['attrspec']):
                             vars[d]['attrspec'].append('optional')
-                    elif d not in ['*',':']:
+                    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))
@@ -2325,11 +2325,11 @@ def analyzevars(block):
                 vars[n]['attrspec'].append('optional')
             if 'depend' not in vars[n]:
                 vars[n]['depend']=[]
-                for v,m in list(dep_matches.items()):
+                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 isscalar(vars[n]):
-                vars[n]['='] = _eval_scalar(vars[n]['='],params)
+                vars[n]['='] = _eval_scalar(vars[n]['='], params)
 
     for n in list(vars.keys()):
         if n==block['name']: # n is block name
@@ -2337,38 +2337,38 @@ def analyzevars(block):
                 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','')
+                    pr1=pr.replace('pure', '')
                     ispure=(not pr==pr1)
-                    pr=pr1.replace('recursive','')
+                    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)
+                        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')
+                        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']))
-    if not block['block'] in ['module','pythonmodule','python module','block data']:
+    if not block['block'] in ['module', 'pythonmodule', 'python module', 'block data']:
         if 'commonvars' in block:
             neededvars=copy.copy(block['args']+block['commonvars'])
         else:
             neededvars=copy.copy(block['args'])
         for n in list(vars.keys()):
-            if l_or(isintent_callback,isintent_aux)(vars[n]):
+            if l_or(isintent_callback, isintent_aux)(vars[n]):
                 neededvars.append(n)
         if 'entry' in block:
             neededvars.extend(list(block['entry'].keys()))
@@ -2381,7 +2381,7 @@ def analyzevars(block):
                 neededvars.append(block['result'])
             else:
                 neededvars.append(block['name'])
-        if block['block'] in ['subroutine','function']:
+        if block['block'] in ['subroutine', 'function']:
             name = block['name']
             if name in vars and 'intent' in vars[name]:
                 block['intent'] = vars[name]['intent']
@@ -2392,13 +2392,13 @@ def analyzevars(block):
                 del vars[n]
     return vars
 
-analyzeargs_re_1 = re.compile(r'\A[a-z]+[\w$]*\Z',re.I)
+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)
+        implicitrules, attrrules=buildimplicitrules(block)
+        at=determineexprtype(a, block['vars'], implicitrules)
         na='e_'
         for c in a:
             c = c.lower()
@@ -2423,12 +2423,12 @@ def expr2name(a, block, args=[]):
             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]=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=[]
@@ -2437,7 +2437,7 @@ def analyzeargs(block):
         args.append(a)
     block['args']=args
     if 'entry' in block:
-        for k,args1 in list(block['entry'].items()):
+        for k, args1 in list(block['entry'].items()):
             for a in args1:
                 if a not in block['vars']:
                     block['vars'][a]={}
@@ -2452,11 +2452,11 @@ def analyzeargs(block):
         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_4 = re.compile(r'\A\(.*\)\Z',re.I)
-determineexprtype_re_5 = re.compile(r'\A(?P<name>\w+)\s*\(.*?\)\s*\Z',re.I)
+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_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'}
@@ -2484,18 +2484,18 @@ def determineexprtype(expr,vars,rules={}):
         if 'name' in m.groupdict() and m.group('name'):
             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 op in ['+', '-', '*', '/']:
+        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=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)
+            t=determineexprtype(m.group('name'), vars, rules)
             if t and 'attrspec' in t:
                 del t['attrspec']
             if not t:
@@ -2514,12 +2514,12 @@ def crack2fortrangen(block,tab='\n', as_interface=False):
     ret=''
     if isinstance(block, list):
         for g in block:
-            if g and g['block'] in ['function','subroutine']:
+            if g and g['block'] in ['function', 'subroutine']:
                 if g['name'] in skipfuncs:
                     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=''
@@ -2540,20 +2540,20 @@ def crack2fortrangen(block,tab='\n', as_interface=False):
     f2pyenhancements = ''
     if 'f2pyenhancements' in block:
         for k in list(block['f2pyenhancements'].keys()):
-            f2pyenhancements = '%s%s%s %s'%(f2pyenhancements,tab+tabchar,k,block['f2pyenhancements'][k])
-    intent_lst = block.get('intent',[])[:]
+            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,
-                            ','.join(intent_lst),name)
+                           (f2pyenhancements, tab+tabchar,
+                            ','.join(intent_lst), name)
     use=''
     if 'use' in block:
-        use=use2fortran(block['use'],tab+tabchar)
+        use=use2fortran(block['use'], tab+tabchar)
     common=''
     if 'common' in block:
-        common=common2fortran(block['common'],tab+tabchar)
+        common=common2fortran(block['common'], tab+tabchar)
     if name=='unknown_interface': name=''
     result=''
     if 'result' in block:
@@ -2562,35 +2562,35 @@ def crack2fortrangen(block,tab='\n', as_interface=False):
             argsl.append(block['result'])
     #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)
+    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']
     if 'entry' in block:
         entry_stmts = ''
-        for k,i in list(block['entry'].items()):
+        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=''
     for k in list(common.keys()):
         if k=='_BLNK_':
-            ret='%s%scommon %s'%(ret,tab,','.join(common[k]))
+            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=''
     for m in list(use.keys()):
-        ret='%s%suse %s,'%(ret,tab,m)
+        ret='%s%suse %s,'%(ret, tab, m)
         if use[m]=={}:
             if ret and ret[-1]==',': ret=ret[:-1]
             continue
@@ -2600,9 +2600,9 @@ def use2fortran(use,tab=''):
             c=' '
             for k in list(use[m]['map'].keys()):
                 if k==use[m]['map'][k]:
-                    ret='%s%s%s'%(ret,c,k); c=','
+                    ret='%s%s%s'%(ret, c, k); c=','
                 else:
-                    ret='%s%s%s=>%s'%(ret,c,k,use[m]['map'][k]); c=','
+                    ret='%s%s%s=>%s'%(ret, c, k, use[m]['map'][k]); c=','
         if ret and ret[-1]==',': ret=ret[:-1]
     return ret
 
@@ -2647,13 +2647,13 @@ 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
@@ -2671,33 +2671,33 @@ def vars2fortran(block,vars,args,tab='', as_interface=False):
         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)
             continue
         vardef=vars[a]['typespec']
         if vardef=='type' and 'typename' in vars[a]:
-            vardef='%s(%s)'%(vardef,vars[a]['typename'])
+            vardef='%s(%s)'%(vardef, vars[a]['typename'])
         selector={}
         if 'kindselector' in vars[a]:
             selector=vars[a]['kindselector']
         elif 'charselector' in vars[a]:
             selector=vars[a]['charselector']
         if '*' in selector:
-            if selector['*'] in ['*',':']:
-                vardef='%s*(%s)'%(vardef,selector['*'])
+            if selector['*'] in ['*', ':']:
+                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)
             elif 'kind' in selector:
-                vardef='%s(kind=%s)'%(vardef,selector['kind'])
+                vardef='%s(kind=%s)'%(vardef, selector['kind'])
         c=' '
         if 'attrspec' in vars[a]:
             attr=[]
@@ -2705,47 +2705,47 @@ def vars2fortran(block,vars,args,tab='', as_interface=False):
                 if l not in ['external']:
                     attr.append(l)
             if attr:
-                vardef='%s, %s'%(vardef,','.join(attr))
+                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']))
+            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))
+                vardef='%s%sintent(%s)'%(vardef, c, ','.join(lst))
             c=','
         if 'check' in vars[a]:
-            vardef='%s%scheck(%s)'%(vardef,c,','.join(vars[a]['check']))
+            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']))
+            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']:
+            if vars[a]['typespec'] in ['complex', 'double complex']:
                 try:
                     v = eval(v)
-                    v = '(%s,%s)' % (v.real,v.imag)
+                    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)
+    outmess('Reading fortran codes...\n', 0)
+    readfortrancode(files, crackline)
+    outmess('Post-processing...\n', 0)
     usermodules=[]
     postlist=postcrack(grouplist[0])
-    outmess('Post-processing (stage 2)...\n',0)
+    outmess('Post-processing (stage 2)...\n', 0)
     postlist=postcrack2(postlist)
     return usermodules+postlist
 
@@ -2778,7 +2778,7 @@ if __name__ == "__main__":
             quiet=0
         elif l=='-fix':
             if strictf77:
-                outmess('Use option -f90 before -fix if Fortran 90 code is in fix form.\n',0)
+                outmess('Use option -f90 before -fix if Fortran 90 code is in fix form.\n', 0)
             skipemptyends=1
             sourcecodeform='fix'
         elif l=='-skipemptyends':
@@ -2820,13 +2820,13 @@ if __name__ == "__main__":
   that should not need one (expect if you are scanning F90 code
   for non module blocks but then you should use flag -skipemptyends
   and also be sure that the files do not contain programs without program statement).
-""",0)
+""", 0)
 
-    postlist=crackfortran(files,funcs)
+    postlist=crackfortran(files, funcs)
     if pyffilename:
-        outmess('Writing fortran code to file %s\n'%repr(pyffilename),0)
+        outmess('Writing fortran code to file %s\n'%repr(pyffilename), 0)
         pyf=crack2fortran(postlist)
-        f=open(pyffilename,'w')
+        f=open(pyffilename, 'w')
         f.write(pyf)
         f.close()
     if showblocklist: