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

Add Python libs and headers

+#!/usr/bin/env python
+"""
+crackfortran --- read fortran (77,90) code and extract declaration information.
+
+Copyright 1999-2004 Pearu Peterson all rights reserved,
+Pearu Peterson <[e-mail]>
+Permission to use, modify, and distribute this software is given under the
+terms of the NumPy License.
+
+NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
+$Date: 2005/09/27 07:13:49 $
+Pearu Peterson
+
+
+Usage of crackfortran:
+======================
+Command line keys: -quiet,-verbose,-fix,-f77,-f90,-show,-h <pyffilename>
+                   -m <module name for f77 routines>,--ignore-contains
+Functions: crackfortran, crack2fortran
+The following Fortran statements/constructions are supported
+(or will be if needed):
+   block data,byte,call,character,common,complex,contains,data,
+   dimension,double complex,double precision,end,external,function,
+   implicit,integer,intent,interface,intrinsic,
+   logical,module,optional,parameter,private,public,
+   program,real,(sequence?),subroutine,type,use,virtual,
+   include,pythonmodule
+Note: 'virtual' is mapped to 'dimension'.
+Note: 'implicit integer (z) static (z)' is 'implicit static (z)' (this is minor bug).
+Note: code after 'contains' will be ignored until its scope ends.
+Note: 'common' statement is extended: dimensions are moved to variable definitions
+Note: f2py directive: <commentchar>f2py<line> is read as <line>
+Note: pythonmodule is introduced to represent Python module
+
+Usage:
+  `postlist=crackfortran(files,funcs)`
+  `postlist` contains declaration information read from the list of files `files`.
+  `crack2fortran(postlist)` returns a fortran code to be saved to pyf-file
+
+  `postlist` has the following structure:
+ *** it is a list of dictionaries containing `blocks':
+     B = {'block','body','vars','parent_block'[,'name','prefix','args','result',
+          'implicit','externals','interfaced','common','sortvars',
+          'commonvars','note']}
+     B['block'] = 'interface' | 'function' | 'subroutine' | 'module' |
+                  'program' | 'block data' | 'type' | 'pythonmodule'
+     B['body'] --- list containing `subblocks' with the same structure as `blocks'
+     B['parent_block'] --- dictionary of a parent block:
+                             C['body'][<index>]['parent_block'] is C
+     B['vars'] --- dictionary of variable definitions
+     B['sortvars'] --- dictionary of variable definitions sorted by dependence (independent first)
+     B['name'] --- name of the block (not if B['block']=='interface')
+     B['prefix'] --- prefix string (only if B['block']=='function')
+     B['args'] --- list of argument names if B['block']== 'function' | 'subroutine'
+     B['result'] --- name of the return value (only if B['block']=='function')
+     B['implicit'] --- dictionary {'a':<variable definition>,'b':...} | None
+     B['externals'] --- list of variables being external
+     B['interfaced'] --- list of variables being external and defined
+     B['common'] --- dictionary of common blocks (list of objects)
+     B['commonvars'] --- list of variables used in common blocks (dimensions are moved to variable definitions)
+     B['from'] --- string showing the 'parents' of the current block
+     B['use'] --- dictionary of modules used in current block:
+         {<modulename>:{['only':<0|1>],['map':{<local_name1>:<use_name1>,...}]}}
+     B['note'] --- list of LaTeX comments on the block
+     B['f2pyenhancements'] --- optional dictionary
+          {'threadsafe':'','fortranname':<name>,
+           'callstatement':<C-expr>|<multi-line block>,
+           'callprotoargument':<C-expr-list>,
+           'usercode':<multi-line block>|<list of multi-line blocks>,
+           'pymethoddef:<multi-line block>'
+           }
+     B['entry'] --- dictionary {entryname:argslist,..}
+     B['varnames'] --- list of variable names given in the order of reading the
+                       Fortran code, useful for derived types.
+     B['saved_interface'] --- a string of scanned routine signature, defines explicit interface
+ *** Variable definition is a dictionary
+     D = B['vars'][<variable name>] =
+     {'typespec'[,'attrspec','kindselector','charselector','=','typename']}
+     D['typespec'] = 'byte' | 'character' | 'complex' | 'double complex' |
+                     'double precision' | 'integer' | 'logical' | 'real' | 'type'
+     D['attrspec'] --- list of attributes (e.g. 'dimension(<arrayspec>)',
+                       'external','intent(in|out|inout|hide|c|callback|cache|aligned4|aligned8|aligned16)',
+                       'optional','required', etc)
+     K = D['kindselector'] = {['*','kind']} (only if D['typespec'] =
+                         'complex' | 'integer' | 'logical' | 'real' )
+     C = D['charselector'] = {['*','len','kind']}
+                             (only if D['typespec']=='character')
+     D['='] --- initialization expression string
+     D['typename'] --- name of the type if D['typespec']=='type'
+     D['dimension'] --- list of dimension bounds
+     D['intent'] --- list of intent specifications
+     D['depend'] --- list of variable names on which current variable depends on
+     D['check'] --- list of C-expressions; if C-expr returns zero, exception is raised
+     D['note'] --- list of LaTeX comments on the variable
+ *** Meaning of kind/char selectors (few examples):
+     D['typespec>']*K['*']
+     D['typespec'](kind=K['kind'])
+     character*C['*']
+     character(len=C['len'],kind=C['kind'])
+     (see also fortran type declaration statement formats below)
+
+Fortran 90 type declaration statement format (F77 is subset of F90)
+====================================================================
+(Main source: IBM XL Fortran 5.1 Language Reference Manual)
+type declaration = <typespec> [[<attrspec>]::] <entitydecl>
+<typespec> = byte                          |
+             character[<charselector>]     |
+             complex[<kindselector>]       |
+             double complex                |
+             double precision              |
+             integer[<kindselector>]       |
+             logical[<kindselector>]       |
+             real[<kindselector>]          |
+             type(<typename>)
+<charselector> = * <charlen>               |
+             ([len=]<len>[,[kind=]<kind>]) |
+             (kind=<kind>[,len=<len>])
+<kindselector> = * <intlen>                |
+             ([kind=]<kind>)
+<attrspec> = comma separated list of attributes.
+             Only the following attributes are used in
+             building up the interface:
+                external
+                (parameter --- affects '=' key)
+                optional
+                intent
+             Other attributes are ignored.
+<intentspec> = in | out | inout
+<arrayspec> = comma separated list of dimension bounds.
+<entitydecl> = <name> [[*<charlen>][(<arrayspec>)] | [(<arrayspec>)]*<charlen>]
+                      [/<init_expr>/ | =<init_expr>] [,<entitydecl>]
+
+In addition, the following attributes are used: check,depend,note
+
+TODO:
+    * Apply 'parameter' attribute (e.g. 'integer parameter :: i=2' 'real x(i)'
+                                   -> 'real x(2)')
+    The above may be solved by creating appropriate preprocessor program, for example.
+
+"""
+from __future__ import division, absolute_import, print_function
+
+import sys
+import string
+import fileinput
+import re
+import pprint
+import os
+import copy
+import platform
+
+from . import __version__
+from .auxfuncs import *
+
+f2py_version = __version__.version
+
+# Global flags:
+strictf77=1          # Ignore `!' comments unless line[0]=='!'
+sourcecodeform='fix' # 'fix','free'
+quiet=0              # Be verbose if 0 (Obsolete: not used any more)
+verbose=1            # Be quiet if 0, extra verbose if > 1.
+tabchar=4*' '
+pyffilename=''
+f77modulename=''
+skipemptyends=0      # for old F77 programs without 'program' statement
+ignorecontains=1
+dolowercase=1
+debug=[]
+
+# Global variables
+groupcounter=0
+grouplist={groupcounter:[]}
+neededmodule=-1
+expectbegin=1
+skipblocksuntil=-1
+usermodules=[]
+f90modulevars={}
+gotnextfile=1
+filepositiontext=''
+currentfilename=''
+skipfunctions=[]
+skipfuncs=[]
+onlyfuncs=[]
+include_paths=[]
+previous_context = None
+
+
+def reset_global_f2py_vars():
+    global groupcounter, grouplist, neededmodule, expectbegin, \
+        skipblocksuntil, usermodules, f90modulevars, gotnextfile, \
+        filepositiontext, currentfilename, skipfunctions, skipfuncs, \
+        onlyfuncs, include_paths, previous_context, \
+        strictf77, sourcecodeform, quiet, verbose, tabchar, pyffilename, \
+        f77modulename, skipemptyends, ignorecontains, dolowercase, debug
+
+    # flags
+    strictf77 = 1
+    sourcecodeform = 'fix'
+    quiet = 0
+    verbose = 1
+    tabchar = 4*' '
+    pyffilename = ''
+    f77modulename = ''
+    skipemptyends = 0
+    ignorecontains = 1
+    dolowercase = 1
+    debug = []
+    # variables
+    groupcounter = 0
+    grouplist = {groupcounter:[]}
+    neededmodule =-1
+    expectbegin = 1
+    skipblocksuntil = -1
+    usermodules = []
+    f90modulevars = {}
+    gotnextfile = 1
+    filepositiontext = ''
+    currentfilename = ''
+    skipfunctions = []
+    skipfuncs = []
+    onlyfuncs = []
+    include_paths = []
+    previous_context = None
+
+
+###### Some helper functions
+def show(o,f=0):pprint.pprint(o)
+errmess=sys.stderr.write
+def outmess(line,flag=1):
+    global filepositiontext
+    if not verbose: return
+    if not quiet:
+        if flag:sys.stdout.write(filepositiontext)
+        sys.stdout.write(line)
+re._MAXCACHE=50
+defaultimplicitrules={}
+for c in "abcdefghopqrstuvwxyz$_": defaultimplicitrules[c]={'typespec':'real'}
+for c in "ijklmn": defaultimplicitrules[c]={'typespec':'integer'}
+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',
+          'max', 'min',
+          '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]))
+        return badnames[name]
+    return name
+
+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]))
+        return invbadnames[name]
+    return name
+
+def undo_rmbadname(names): return [undo_rmbadname1(_m) for _m in names]
+
+def getextension(name):
+    i=name.rfind('.')
+    if i==-1: return ''
+    if '\\' in name[i:]: return ''
+    if '/' in name[i:]: return ''
+    return name[i+1:]
+
+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')
+    line = f.readline()
+    n = 15 # the number of non-comment lines to scan for hints
+    if _has_f_header(line):
+        n = 0
+    elif _has_f90_header(line):
+        n = 0
+        result = 1
+    while n>0 and line:
+        if line[0]!='!' and line.strip():
+            n -= 1
+            if (line[0]!='\t' and _free_f90_start(line[:5])) or line[-2:-1]=='&':
+                result = 1
+                break
+        line = f.readline()
+    f.close()
+    return result
+
+
+####### Read fortran (77,90) code
+def readfortrancode(ffile,dowithline=show,istop=1):
+    """
+    Read fortran codes from files and
+     1) Get rid of comments, line continuations, and empty lines; lower cases.
+     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
+    if not istop:
+        saveglobals=gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
+           beginpattern, quiet, verbose, dolowercase
+    if ffile==[]: return
+    localdolowercase = dolowercase
+    cont=0
+    finalline=''
+    ll=''
+    commentline=re.compile(r'(?P<line>([^"]*["][^"]*["][^"!]*|[^\']*\'[^\']*\'[^\'!]*|[^!\'"]*))!{1}(?P<rest>.*)')
+    includeline=re.compile(r'\s*include\s*(\'|")(?P<name>[^\'"]*)(\'|")', re.I)
+    cont1=re.compile(r'(?P<line>.*)&\s*\Z')
+    cont2=re.compile(r'(\s*&|)(?P<line>.*)')
+    mline_mark = re.compile(r".*?'''")
+    if istop: dowithline('', -1)
+    ll, l1='', ''
+    spacedigits=[' '] + [str(_m) for _m in range(10)]
+    filepositiontext=''
+    fin=fileinput.FileInput(ffile)
+    while True:
+        l=fin.readline()
+        if not l: break
+        if fin.isfirstline():
+            filepositiontext=''
+            currentfilename=fin.filename()
+            gotnextfile=1
+            l1=l
+            strictf77=0
+            sourcecodeform='fix'
+            ext = os.path.splitext(currentfilename)[1]
+            if is_f_file(currentfilename) and \
+                   not (_has_f90_header(l) or _has_fix_header(l)):
+                strictf77=1
+            elif is_free_format(currentfilename) and not _has_fix_header(l):
+                sourcecodeform='free'
+            if strictf77: beginpattern=beginpattern77
+            else: beginpattern=beginpattern90
+            outmess('\tReading file %s (format:%s%s)\n'\
+                    %(repr(currentfilename), sourcecodeform,
+                      strictf77 and ',strict' or ''))
+
+        l=l.expandtabs().replace('\xa0', ' ')
+        while not l=='':                       # Get rid of newline characters
+            if l[-1] not in "\n\r\f": break
+            l=l[:-1]
+        if not strictf77:
+            r=commentline.match(l)
+            if r:
+                l=r.group('line')+' ' # Strip comments starting with `!'
+                rl=r.group('rest')
+                if rl[:4].lower()=='f2py': # f2py directive
+                    l = l + 4*' '
+                    r=commentline.match(rl[4:])
+                    if r: l=l+r.group('line')
+                    else: l = l + rl[4:]
+        if l.strip()=='': # Skip empty line
+            cont=0
+            continue
+        if sourcecodeform=='fix':
+            if l[0] in ['*', 'c', '!', 'C', '#']:
+                if l[1:5].lower()=='f2py': # f2py directive
+                    l='     '+l[5:]
+                else: # Skip comment line
+                    cont=0
+                    continue
+            elif strictf77:
+                if len(l)>72: l=l[:72]
+            if not (l[0] in spacedigits):
+                raise Exception('readfortrancode: Found non-(space,digit) char '
+                                'in the first column.\n\tAre you sure that '
+                                'this code is in fix form?\n\tline=%s' % repr(l))
+
+            if (not cont or strictf77) and (len(l)>5 and not l[5]==' '):
+                # Continuation of a previous line
+                ll=ll+l[6:]
+                finalline=''
+                origfinalline=''
+            else:
+                if not strictf77:
+                    # F90 continuation
+                    r=cont1.match(l)
+                    if r: l=r.group('line') # Continuation follows ..
+                    if cont:
+                        ll=ll+cont2.match(l).group('line')
+                        finalline=''
+                        origfinalline=''
+                    else:
+                        l='     '+l[5:] # clean up line beginning from possible digits.
+                        if localdolowercase: finalline=ll.lower()
+                        else: finalline=ll
+                        origfinalline=ll
+                        ll=l
+                    cont=(r is not None)
+                else:
+                    l='     '+l[5:] # clean up line beginning from possible digits.
+                    if localdolowercase: finalline=ll.lower()
+                    else: finalline=ll
+                    origfinalline =ll
+                    ll=l
+
+        elif sourcecodeform=='free':
+            if not cont and ext=='.pyf' and mline_mark.match(l):
+                l = l + '\n'
+                while True:
+                    lc = fin.readline()
+                    if not lc:
+                        errmess('Unexpected end of file when reading multiline\n')
+                        break
+                    l = l + lc
+                    if mline_mark.match(lc):
+                        break
+                l = l.rstrip()
+            r=cont1.match(l)
+            if r: l=r.group('line') # Continuation follows ..
+            if cont:
+                ll=ll+cont2.match(l).group('line')
+                finalline=''
+                origfinalline=''
+            else:
+                if localdolowercase: finalline=ll.lower()
+                else: finalline=ll
+                origfinalline =ll
+                ll=l
+            cont=(r is not None)
+        else:
+            raise ValueError("Flag sourcecodeform must be either 'fix' or 'free': %s"%repr(sourcecodeform))
+        filepositiontext='Line #%d in %s:"%s"\n\t' % (fin.filelineno()-1, currentfilename, l1)
+        m=includeline.match(origfinalline)
+        if m:
+            fn=m.group('name')
+            if os.path.isfile(fn):
+                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)
+                    if os.path.isfile(fn1):
+                        foundfile = 1
+                        readfortrancode(fn1, dowithline=dowithline, istop=0)
+                        break
+                if not foundfile:
+                    outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n'%(repr(fn), os.pathsep.join(include_dirs)))
+        else:
+            dowithline(finalline)
+        l1=ll
+    if localdolowercase:
+        finalline=ll.lower()
+    else: finalline=ll
+    origfinalline = ll
+    filepositiontext='Line #%d in %s:"%s"\n\t' % (fin.filelineno()-1, currentfilename, l1)
+    m=includeline.match(origfinalline)
+    if m:
+        fn=m.group('name')
+        if os.path.isfile(fn):
+            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)
+                if os.path.isfile(fn1):
+                    foundfile = 1
+                    readfortrancode(fn1, dowithline=dowithline, istop=0)
+                    break
+            if not foundfile:
+                outmess('readfortrancode: could not find include file %s in %s. Ignoring.\n'%(repr(fn), os.pathsep.join(include_dirs)))
+    else:
+        dowithline(finalline)
+    filepositiontext=''
+    fin.close()
+    if istop: dowithline('', 1)
+    else:
+        gotnextfile, filepositiontext, currentfilename, sourcecodeform, strictf77,\
+           beginpattern, quiet, verbose, dolowercase=saveglobals
+
+########### Crack line
+beforethisafter=r'\s*(?P<before>%s(?=\s*(\b(%s)\b)))'+ \
+                          r'\s*(?P<this>(\b(%s)\b))'+ \
+                          r'\s*(?P<after>%s)\s*\Z'
+##
+fortrantypes='character|logical|integer|real|complex|double\s*(precision\s*(complex|)|complex)|type(?=\s*\([\w\s,=(*)]*\))|byte'
+typespattern=re.compile(beforethisafter%('', fortrantypes, fortrantypes, '.*'), re.I), 'type'
+typespattern4implicit=re.compile(beforethisafter%('', fortrantypes+'|static|automatic|undefined', fortrantypes+'|static|automatic|undefined', '.*'), re.I)
+#
+functionpattern=re.compile(beforethisafter%('([a-z]+[\w\s(=*+-/)]*?|)', 'function', 'function', '.*'), re.I), 'begin'
+subroutinepattern=re.compile(beforethisafter%('[a-z\s]*?', 'subroutine', 'subroutine', '.*'), re.I), 'begin'
+#modulepattern=re.compile(beforethisafter%('[a-z\s]*?','module','module','.*'),re.I),'begin'
+#
+groupbegins77=r'program|block\s*data'
+beginpattern77=re.compile(beforethisafter%('', groupbegins77, groupbegins77, '.*'), re.I), 'begin'
+groupbegins90=groupbegins77+r'|module(?!\s*procedure)|python\s*module|interface|type(?!\s*\()'
+beginpattern90=re.compile(beforethisafter%('', groupbegins90, groupbegins90, '.*'), re.I), 'begin'
+groupends=r'end|endprogram|endblockdata|endmodule|endpythonmodule|endinterface'
+endpattern=re.compile(beforethisafter%('', groupends, groupends, '[\w\s]*'), re.I), 'end'
+#endifs='end\s*(if|do|where|select|while|forall)'
+endifs='(end\s*(if|do|where|select|while|forall))|(module\s*procedure)'
+endifpattern=re.compile(beforethisafter%('[\w]*?', endifs, endifs, '[\w\s]*'), re.I), 'endif'
+#
+implicitpattern=re.compile(beforethisafter%('', 'implicit', 'implicit', '.*'), re.I), 'implicit'
+dimensionpattern=re.compile(beforethisafter%('', 'dimension|virtual', 'dimension|virtual', '.*'), re.I), 'dimension'
+externalpattern=re.compile(beforethisafter%('', 'external', 'external', '.*'), re.I), 'external'
+optionalpattern=re.compile(beforethisafter%('', 'optional', 'optional', '.*'), re.I), 'optional'
+requiredpattern=re.compile(beforethisafter%('', 'required', 'required', '.*'), re.I), 'required'
+publicpattern=re.compile(beforethisafter%('', 'public', 'public', '.*'), re.I), 'public'
+privatepattern=re.compile(beforethisafter%('', 'private', 'private', '.*'), re.I), 'private'
+intrisicpattern=re.compile(beforethisafter%('', 'intrisic', 'intrisic', '.*'), re.I), 'intrisic'
+intentpattern=re.compile(beforethisafter%('', 'intent|depend|note|check', 'intent|depend|note|check', '\s*\(.*?\).*'), re.I), 'intent'
+parameterpattern=re.compile(beforethisafter%('', 'parameter', 'parameter', '\s*\(.*'), re.I), 'parameter'
+datapattern=re.compile(beforethisafter%('', 'data', 'data', '.*'), re.I), 'data'
+callpattern=re.compile(beforethisafter%('', 'call', 'call', '.*'), re.I), 'call'
+entrypattern=re.compile(beforethisafter%('', 'entry', 'entry', '.*'), re.I), 'entry'
+callfunpattern=re.compile(beforethisafter%('', 'callfun', 'callfun', '.*'), re.I), 'callfun'
+commonpattern=re.compile(beforethisafter%('', 'common', 'common', '.*'), re.I), 'common'
+usepattern=re.compile(beforethisafter%('', 'use', 'use', '.*'), re.I), 'use'
+containspattern=re.compile(beforethisafter%('', 'contains', 'contains', ''), re.I), 'contains'
+formatpattern=re.compile(beforethisafter%('', 'format', 'format', '.*'), re.I), 'format'
+## Non-fortran and f2py-specific statements
+f2pyenhancementspattern=re.compile(beforethisafter%('', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', '.*'), re.I|re.S), 'f2pyenhancements'
+multilinepattern = re.compile(r"\s*(?P<before>''')(?P<this>.*?)(?P<after>''')\s*\Z", re.S), 'multiline'
+##
+
+def _simplifyargs(argsline):
+    a = []
+    for n in markoutercomma(argsline).split('@,@'):
+        for r in '(),':
+            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)
+def crackline(line,reset=0):
+    """
+    reset=-1  --- initialize
+    reset=0   --- crack the line
+    reset=1   --- final check if mismatch of blocks occured
+
+    Cracked data is saved in grouplist[0].
+    """
+    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)
+        return
+    if reset<0:
+        groupcounter=0
+        groupname={groupcounter:''}
+        groupcache={groupcounter:{}}
+        grouplist={groupcounter:[]}
+        groupcache[groupcounter]['body']=[]
+        groupcache[groupcounter]['vars']={}
+        groupcache[groupcounter]['block']=''
+        groupcache[groupcounter]['name']=''
+        neededmodule=-1
+        skipblocksuntil=-1
+        return
+    if reset>0:
+        fl=0
+        if f77modulename and neededmodule==groupcounter: fl=2
+        while groupcounter>fl:
+            outmess('crackline: groupcounter=%s groupname=%s\n'%(repr(groupcounter), repr(groupname)))
+            outmess('crackline: Mismatch of blocks encountered. Trying to fix it by assuming "end" statement.\n')
+            grouplist[groupcounter-1].append(groupcache[groupcounter])
+            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter=groupcounter-1
+        if f77modulename and neededmodule==groupcounter:
+            grouplist[groupcounter-1].append(groupcache[groupcounter])
+            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter=groupcounter-1 # end interface
+            grouplist[groupcounter-1].append(groupcache[groupcounter])
+            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter=groupcounter-1 # end module
+            neededmodule=-1
+        return
+    if line=='': return
+    flag=0
+    for pat in [dimensionpattern, externalpattern, intentpattern, optionalpattern,
+                requiredpattern,
+                parameterpattern, datapattern, publicpattern, privatepattern,
+                intrisicpattern,
+                endifpattern, endpattern,
+                formatpattern,
+                beginpattern, functionpattern, subroutinepattern,
+                implicitpattern, typespattern, commonpattern,
+                callpattern, usepattern, containspattern,
+                entrypattern,
+                f2pyenhancementspattern,
+                multilinepattern
+                ]:
+        m = pat[0].match(line)
+        if m:
+            break
+        flag=flag+1
+    if not m:
+        re_1 = crackline_re_1
+        if 0<=skipblocksuntil<=groupcounter:return
+        if 'externals' in groupcache[groupcounter]:
+            for name in groupcache[groupcounter]['externals']:
+                if name in invbadnames:
+                    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)
+                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)
+                    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)
+                    return
+        if verbose>1 or (verbose==1 and currentfilename.lower().endswith('.pyf')):
+            previous_context = None
+            outmess('crackline:%d: No pattern for line\n'%(groupcounter))
+        return
+    elif pat[1]=='end':
+        if 0<=skipblocksuntil<groupcounter:
+            groupcounter=groupcounter-1
+            if skipblocksuntil<=groupcounter: return
+        if groupcounter<=0:
+            raise Exception('crackline: groupcounter(=%s) is nonpositive. '
+                            'Check the blocks.' \
+                            % (groupcounter))
+        m1 = beginpattern[0].match((line))
+        if (m1) and (not m1.group('this')==groupname[groupcounter]):
+            raise Exception('crackline: End group %s does not match with '
+                            'previous Begin group %s\n\t%s' % \
+                            (repr(m1.group('this')), repr(groupname[groupcounter]),
+                             filepositiontext)
+                            )
+        if skipblocksuntil==groupcounter:
+            skipblocksuntil=-1
+        grouplist[groupcounter-1].append(groupcache[groupcounter])
+        grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+        del grouplist[groupcounter]
+        groupcounter=groupcounter-1
+        if not skipemptyends:
+            expectbegin=1
+    elif pat[1] == 'begin':
+        if 0<=skipblocksuntil<=groupcounter:
+            groupcounter=groupcounter+1
+            return
+        gotnextfile=0
+        analyzeline(m, pat[1], line)
+        expectbegin=0
+    elif pat[1]=='endif':
+        pass
+    elif pat[1]=='contains':
+        if ignorecontains: return
+        if 0<=skipblocksuntil<=groupcounter: return
+        skipblocksuntil=groupcounter
+    else:
+        if 0<=skipblocksuntil<=groupcounter:return
+        analyzeline(m, pat[1], line)
+
+def markouterparen(line):
+    l='';f=0
+    for c in line:
+        if c=='(':
+            f=f+1
+            if f==1: l=l+'@(@'; continue
+        elif c==')':
+            f=f-1
+            if f==0: l=l+'@)@'; continue
+        l=l+c
+    return l
+def markoutercomma(line,comma=','):
+    l='';f=0
+    cc=''
+    for c in line:
+        if (not cc or cc==')') and c=='(':
+            f=f+1
+            cc = ')'
+        elif not cc and c=='\'' and (not l or l[-1]!='\\'):
+            f=f+1
+            cc = '\''
+        elif c==cc:
+            f=f-1
+            if f==0:
+                cc=''
+        elif c==comma and f==0:
+            l=l+'@'+comma+'@'
+            continue
+        l=l+c
+    assert not f, repr((f, line, l, cc))
+    return l
+def unmarkouterparen(line):
+    r = line.replace('@(@', '(').replace('@)@', ')')
+    return r
+def appenddecl(decl,decl2,force=1):
+    if not decl: decl={}
+    if not decl2: return decl
+    if decl is decl2: return decl
+    for k in list(decl2.keys()):
+        if k=='typespec':
+            if force or k not in decl:
+                decl[k]=decl2[k]
+        elif k=='attrspec':
+            for l in decl2[k]:
+                decl=setattrspec(decl, l, force)
+        elif k=='kindselector':
+            decl=setkindselector(decl, decl2[k], force)
+        elif k=='charselector':
+            decl=setcharselector(decl, decl2[k], force)
+        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']:
+            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)
+real16pattern = re.compile(r'([-+]?(?:\d+(?:\.\d*)?|\d*\.\d+))[dD]((?:[-+]?\d+)?)')
+real8pattern = re.compile(r'([-+]?((?:\d+(?:\.\d*)?|\d*\.\d+))[eE]((?:[-+]?\d+)?)|(\d+\.\d*))')
+
+_intentcallbackpattern = re.compile(r'intent\s*\(.*?\bcallback\b', re.I)
+def _is_intent_callback(vdecl):
+    for a in vdecl.get('attrspec', []):
+        if _intentcallbackpattern.match(a):
+            return 1
+    return 0
+
+def _resolvenameargspattern(line):
+    line = markouterparen(line)
+    m1=nameargspattern.match(line)
+    if m1:
+        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
+
+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'] \
+       and not skipemptyends and groupcounter<1:
+        newname=os.path.basename(currentfilename).split('.')[0]
+        outmess('analyzeline: no group yet. Creating program group with name "%s".\n'%newname)
+        gotnextfile=0
+        groupcounter=groupcounter+1
+        groupname[groupcounter]='program'
+        groupcache[groupcounter]={}
+        grouplist[groupcounter]=[]
+        groupcache[groupcounter]['body']=[]
+        groupcache[groupcounter]['vars']={}
+        groupcache[groupcounter]['block']='program'
+        groupcache[groupcounter]['name']=newname
+        groupcache[groupcounter]['from']='fromsky'
+        expectbegin=0
+    if case in ['begin', 'call', 'callfun']:
+        # Crack line => block,name,args,result
+        block = block.lower()
+        if re.match(r'block\s*data', block, re.I): block='block data'
+        if re.match(r'python\s*module', block, re.I): block='python module'
+        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']:
+                outmess('analyzeline: No name/args pattern found for line.\n')
+
+        previous_context = (block, name, groupcounter)
+        if args: args=rmbadname([x.strip() for x in markoutercomma(args).split('@,@')])
+        else: args=[]
+        if '' in args:
+            while '' in args:
+                args.remove('')
+            outmess('analyzeline: argument list is malformed (missing argument).\n')
+
+        # end of crack line => block,name,args,result
+        needmodule=0
+        needinterface=0
+
+        if case in ['call', 'callfun']:
+            needinterface=1
+            if 'args' not in groupcache[groupcounter]:
+                return
+            if name not in groupcache[groupcounter]['args']:
+                return
+            for it in grouplist[groupcounter]:
+                if it['name']==name:
+                    return
+            if name in groupcache[groupcounter]['interfaced']:
+                return
+            block={'call':'subroutine','callfun':'function'}[case]
+        if f77modulename and neededmodule==-1 and groupcounter<=1:
+            neededmodule=groupcounter+2
+            needmodule=1
+            if block != 'interface':
+                needinterface=1
+        # Create new block(s)
+        groupcounter=groupcounter+1
+        groupcache[groupcounter]={}
+        grouplist[groupcounter]=[]
+        if needmodule:
+            if verbose>1:
+                outmess('analyzeline: Creating module block %s\n'%repr(f77modulename), 0)
+            groupname[groupcounter]='module'
+            groupcache[groupcounter]['block']='python module'
+            groupcache[groupcounter]['name']=f77modulename
+            groupcache[groupcounter]['from']=''
+            groupcache[groupcounter]['body']=[]
+            groupcache[groupcounter]['externals']=[]
+            groupcache[groupcounter]['interfaced']=[]
+            groupcache[groupcounter]['vars']={}
+            groupcounter=groupcounter+1
+            groupcache[groupcounter]={}
+            grouplist[groupcounter]=[]
+        if needinterface:
+            if verbose>1:
+                outmess('analyzeline: Creating additional interface block (groupcounter=%s).\n' % (groupcounter), 0)
+            groupname[groupcounter]='interface'
+            groupcache[groupcounter]['block']='interface'
+            groupcache[groupcounter]['name']='unknown_interface'
+            groupcache[groupcounter]['from']='%s:%s'%(groupcache[groupcounter-1]['from'], groupcache[groupcounter-1]['name'])
+            groupcache[groupcounter]['body']=[]
+            groupcache[groupcounter]['externals']=[]
+            groupcache[groupcounter]['interfaced']=[]
+            groupcache[groupcounter]['vars']={}
+            groupcounter=groupcounter+1
+            groupcache[groupcounter]={}
+            grouplist[groupcounter]=[]
+        groupname[groupcounter]=block
+        groupcache[groupcounter]['block']=block
+        if not name: name='unknown_'+block
+        groupcache[groupcounter]['prefix']=m.group('before')
+        groupcache[groupcounter]['name']=rmbadname1(name)
+        groupcache[groupcounter]['result']=result
+        if groupcounter==1:
+            groupcache[groupcounter]['from']=currentfilename
+        else:
+            if f77modulename and groupcounter==3:
+                groupcache[groupcounter]['from']='%s:%s'%(groupcache[groupcounter-1]['from'], currentfilename)
+            else:
+                groupcache[groupcounter]['from']='%s:%s'%(groupcache[groupcounter-1]['from'], groupcache[groupcounter-1]['name'])
+        for k in list(groupcache[groupcounter].keys()):
+            if not groupcache[groupcounter][k]:
+                del groupcache[groupcounter][k]
+
+        groupcache[groupcounter]['args']=args
+        groupcache[groupcounter]['body']=[]
+        groupcache[groupcounter]['externals']=[]
+        groupcache[groupcounter]['interfaced']=[]
+        groupcache[groupcounter]['vars']={}
+        groupcache[groupcounter]['entry']={}
+        # end of creation
+        if block=='type':
+            groupcache[groupcounter]['varnames'] = []
+
+        if case in ['call', 'callfun']: # set parents variables
+            if name not in groupcache[groupcounter-2]['externals']:
+                groupcache[groupcounter-2]['externals'].append(name)
+            groupcache[groupcounter]['vars']=copy.deepcopy(groupcache[groupcounter-2]['vars'])
+            #try: del groupcache[groupcounter]['vars'][groupcache[groupcounter-2]['name']]
+            #except: pass
+            try: del groupcache[groupcounter]['vars'][name][groupcache[groupcounter]['vars'][name]['attrspec'].index('external')]
+            except: pass
+        if block in ['function', 'subroutine']: # set global attributes
+            try: groupcache[groupcounter]['vars'][name]=appenddecl(groupcache[groupcounter]['vars'][name], groupcache[groupcounter-2]['vars'][''])
+            except: pass
+            if case=='callfun': # return type
+                if result and result in groupcache[groupcounter]['vars']:
+                    if not name==result:
+                        groupcache[groupcounter]['vars'][name]=appenddecl(groupcache[groupcounter]['vars'][name], groupcache[groupcounter]['vars'][result])
+            #if groupcounter>1: # name is interfaced
+            try: groupcache[groupcounter-2]['interfaced'].append(name)
+            except: pass
+        if block=='function':
+            t=typespattern[0].match(m.group('before')+' '+name)
+            if t:
+                typespec, selector, attr, edecl=cracktypespec0(t.group('this'), t.group('after'))
+                updatevars(typespec, selector, attr, edecl)
+
+        if case in ['call', 'callfun']:
+            grouplist[groupcounter-1].append(groupcache[groupcounter])
+            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter=groupcounter-1 # end routine
+            grouplist[groupcounter-1].append(groupcache[groupcounter])
+            grouplist[groupcounter-1][-1]['body']=grouplist[groupcounter]
+            del grouplist[groupcounter]
+            groupcounter=groupcounter-1 # end interface
+
+    elif case=='entry':
+        name, args, result, bind=_resolvenameargspattern(m.group('after'))
+        if name is not None:
+            if args:
+                args=rmbadname([x.strip() for x in markoutercomma(args).split('@,@')])
+            else: args=[]
+            assert result is None, repr(result)
+            groupcache[groupcounter]['entry'][name] = args
+            previous_context = ('entry', name, groupcounter)
+    elif case=='type':
+        typespec, selector, attr, edecl=cracktypespec0(block, m.group('after'))
+        last_name = updatevars(typespec, selector, attr, edecl)
+        if last_name is not None:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case in ['dimension', 'intent', 'optional', 'required', 'external', 'public', 'private', 'intrisic']:
+        edecl=groupcache[groupcounter]['vars']
+        ll=m.group('after').strip()
+        i=ll.find('::')
+        if i<0 and case=='intent':
+            i=markouterparen(ll).find('@)@')-2
+            ll=ll[:i+1]+'::'+ll[i+1:]
+            i=ll.find('::')
+            if ll[i:]=='::' and 'args' in groupcache[groupcounter]:
+                outmess('All arguments will have attribute %s%s\n'%(m.group('this'), ll[:i]))
+                ll = ll + ','.join(groupcache[groupcounter]['args'])
+        if i<0:i=0;pl=''
+        else: pl=ll[:i].strip();ll=ll[i+2:]
+        ch = markoutercomma(pl).split('@,@')
+        if len(ch)>1:
+            pl = ch[0]
+            outmess('analyzeline: cannot handle multiple attributes without type specification. Ignoring %r.\n' % (','.join(ch[1:])))
+        last_name = None
+
+        for e in [x.strip() for x in markoutercomma(ll).split('@,@')]:
+            m1=namepattern.match(e)
+            if not m1:
+                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)))
+                    continue
+            else:
+                k=rmbadname1(m1.group('name'))
+            if k not in edecl:
+                edecl[k]={}
+            if case=='dimension':
+                ap=case+m1.group('after')
+            if case=='intent':
+                ap=m.group('this')+pl
+                if _intentcallbackpattern.match(ap):
+                    if k not in groupcache[groupcounter]['args']:
+                        if groupcounter>1:
+                            if '__user__' not in groupcache[groupcounter-2]['name']:
+                                outmess('analyzeline: missing __user__ module (could be nothing)\n')
+                            if k!=groupcache[groupcounter]['name']: # fixes ticket 1693
+                                outmess('analyzeline: appending intent(callback) %s'\
+                                        ' 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']:
+                ap=case
+            if 'attrspec' in edecl[k]:
+                edecl[k]['attrspec'].append(ap)
+            else:
+                edecl[k]['attrspec']=[ap]
+            if case=='external':
+                if groupcache[groupcounter]['block']=='program':
+                    outmess('analyzeline: ignoring program arguments\n')
+                    continue
+                if k not in groupcache[groupcounter]['args']:
+                    #outmess('analyzeline: ignoring external %s (not in arguments list)\n'%(`k`))
+                    continue
+                if 'externals' not in groupcache[groupcounter]:
+                    groupcache[groupcounter]['externals']=[]
+                groupcache[groupcounter]['externals'].append(k)
+            last_name = k
+        groupcache[groupcounter]['vars']=edecl
+        if last_name is not None:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case=='parameter':
+        edecl=groupcache[groupcounter]['vars']
+        ll=m.group('after').strip()[1:-1]
+        last_name = None
+        for e in markoutercomma(ll).split('@,@'):
+            try:
+                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
+            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)
+            if t:
+                if t.get('typespec')=='real':
+                    tt = list(initexpr)
+                    for m in real16pattern.finditer(initexpr):
+                        tt[m.start():m.end()] = list(\
+                            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*(')
+            try:
+                v = eval(initexpr, {}, params)
+            except (SyntaxError, NameError, TypeError) as msg:
+                errmess('analyzeline: Failed to evaluate %r. Ignoring: %s\n'\
+                        % (initexpr, msg))
+                continue
+            edecl[k]['='] = repr(v)
+            if 'attrspec' in edecl[k]:
+                edecl[k]['attrspec'].append('parameter')
+            else: edecl[k]['attrspec']=['parameter']
+            last_name = k
+        groupcache[groupcounter]['vars']=edecl
+        if last_name is not None:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case=='implicit':
+        if m.group('after').strip().lower()=='none':
+            groupcache[groupcounter]['implicit']=None
+        elif m.group('after'):
+            if 'implicit' in groupcache[groupcounter]:
+                impl=groupcache[groupcounter]['implicit']
+            else: impl={}
+            if impl is None:
+                outmess('analyzeline: Overwriting earlier "implicit none" statement.\n')
+                impl={}
+            for e in markoutercomma(m.group('after')).split('@,@'):
+                decl={}
+                m1=re.match(r'\s*(?P<this>.*?)\s*(\(\s*(?P<after>[a-z-, ]+)\s*\)\s*|)\Z', e, re.I)
+                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)
+                decl['typespec']=typespec
+                decl['kindselector']=kindselect
+                decl['charselector']=charselect
+                decl['typename']=typename
+                for k in list(decl.keys()):
+                    if not decl[k]: del decl[k]
+                for r in markoutercomma(m1.group('after')).split('@,@'):
+                    if '-' in r:
+                        try: begc, endc=[x.strip() for x in r.split('-')]
+                        except:
+                            outmess('analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement\n'%r);continue
+                    else: begc=endc=r.strip()
+                    if not len(begc)==len(endc)==1:
+                        outmess('analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement (2)\n'%r);continue
+                    for o in range(ord(begc), ord(endc)+1):
+                        impl[chr(o)]=decl
+            groupcache[groupcounter]['implicit']=impl
+    elif case=='data':
+        ll=[]
+        dl='';il='';f=0;fc=1;inp=0
+        for c in m.group('after'):
+            if not inp:
+                if c=="'": fc=not fc
+                if c=='/' and fc: f=f+1;continue
+            if c=='(': inp = inp + 1
+            elif c==')': inp = inp - 1
+            if f==0: dl=dl+c
+            elif f==1: il=il+c
+            elif f==2:
+                dl = dl.strip()
+                if dl.startswith(','):
+                    dl = dl[1:].strip()
+                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])
+        vars={}
+        if 'vars' in groupcache[groupcounter]:
+            vars=groupcache[groupcounter]['vars']
+        last_name = None
+        for l in ll:
+            l=[x.strip() for x in l]
+            if l[0][0]==',':l[0]=l[0][1:]
+            if l[0][0]=='(':
+                outmess('analyzeline: implied-DO list "%s" is not supported. Skipping.\n'%l[0])
+                continue
+            #if '(' in l[0]:
+            #    #outmess('analyzeline: ignoring this data statement.\n')
+            #    continue
+            i=0;j=0;llen=len(l[1])
+            for v in rmbadname([x.strip() for x in markoutercomma(l[0]).split('@,@')]):
+                if v[0]=='(':
+                    outmess('analyzeline: implied-DO list "%s" is not supported. Skipping.\n'%v)
+                    # XXX: subsequent init expressions may get wrong values.
+                    #      Ignoring since data statements are irrelevant for wrapping.
+                    continue
+                fc=0
+                while (i<llen) and (fc or not l[1][i]==','):
+                    if l[1][i]=="'": fc=not fc
+                    i=i+1
+                i=i+1
+                #v,l[1][j:i-1]=name,initvalue
+                if v not in vars:
+                    vars[v]={}
+                if '=' in vars[v] and not vars[v]['=']==l[1][j:i-1]:
+                    outmess('analyzeline: changing init expression of "%s" ("%s") to "%s"\n'%(v, vars[v]['='], l[1][j:i-1]))
+                vars[v]['=']=l[1][j:i-1]
+                j=i
+                last_name = v
+        groupcache[groupcounter]['vars']=vars
+        if last_name is not None:
+            previous_context = ('variable', last_name, groupcounter)
+    elif case=='common':
+        line=m.group('after').strip()
+        if not line[0]=='/':line='//'+line
+        cl=[]
+        f=0;bn='';ol=''
+        for c in line:
+            if c=='/':f=f+1;continue
+            if f>=3:
+                bn = bn.strip()
+                if not bn: bn='_BLNK_'
+                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])
+        commonkey={}
+        if 'common' in groupcache[groupcounter]:
+            commonkey=groupcache[groupcounter]['common']
+        for c in cl:
+            if c[0] in commonkey:
+                outmess('analyzeline: previously defined common block encountered. Skipping.\n')
+                continue
+            commonkey[c[0]]=[]
+            for i in [x.strip() for x in markoutercomma(c[1]).split('@,@')]:
+                if i: commonkey[c[0]].append(i)
+        groupcache[groupcounter]['common']=commonkey
+        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)
+        if m1:
+            mm=m1.groupdict()
+            if 'use' not in groupcache[groupcounter]:
+                groupcache[groupcounter]['use']={}
+            name=m1.group('name')
+            groupcache[groupcounter]['use'][name]={}
+            isonly=0
+            if 'list' in mm and mm['list'] is not None:
+                if 'notonly' in mm and mm['notonly'] is None:
+                    isonly=1
+                groupcache[groupcounter]['use'][name]['only']=isonly
+                ll=[x.strip() for x in mm['list'].split(',')]
+                rl={}
+                for l in ll:
+                    if '=' in l:
+                        m2=re.match(r'\A\s*(?P<local>\b[\w]+\b)\s*=\s*>\s*(?P<use>\b[\w]+\b)\s*\Z', l, re.I)
+                        if m2: rl[m2.group('local').strip()]=m2.group('use').strip()
+                        else:
+                            outmess('analyzeline: Not local=>use pattern found in %s\n'%repr(l))
+                    else:
+                        rl[l]=l
+                    groupcache[groupcounter]['use'][name]['map']=rl
+            else:
+                pass
+        else:
+            print(m.groupdict())
+            outmess('analyzeline: Could not crack the use statement.\n')
+    elif case in ['f2pyenhancements']:
+        if 'f2pyenhancements' not in groupcache[groupcounter]:
+            groupcache[groupcounter]['f2pyenhancements'] = {}
+        d = groupcache[groupcounter]['f2pyenhancements']
+        if m.group('this')=='usercode' and 'usercode' in d:
+            if isinstance(d['usercode'], str):
+                d['usercode'] = [d['usercode']]
+            d['usercode'].append(m.group('after'))
+        else:
+            d[m.group('this')] = m.group('after')
+    elif case=='multiline':
+        if previous_context is None:
+            if verbose:
+                outmess('analyzeline: No context for multiline block.\n')
+            return
+        gc = groupcounter
+        #gc = previous_context[2]
+        appendmultiline(groupcache[gc],
+                        previous_context[:2],
+                        m.group('this'))
+    else:
+        if verbose>1:
+            print(m.groupdict())
+            outmess('analyzeline: No code implemented for line.\n')
+
+def appendmultiline(group, context_name, ml):
+    if 'f2pymultilines' not in group:
+        group['f2pymultilines'] = {}
+    d = group['f2pymultilines']
+    if context_name not in d:
+        d[context_name] = []
+    d[context_name].append(ml)
+    return
+
+def cracktypespec0(typespec, ll):
+    selector=None
+    attr=None
+    if re.match(r'double\s*complex', typespec, re.I): typespec='double complex'
+    elif re.match(r'double\s*precision', typespec, re.I): typespec='double precision'
+    else: typespec=typespec.strip().lower()
+    m1=selectpattern.match(markouterparen(ll))
+    if not m1:
+        outmess('cracktypespec0: no kind/char_selector pattern found for line.\n')
+        return
+    d=m1.groupdict()
+    for k in list(d.keys()): d[k]=unmarkouterparen(d[k])
+    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
+#####
+namepattern=re.compile(r'\s*(?P<name>\b[\w]+\b)\s*(?P<after>.*)\s*\Z', re.I)
+kindselector=re.compile(r'\s*(\(\s*(kind\s*=)?\s*(?P<kind>.*)\s*\)|[*]\s*(?P<kind2>.*?))\s*\Z', re.I)
+charselector=re.compile(r'\s*(\((?P<lenkind>.*)\)|[*]\s*(?P<charlen>.*))\s*\Z', re.I)
+lenkindpattern=re.compile(r'\s*(kind\s*=\s*(?P<kind>.*?)\s*(@,@\s*len\s*=\s*(?P<len>.*)|)|(len\s*=\s*|)(?P<len2>.*?)\s*(@,@\s*(kind\s*=\s*|)(?P<kind2>.*)|))\s*\Z', re.I)
+lenarraypattern=re.compile(r'\s*(@\(@\s*(?!/)\s*(?P<array>.*?)\s*@\)@\s*[*]\s*(?P<len>.*?)|([*]\s*(?P<len2>.*?)|)\s*(@\(@\s*(?!/)\s*(?P<array2>.*?)\s*@\)@|))\s*(=\s*(?P<init>.*?)|(@\(@|)/\s*(?P<init2>.*?)\s*/(@\)@|)|)\s*\Z', re.I)
+def removespaces(expr):
+    expr=expr.strip()
+    if len(expr)<=1: return expr
+    expr2=expr[0]
+    for i in range(1, len(expr)-1):
+        if expr[i]==' ' and \
+           ((expr[i+1] in "()[]{}=+-/* ") or (expr[i-1] in "()[]{}=+-/* ")): continue
+        expr2=expr2+expr[i]
+    expr2=expr2+expr[-1]
+    return expr2
+def markinnerspaces(line):
+    l='';f=0
+    cc='\''
+    cc1='"'
+    cb=''
+    for c in line:
+        if cb=='\\' and c in ['\\', '\'', '"']:
+            l=l+c
+            cb=c
+            continue
+        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
+    last_name = None
+    kindselect, charselect, typename=cracktypespec(typespec, selector)
+    if attrspec:
+        attrspec=[x.strip() for x in markoutercomma(attrspec).split('@,@')]
+        l = []
+        c = re.compile(r'(?P<start>[a-zA-Z]+)')
+        for a in attrspec:
+            if not a:
+                continue
+            m = c.match(a)
+            if m:
+                s = m.group('start').lower()
+                a = s + a[len(s):]
+            l.append(a)
+        attrspec = l
+    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 e in el1:
+        m=namepattern.match(e)
+        if not m:
+            outmess('updatevars: no name pattern found for entity=%s. Skipping.\n'%(repr(e)))
+            continue
+        ename=rmbadname1(m.group('name'))
+        edecl={}
+        if ename in groupcache[groupcounter]['vars']:
+            edecl=groupcache[groupcounter]['vars'][ename].copy()
+            not_has_typespec = 'typespec' not in edecl
+            if not_has_typespec:
+                edecl['typespec']=typespec
+            elif typespec and (not typespec==edecl['typespec']):
+                outmess('updatevars: attempt to change the type of "%s" ("%s") to "%s". Ignoring.\n' % (ename, edecl['typespec'], typespec))
+            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]))
+                    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))
+            elif charselect:
+                for k in list(charselect.keys()):
+                    if k in edecl['charselector'] and (not charselect[k]==edecl['charselector'][k]):
+                        outmess('updatevars: attempt to change the charselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (k, ename, edecl['charselector'][k], charselect[k]))
+                    else: edecl['charselector'][k]=copy.copy(charselect[k])
+            if '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))
+            if 'attrspec' not in edecl:
+                edecl['attrspec']=copy.copy(attrspec)
+            elif attrspec:
+                for a in attrspec:
+                    if a not in edecl['attrspec']:
+                        edecl['attrspec'].append(a)
+        else:
+            edecl['typespec']=copy.copy(typespec)
+            edecl['kindselector']=copy.copy(kindselect)
+            edecl['charselector']=copy.copy(charselect)
+            edecl['typename']=typename
+            edecl['attrspec']=copy.copy(attrspec)
+        if m.group('after'):
+            m1=lenarraypattern.match(markouterparen(m.group('after')))
+            if m1:
+                d1=m1.groupdict()
+                for lk in ['len', 'array', 'init']:
+                    if d1[lk+'2'] is not None: d1[lk]=d1[lk+'2']; del d1[lk+'2']
+                for k in list(d1.keys()):
+                    if d1[k] is not None: d1[k]=unmarkouterparen(d1[k])
+                    else: del d1[k]
+                if 'len' in d1 and 'array' in d1:
+                    if d1['len']=='':
+                        d1['len']=d1['array']
+                        del d1['array']
+                    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']))
+                if 'array' in d1:
+                    dm = 'dimension(%s)'%d1['array']
+                    if 'attrspec' not in edecl or (not edecl['attrspec']):
+                        edecl['attrspec']=[dm]
+                    else:
+                        edecl['attrspec'].append(dm)
+                        for dm1 in edecl['attrspec']:
+                            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))
+                                break
+
+                if 'len' in d1:
+                    if typespec in ['complex', 'integer', 'logical', 'real']:
+                        if ('kindselector' not in edecl) or (not edecl['kindselector']):
+                            edecl['kindselector']={}
+                        edecl['kindselector']['*']=d1['len']
+                    elif typespec == 'character':
+                        if ('charselector' not in edecl) or (not edecl['charselector']):
+                            edecl['charselector']={}
+                        if 'len' in edecl['charselector']:
+                            del edecl['charselector']['len']
+                        edecl['charselector']['*']=d1['len']
+                if 'init' in d1:
+                    if '=' in edecl and (not edecl['=']==d1['init']):
+                        outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (ename, edecl['='], d1['init']))
+                    else:
+                        edecl['=']=d1['init']
+            else:
+                outmess('updatevars: could not crack entity declaration "%s". Ignoring.\n'%(ename+m.group('after')))
+        for k in list(edecl.keys()):
+            if not edecl[k]:
+                del edecl[k]
+        groupcache[groupcounter]['vars'][ename]=edecl
+        if 'varnames' in groupcache[groupcounter]:
+            groupcache[groupcounter]['varnames'].append(ename)
+        last_name = ename
+    return last_name
+
+def cracktypespec(typespec, selector):
+    kindselect=None
+    charselect=None
+    typename=None
+    if selector:
+        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)))
+                return
+            kindselect=kindselect.groupdict()
+            kindselect['*']=kindselect['kind2']
+            del kindselect['kind2']
+            for k in list(kindselect.keys()):
+                if not kindselect[k]: del kindselect[k]
+            for k, i in list(kindselect.items()):
+                kindselect[k] = rmbadname1(i)
+        elif typespec=='character':
+            charselect=charselector.match(selector)
+            if not charselect:
+                outmess('cracktypespec: no charselector pattern found for %s\n'%(repr(selector)))
+                return
+            charselect=charselect.groupdict()
+            charselect['*']=charselect['charlen']
+            del charselect['charlen']
+            if charselect['lenkind']:
+                lenkind=lenkindpattern.match(markoutercomma(charselect['lenkind']))
+                lenkind=lenkind.groupdict()
+                for lk in ['len', 'kind']:
+                    if lenkind[lk+'2']:
+                        lenkind[lk]=lenkind[lk+'2']
+                    charselect[lk]=lenkind[lk]
+                    del lenkind[lk+'2']
+            del charselect['lenkind']
+            for k in list(charselect.keys()):
+                if not charselect[k]: del charselect[k]
+            for k, i in list(charselect.items()):
+                charselect[k] = rmbadname1(i)
+        elif typespec=='type':
+            typename=re.match(r'\s*\(\s*(?P<name>\w+)\s*\)', selector, re.I)
+            if typename: typename=typename.group('name')
+            else: outmess('cracktypespec: no typename found in %s\n'%(repr(typespec+selector)))
+        else:
+            outmess('cracktypespec: no selector used for %s\n'%(repr(selector)))
+    return kindselect, charselect, typename
+######
+def setattrspec(decl,attr,force=0):
+    if not decl:
+        decl={}
+    if not attr:
+        return decl
+    if 'attrspec' not in decl:
+        decl['attrspec']=[attr]
+        return decl
+    if force: decl['attrspec'].append(attr)
+    if attr in decl['attrspec']: return decl
+    if attr=='static' and 'automatic' not in decl['attrspec']:
+        decl['attrspec'].append(attr)
+    elif attr=='automatic' and 'static' not in decl['attrspec']:
+        decl['attrspec'].append(attr)
+    elif attr=='public' and 'private' not in decl['attrspec']:
+        decl['attrspec'].append(attr)
+    elif attr=='private' and 'public' not in decl['attrspec']:
+        decl['attrspec'].append(attr)
+    else:
+        decl['attrspec'].append(attr)
+    return decl
+
+def setkindselector(decl,sel,force=0):
+    if not decl:
+        decl={}
+    if not sel:
+        return decl
+    if 'kindselector' not in decl:
+        decl['kindselector']=sel
+        return decl
+    for k in list(sel.keys()):
+        if force or k not in decl['kindselector']:
+            decl['kindselector'][k]=sel[k]
+    return decl
+
+def setcharselector(decl,sel,force=0):
+    if not decl:
+        decl={}
+    if not sel:
+        return decl
+    if 'charselector' not in decl:
+        decl['charselector']=sel
+        return decl
+    for k in list(sel.keys()):
+        if force or k not in decl['charselector']:
+            decl['charselector'][k]=sel[k]
+    return decl
+
+def getblockname(block,unknown='unknown'):
+    if 'name' in block:
+        return block['name']
+    return unknown
+
+###### post processing
+
+def setmesstext(block):
+    global filepositiontext
+    try:
+        filepositiontext='In: %s:%s\n'%(block['from'], block['name'])
+    except:
+        pass
+
+def get_usedict(block):
+    usedict = {}
+    if 'parent_block' in block:
+        usedict = get_usedict(block['parent_block'])
+    if 'use' in block:
+        usedict.update(block['use'])
+    return usedict
+
+def get_useparameters(block, param_map=None):
+    global f90modulevars
+    if param_map is None:
+        param_map = {}
+    usedict = get_usedict(block)
+    if not usedict:
+        return param_map
+    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')))
+            continue
+        mvars = f90modulevars[usename]
+        params = get_parameters(mvars)
+        if not params:
+            continue
+        # XXX: apply mapping
+        if mapping:
+            errmess('get_useparameters: mapping for %s not impl.' % (mapping))
+        for k, v in list(params.items()):
+            if k in param_map:
+                outmess('get_useparameters: overriding parameter %s with'\
+                        ' value from module %s' % (repr(k), repr(usename)))
+            param_map[k] = v
+
+    return param_map
+
+def postcrack2(block,tab='',param_map=None):
+    global f90modulevars
+    if not f90modulevars:
+        return block
+    if isinstance(block, list):
+        ret = []
+        for g in block:
+            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)
+
+    if param_map is None:
+        param_map = get_useparameters(block)
+
+    if param_map is not None and 'vars' in block:
+        vars = block['vars']
+        for n in list(vars.keys()):
+            var = vars[n]
+            if 'kindselector' in var:
+                kind = var['kindselector']
+                if 'kind' in kind:
+                    val = kind['kind']
+                    if val in param_map:
+                        kind['kind'] = param_map[val]
+    new_body = []
+    for b in block['body']:
+        b = postcrack2(b, tab=tab+'\t', param_map=param_map)
+        new_body.append(b)
+    block['body'] = new_body
+
+    return block
+
+def postcrack(block,args=None,tab=''):
+    """
+    TODO:
+          function return values
+          determine expression types if in argument list
+    """
+    global usermodules, onlyfunctions
+    if isinstance(block, list):
+        gret=[]
+        uret=[]
+        for g in block:
+            setmesstext(g)
+            g=postcrack(g, tab=tab+'\t')
+            if 'name' in g and '__user__' in g['name']: # sort user routines to appear first
+                uret.append(g)
+            else:
+                gret.append(g)
+        return uret+gret
+    setmesstext(block)
+    if not isinstance(block, dict) and 'block' not in block:
+        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)
+    blocktype=block['block']
+    block=analyzeargs(block)
+    block=analyzecommon(block)
+    block['vars']=analyzevars(block)
+    block['sortvars']=sortvarnames(block['vars'])
+    if 'args' in block and block['args']:
+        args=block['args']
+    block['body']=analyzebody(block, args, tab=tab)
+
+    userisdefined=[]
+##     fromuser = []
+    if 'use' in block:
+        useblock=block['use']
+        for k in list(useblock.keys()):
+            if '__user__' in k:
+                userisdefined.append(k)
+##                 if 'map' in useblock[k]:
+##                     for n in useblock[k]['map'].itervalues():
+##                         if n not in fromuser: fromuser.append(n)
+    else: useblock={}
+    name=''
+    if 'name' in block:
+        name=block['name']
+    if 'externals' in block and block['externals']:# and not userisdefined: # Build a __user__ module
+        interfaced=[]
+        if 'interfaced' in block:
+            interfaced=block['interfaced']
+        mvars=copy.copy(block['vars'])
+        if name:
+            mname=name+'__user__routines'
+        else:
+            mname='unknown__user__routines'
+        if mname in userisdefined:
+            i=1
+            while '%s_%i'%(mname, i) in userisdefined: i=i+1
+            mname='%s_%i'%(mname, i)
+        interface={'block':'interface','body':[],'vars':{},'name':name+'_user_interface'}
+        for e in block['externals']:
+##             if e in fromuser:
+##                 outmess('  Skipping %s that is defined explicitly in another use statement\n'%(`e`))
+##                 continue
+            if e in interfaced:
+                edef=[]
+                j=-1
+                for b in block['body']:
+                    j=j+1
+                    if b['block']=='interface':
+                        i=-1
+                        for bb in b['body']:
+                            i=i+1
+                            if 'name' in bb and bb['name']==e:
+                                edef=copy.copy(bb)
+                                del b['body'][i]
+                                break
+                        if edef:
+                            if not b['body']: del block['body'][j]
+                            del interfaced[interfaced.index(e)]
+                            break
+                interface['body'].append(edef)
+            else:
+                if e in mvars and not isexternal(mvars[e]):
+                    interface['vars'][e]=mvars[e]
+        if interface['vars'] or interface['body']:
+            block['interfaced']=interfaced
+            mblock={'block':'python module','body':[interface],'vars':{},'name':mname,'interfaced':block['externals']}
+            useblock[mname]={}
+            usermodules.append(mblock)
+    if useblock:
+        block['use']=useblock
+    return block
+
+def sortvarnames(vars):
+    indep = []
+    dep = []
+    for v in list(vars.keys()):
+        if 'depend' in vars[v] and vars[v]['depend']:
+            dep.append(v)
+            #print '%s depends on %s'%(v,vars[v]['depend'])
+        else: indep.append(v)
+    n = len(dep)
+    i = 0
+    while dep: #XXX: How to catch dependence cycles correctly?
+        v = dep[0]
+        fl = 0
+        for w in dep[1:]:
+            if w in vars[v]['depend']:
+                fl = 1
+                break
+        if fl:
+            dep = dep[1:]+[v]
+            i = i + 1
+            if i>n:
+                errmess('sortvarnames: failed to compute dependencies because'
+                        ' of cyclic dependencies between '
+                        +', '.join(dep)+'\n')
+                indep = indep + dep
+                break
+        else:
+            indep.append(v)
+            dep = dep[1:]
+            n = len(dep)
+            i = 0
+    #print indep
+    return indep
+
+def analyzecommon(block):
+    if not hascommon(block): return block
+    commonvars=[]
+    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)
+            if m:
+                dims=[]
+                if m.group('dims'):
+                    dims=[x.strip() for x in markoutercomma(m.group('dims')).split('@,@')]
+                n=m.group('name').strip()
+                if n in block['vars']:
+                    if 'attrspec' in block['vars'][n]:
+                        block['vars'][n]['attrspec'].append('dimension(%s)'%(','.join(dims)))
+                    else:
+                        block['vars'][n]['attrspec']=['dimension(%s)'%(','.join(dims))]
+                else:
+                    if dims:
+                        block['vars'][n]={'attrspec':['dimension(%s)'%(','.join(dims))]}
+                    else: block['vars'][n]={}
+                if n not in commonvars: commonvars.append(n)
+            else:
+                n=e
+                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:
+        block['commonvars']=commonvars
+    else:
+        block['commonvars']=block['commonvars']+commonvars
+    return block
+
+def analyzebody(block,args,tab=''):
+    global usermodules, skipfuncs, onlyfuncs, f90modulevars
+    setmesstext(block)
+    body=[]
+    for b in block['body']:
+        b['parent_block'] = block
+        if b['block'] in ['function', 'subroutine']:
+            if args is not None and b['name'] not in args:
+                continue
+            else:
+                as_=b['args']
+            if b['name'] in skipfuncs:
+                continue
+            if onlyfuncs and b['name'] not in onlyfuncs:
+                continue
+            b['saved_interface'] = crack2fortrangen(b, '\n'+' '*6, as_interface=True)
+
+        else: as_=args
+        b=postcrack(b, as_, tab=tab+'\t')
+        if b['block']=='interface' and not b['body']:
+            if 'f2pyenhancements' not in b:
+                continue
+        if b['block'].replace(' ', '')=='pythonmodule':
+            usermodules.append(b)
+        else:
+            if b['block']=='module':
+                f90modulevars[b['name']] = b['vars']
+            body.append(b)
+    return body
+
+def buildimplicitrules(block):
+    setmesstext(block)
+    implicitrules=defaultimplicitrules
+    attrrules={}
+    if 'implicit' in block:
+        if block['implicit'] is None:
+            implicitrules=None
+            if verbose>1:
+                outmess('buildimplicitrules: no implicit rules for routine %s.\n'%repr(block['name']))
+        else:
+            for k in list(block['implicit'].keys()):
+                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
+
+def myeval(e,g=None,l=None):
+    r = eval(e, g, l)
+    if type(r) in [type(0), type(0.0)]:
+        return r
+    raise ValueError('r=%r' % (r))
+
+getlincoef_re_1 = re.compile(r'\A\b\w+\b\Z', re.I)
+def getlincoef(e, xset): # e = a*x+b ; x in xset
+    try:
+        c = int(myeval(e, {}, {}))
+        return 0, c, None
+    except: pass
+    if getlincoef_re_1.match(e):
+        return 1, 0, e
+    len_e = len(e)
+    for x in xset:
+        if len(x)>len_e: continue
+        if re.search(r'\w\s*\([^)]*\b'+x+r'\b', e):
+            # 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)
+        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'))
+                    m1 = re_1.match(ee)
+                b = myeval(ee, {}, {})
+                m1 = re_1.match(e)
+                while m1:
+                    ee = '%s(%s)%s'%(m1.group('before'), 1, m1.group('after'))
+                    m1 = re_1.match(ee)
+                a = myeval(ee, {}, {}) - b
+                m1 = re_1.match(e)
+                while m1:
+                    ee = '%s(%s)%s'%(m1.group('before'), 0.5, m1.group('after'))
+                    m1 = re_1.match(ee)
+                c = myeval(ee, {}, {})
+                # computing another point to be sure that expression is linear
+                m1 = re_1.match(e)
+                while m1:
+                    ee = '%s(%s)%s'%(m1.group('before'), 1.5, m1.group('after'))
+                    m1 = re_1.match(ee)
+                c2 = myeval(ee, {}, {})
+                if (a*0.5+b==c and a*1.5+b==c2):
+                    return a, b, x
+            except: pass
+            break
+    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], {}, {}))
+    except: edl.append(dl[0])
+    try: edl.append(myeval(dl[1], {}, {}))
+    except: edl.append(dl[1])
+    if isinstance(edl[0], int):
+        p1 = 1-edl[0]
+        if p1==0: d = str(dl[1])
+        elif p1<0: d = '%s-%s'%(dl[1], -p1)
+        else: d = '%s+%s'%(dl[1], p1)
+    elif isinstance(edl[1], int):
+        p1 = 1+edl[1]
+        if p1==0: d='-(%s)' % (dl[0])
+        else: d='%s-(%s)' % (p1, dl[0])
+    else: d = '%s-(%s)+1'%(dl[1], dl[0])
+    try: return repr(myeval(d, {}, {})), None, None
+    except: pass
+    d1, d2=getlincoef(dl[0], args), getlincoef(dl[1], args)
+    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])
+        if d1[0]==0 and d2[2] in args:
+            if b<0: return '%s * %s - %s'%(d2[0], d2[2], -b), d2[2], '+%s)/(%s)'%(-b, d2[0])
+            elif b: return '%s * %s + %s'%(d2[0], d2[2], b), d2[2], '-%s)/(%s)'%(b, d2[0])
+            else: return '%s * %s'%(d2[0], d2[2]), d2[2], ')/(%s)'%(d2[0])
+        if d2[0]==0 and d1[2] in args:
+
+            if b<0: return '%s * %s - %s'%(-d1[0], d1[2], -b), d1[2], '+%s)/(%s)'%(-b, -d1[0])
+            elif b: return '%s * %s + %s'%(-d1[0], d1[2], b), d1[2], '-%s)/(%s)'%(b, -d1[0])
+            else: return '%s * %s'%(-d1[0], d1[2]), d1[2], ')/(%s)'%(-d1[0])
+        if d1[2]==d2[2] and d1[2] in args:
+            a = d2[0] - d1[0]
+            if not a: return repr(b), None, None
+            if b<0: return '%s * %s - %s'%(a, d1[2], -b), d2[2], '+%s)/(%s)'%(-b, a)
+            elif b: return '%s * %s + %s'%(a, d1[2], b), d2[2], '-%s)/(%s)'%(b, a)
+            else: return '%s * %s'%(a, d1[2]), d2[2], ')/(%s)'%(a)
+        if d1[0]==d2[0]==1:
+            c = str(d1[2])
+            if c not in args:
+                if _varname_match(c):
+                    outmess('\tgetarrlen:variable "%s" undefined\n' % (c))
+                c = '(%s)'%c
+            if b==0: d='%s-%s' % (d2[2], c)
+            elif b<0: d='%s-%s-%s' % (d2[2], c, -b)
+            else: d='%s-%s+%s' % (d2[2], c, b)
+        elif d1[0]==0:
+            c2 = str(d2[2])
+            if c2 not in args:
+                if _varname_match(c2):
+                    outmess('\tgetarrlen:variable "%s" undefined\n' % (c2))
+                c2 = '(%s)'%c2
+            if d2[0]==1: pass
+            elif d2[0]==-1: c2='-%s' %c2
+            else: c2='%s*%s'%(d2[0], c2)
+
+            if b==0: d=c2
+            elif b<0: d='%s-%s' % (c2, -b)
+            else: d='%s+%s' % (c2, b)
+        elif d2[0]==0:
+            c1 = str(d1[2])
+            if c1 not in args:
+                if _varname_match(c1):
+                    outmess('\tgetarrlen:variable "%s" undefined\n' % (c1))
+                c1 = '(%s)'%c1
+            if d1[0]==1: c1='-%s'%c1
+            elif d1[0]==-1: c1='+%s'%c1
+            elif d1[0]<0: c1='+%s*%s'%(-d1[0], c1)
+            else: c1 = '-%s*%s' % (d1[0], c1)
+
+            if b==0: d=c1
+            elif b<0: d='%s-%s' % (c1, -b)
+            else: d='%s+%s' % (c1, b)
+        else:
+            c1 = str(d1[2])
+            if c1 not in args:
+                if _varname_match(c1):
+                    outmess('\tgetarrlen:variable "%s" undefined\n' % (c1))
+                c1 = '(%s)'%c1
+            if d1[0]==1: c1='-%s'%c1
+            elif d1[0]==-1: c1='+%s'%c1
+            elif d1[0]<0: c1='+%s*%s'%(-d1[0], c1)
+            else: c1 = '-%s*%s' % (d1[0], c1)
+
+            c2 = str(d2[2])
+            if c2 not in args:
+                if _varname_match(c2):
+                    outmess('\tgetarrlen:variable "%s" undefined\n' % (c2))
+                c2 = '(%s)'%c2
+            if d2[0]==1: pass
+            elif d2[0]==-1: c2='-%s' %c2
+            else: c2='%s*%s'%(d2[0], c2)
+
+            if b==0: d='%s%s' % (c2, c1)
+            elif b<0: d='%s%s-%s' % (c2, c1, -b)
+            else: d='%s%s+%s' % (c2, c1, b)
+    return d, None, None
+
+word_pattern = re.compile(r'\b[a-z][\w$]*\b', re.I)
+
+def _get_depend_dict(name, vars, deps):
+    if name in vars:
+        words = vars[name].get('depend', [])
+
+        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, []) \
+                    or _get_depend_dict(word, vars, deps):
+                if w not in words:
+                    words.append(w)
+    else:
+        outmess('_get_depend_dict: no dependence info for %s\n' % (repr(name)))
+        words = []
+    deps[name] = words
+    return words
+
+def _calc_depend_dict(vars):
+    names = list(vars.keys())
+    depend_dict = {}
+    for n in names:
+        _get_depend_dict(n, vars, depend_dict)
+    return depend_dict
+
+def get_sorted_names(vars):
+    """
+    """
+    depend_dict = _calc_depend_dict(vars)
+    names = []
+    for name in list(depend_dict.keys()):
+        if not depend_dict[name]:
+            names.append(name)
+            del depend_dict[name]
+    while depend_dict:
+        for name, lst in list(depend_dict.items()):
+            new_lst = [n for n in lst if n in depend_dict]
+            if not new_lst:
+                names.append(name)
+                del depend_dict[name]
+            else:
+                depend_dict[name] = new_lst
+    return [name for name in names if name in vars]
+
+def _kind_func(string):
+    #XXX: return something sensible.
+    if string[0] in "'\"":
+        string = string[1:-1]
+    if real16pattern.match(string):
+        return 8
+    elif real8pattern.match(string):
+        return 4
+    return 'kind('+string+')'
+
+def _selected_int_kind_func(r):
+    #XXX: This should be processor dependent
+    m = 10**r
+    if m<=2**8: return 1
+    if m<=2**16: return 2
+    if m<=2**32: return 4
+    if m<=2**63: return 8
+    if m<=2**128: return 16
+    return -1
+
+def _selected_real_kind_func(p, r=0, radix=0):
+    #XXX: This should be processor dependent
+    # This is only good for 0 <= p <= 20
+    if p < 7: return 4
+    if p < 16: return 8
+    if platform.machine().lower().startswith('power'):
+        if p <= 20:
+            return 16
+    else:
+        if p < 19:
+            return 10
+        elif p <= 20:
+            return 16
+    return -1
+
+def get_parameters(vars, global_params={}):
+    params = copy.copy(global_params)
+    g_params = copy.copy(global_params)
+    for name, func in [('kind', _kind_func),
+                      ('selected_int_kind', _selected_int_kind_func),
+                      ('selected_real_kind', _selected_real_kind_func),
+                      ]:
+        if name not in g_params:
+            g_params[name] = func
+    param_names = []
+    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)
+    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'),
+                    #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)
+            if isinteger(vars[n]) and not selected_kind_re.match(v):
+                v = v.split('_')[0]
+            if isdouble(vars[n]):
+                tt = list(v)
+                for m in real16pattern.finditer(v):
+                    tt[m.start():m.end()] = list(\
+                            v[m.start():m.end()].lower().replace('d', 'e'))
+                v = ''.join(tt)
+            if iscomplex(vars[n]):
+                if v[0]=='(' and v[-1]==')':
+                    l = markoutercomma(v[1:-1]).split('@,@')
+            try:
+                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)))
+            if isstring(vars[n]) and isinstance(params[n], int):
+                params[n] = chr(params[n])
+            nl = n.lower()
+            if nl!=n:
+                params[nl] = params[n]
+        else:
+            print(vars[n])
+            outmess('get_parameters:parameter %s does not have value?!\n'%(repr(n)))
+    return params
+
+def _eval_length(length, params):
+    if length in ['(:)', '(*)', '*']:
+        return '(*)'
+    return _eval_scalar(length, params)
+
+_is_kind_number = re.compile(r'\d+_').match
+
+def _eval_scalar(value, params):
+    if _is_kind_number(value):
+        value = value.split('_')[0]
+    try:
+        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())))
+    return value
+
+def analyzevars(block):
+    global f90modulevars
+    setmesstext(block)
+    implicitrules, attrrules=buildimplicitrules(block)
+    vars=copy.copy(block['vars'])
+    if block['block']=='function' and block['name'] not in vars:
+        vars[block['name']]={}
+    if '' in block['vars']:
+        del vars['']
+        if 'attrspec' in block['vars']['']:
+            gen=block['vars']['']['attrspec']
+            for n in list(vars.keys()):
+                for k in ['public', 'private']:
+                    if k in gen:
+                        vars[n]=setattrspec(vars[n], k)
+    svars=[]
+    args = block['args']
+    for a in args:
+        try:
+            vars[a]
+            svars.append(a)
+        except KeyError:
+            pass
+    for n in list(vars.keys()):
+        if n not in args: svars.append(n)
+
+    params = get_parameters(vars, get_useparameters(block))
+
+    dep_matches = {}
+    name_match = re.compile(r'\w[\w\d_$]*').match
+    for v in list(vars.keys()):
+        m = name_match(v)
+        if m:
+            n = v[m.start():m.end()]
+            try:
+                dep_matches[n]
+            except KeyError:
+                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]])
+        if 'typespec' not in vars[n]:
+            if not('attrspec' in vars[n] and 'external' in vars[n]['attrspec']):
+                if implicitrules:
+                    ln0 = n[0].lower()
+                    for k in list(implicitrules[ln0].keys()):
+                        if k=='typespec' and implicitrules[ln0][k]=='undefined':
+                            continue
+                        if k not in vars[n]:
+                            vars[n][k]=implicitrules[ln0][k]
+                        elif k=='attrspec':
+                            for l in implicitrules[ln0][k]:
+                                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']))
+
+        if 'charselector' in vars[n]:
+            if 'len' in vars[n]['charselector']:
+                l = vars[n]['charselector']['len']
+                try:
+                    l = str(eval(l, {}, params))
+                except:
+                    pass
+                vars[n]['charselector']['len'] = l
+
+        if 'kindselector' in vars[n]:
+            if 'kind' in vars[n]['kindselector']:
+                l = vars[n]['kindselector']['kind']
+                try:
+                    l = str(eval(l, {}, params))
+                except:
+                    pass
+                vars[n]['kindselector']['kind'] = l
+
+        savelindims = {}
+        if 'attrspec' in vars[n]:
+            attr=vars[n]['attrspec']
+            attr.reverse()
+            vars[n]['attrspec']=[]
+            dim, intent, depend, check, note=None, None, None, None, None
+            for a in attr:
+                if a[:9]=='dimension': dim=(a[9:].strip())[1:-1]
+                elif a[:6]=='intent': intent=(a[6:].strip())[1:-1]
+                elif a[:6]=='depend': depend=(a[6:].strip())[1:-1]
+                elif a[:5]=='check': check=(a[5:].strip())[1:-1]
+                elif a[:4]=='note': note=(a[4:].strip())[1:-1]
+                else: vars[n]=setattrspec(vars[n], a)
+                if intent:
+                    if 'intent' not in vars[n]:
+                        vars[n]['intent']=[]
+                    for c in [x.strip() for x in markoutercomma(intent).split('@,@')]:
+                        # Remove spaces so that 'in out' becomes 'inout'
+                        tmp = c.replace(' ', '')
+                        if tmp not in vars[n]['intent']:
+                            vars[n]['intent'].append(tmp)
+                    intent=None
+                if note:
+                    note=note.replace('\\n\\n', '\n\n')
+                    note=note.replace('\\n ', '\n')
+                    if 'note' not in vars[n]:
+                        vars[n]['note']=[note]
+                    else:
+                        vars[n]['note'].append(note)
+                    note=None
+                if depend is not None:
+                    if 'depend' not in vars[n]:
+                        vars[n]['depend']=[]
+                    for c in rmbadname([x.strip() for x in markoutercomma(depend).split('@,@')]):
+                        if c not in vars[n]['depend']:
+                            vars[n]['depend'].append(c)
+                    depend=None
+                if check is not None:
+                    if 'check' not in vars[n]:
+                        vars[n]['check']=[]
+                    for c in [x.strip() for x in markoutercomma(check).split('@,@')]:
+                        if c not in vars[n]['check']:
+                            vars[n]['check'].append(c)
+                    check=None
+            if dim and 'dimension' not in vars[n]:
+                vars[n]['dimension']=[]
+                for d in rmbadname([x.strip() for x in markoutercomma(dim).split('@,@')]):
+                    star = '*'
+                    if d==':':
+                        star=':'
+                    if d in params:
+                        d = str(params[d])
+                    for p in list(params.keys()):
+                        m = re.match(r'(?P<before>.*?)\b'+p+r'\b(?P<after>.*)', d, re.I)
+                        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('@:@')
+                    if len(dl)==2 and '*' in dl: # e.g. dimension(5:*)
+                        dl = ['*']
+                        d = '*'
+                    if len(dl)==1 and not dl[0]==star: dl = ['1', dl[0]]
+                    if len(dl)==2:
+                        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
+                    vars[n]['dimension'].append(d)
+        if 'dimension' in vars[n]:
+            if isintent_c(vars[n]):
+                shape_macro = 'shape'
+            else:
+                shape_macro = 'shape'#'fshape'
+            if isstringarray(vars[n]):
+                if 'charselector' in vars[n]:
+                    d = vars[n]['charselector']
+                    if '*' in d:
+                        d = d['*']
+                        errmess('analyzevars: character array "character*%s %s(%s)" is considered as "character %s(%s)"; "intent(c)" is forced.\n'\
+                                %(d, n,
+                                  ','.join(vars[n]['dimension']),
+                                  n, ','.join(vars[n]['dimension']+[d])))
+                        vars[n]['dimension'].append(d)
+                        del vars[n]['charselector']
+                        if 'intent' not in vars[n]:
+                            vars[n]['intent'] = []
+                        if 'c' not in vars[n]['intent']:
+                            vars[n]['intent'].append('c')
+                    else:
+                        errmess("analyzevars: charselector=%r unhandled." % (d))
+        if 'check' not in vars[n] and 'args' in block and n in block['args']:
+            flag = 'depend' not in vars[n]
+            if flag:
+                vars[n]['depend']=[]
+            vars[n]['check']=[]
+            if 'dimension' in vars[n]:
+                #/----< no check
+                #vars[n]['check'].append('rank(%s)==%s'%(n,len(vars[n]['dimension'])))
+                i=-1; ni=len(vars[n]['dimension'])
+                for d in vars[n]['dimension']:
+                    ddeps=[] # dependecies of 'd'
+                    ad=''
+                    pd=''
+                    #origd = d
+                    if d not in vars:
+                        if d in savelindims:
+                            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):
+                                    ddeps.append(r)
+                    if d in vars:
+                        if 'attrspec' in vars[d]:
+                            for aa in vars[d]['attrspec']:
+                                if aa[:6]=='depend':
+                                    ddeps += aa[6:].strip()[1:-1].split(',')
+                        if 'depend' in vars[d]:
+                            ddeps=ddeps+vars[d]['depend']
+                    i=i+1
+                    if d in vars and ('depend' not in vars[d]) \
+                       and ('=' not in vars[d]) and (d not in vars[n]['depend']) \
+                       and l_or(isintent_in, isintent_inout, isintent_inplace)(vars[n]):
+                        vars[d]['depend']=[n]
+                        if ni>1:
+                            vars[d]['=']='%s%s(%s,%s)%s'% (pd, shape_macro, n, i, ad)
+                        else:
+                            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)]
+                            else:
+                                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 ['*', ':']:
+                        #/----< 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))
+                        if flag:
+                            if d in vars:
+                                if n not in ddeps:
+                                    vars[n]['depend'].append(d)
+                            else:
+                                vars[n]['depend'] = vars[n]['depend'] + ddeps
+            elif isstring(vars[n]):
+                length='1'
+                if 'charselector' in vars[n]:
+                    if '*' in vars[n]['charselector']:
+                        length = _eval_length(vars[n]['charselector']['*'],
+                                              params)
+                        vars[n]['charselector']['*']=length
+                    elif 'len' in vars[n]['charselector']:
+                        length = _eval_length(vars[n]['charselector']['len'],
+                                              params)
+                        del vars[n]['charselector']['len']
+                        vars[n]['charselector']['*']=length
+
+            if not vars[n]['check']:
+                del vars[n]['check']
+            if flag and not vars[n]['depend']:
+                del vars[n]['depend']
+        if '=' in vars[n]:
+            if 'attrspec' not in vars[n]:
+                vars[n]['attrspec']=[]
+            if ('optional' not in vars[n]['attrspec']) and \
+               ('required' not in vars[n]['attrspec']):
+                vars[n]['attrspec'].append('optional')
+            if 'depend' not in vars[n]:
+                vars[n]['depend']=[]
+                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)
+
+    for n in list(vars.keys()):
+        if n==block['name']: # n is block name
+            if 'note' in vars[n]:
+                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']])
+                if 'prefix' in block:
+                    pr=block['prefix']; ispure=0; isrec=1
+                    pr1=pr.replace('pure', '')
+                    ispure=(not pr==pr1)
+                    pr=pr1.replace('recursive', '')
+                    isrec=(not pr==pr1)
+                    m=typespattern[0].match(pr)
+                    if m:
+                        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)
+                                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')
+                    else:
+                        outmess('analyzevars: prefix (%s) were not used\n'%repr(block['prefix']))
+    if not block['block'] in ['module', 'pythonmodule', 'python module', 'block data']:
+        if 'commonvars' in block:
+            neededvars=copy.copy(block['args']+block['commonvars'])
+        else:
+            neededvars=copy.copy(block['args'])
+        for n in list(vars.keys()):
+            if l_or(isintent_callback, isintent_aux)(vars[n]):
+                neededvars.append(n)
+        if 'entry' in block:
+            neededvars.extend(list(block['entry'].keys()))
+            for k in list(block['entry'].keys()):
+                for n in block['entry'][k]:
+                    if n not in neededvars:
+                        neededvars.append(n)
+        if block['block']=='function':
+            if 'result' in block:
+                neededvars.append(block['result'])
+            else:
+                neededvars.append(block['name'])
+        if block['block'] in ['subroutine', 'function']:
+            name = block['name']
+            if name in vars and 'intent' in vars[name]:
+                block['intent'] = vars[name]['intent']
+        if block['block'] == 'type':
+            neededvars.extend(list(vars.keys()))
+        for n in list(vars.keys()):
+            if n not in neededvars:
+                del vars[n]
+    return vars
+
+analyzeargs_re_1 = re.compile(r'\A[a-z]+[\w$]*\Z', re.I)
+def expr2name(a, block, args=[]):
+    orig_a = a
+    a_is_expr = not analyzeargs_re_1.match(a)
+    if a_is_expr: # `a` is an expression
+        implicitrules, attrrules=buildimplicitrules(block)
+        at=determineexprtype(a, block['vars'], implicitrules)
+        na='e_'
+        for c in a:
+            c = c.lower()
+            if c not in string.ascii_lowercase+string.digits: c='_'
+            na=na+c
+        if na[-1]=='_': na=na+'e'
+        else: na=na+'_e'
+        a=na
+        while a in block['vars'] or a in block['args']:
+            a=a+'r'
+    if a in args:
+        k = 1
+        while a + str(k) in args:
+            k = k + 1
+        a = a + str(k)
+    if a_is_expr:
+        block['vars'][a]=at
+    else:
+        if a not in block['vars']:
+            if orig_a in block['vars']:
+                block['vars'][a] = block['vars'][orig_a]
+            else:
+                block['vars'][a]={}
+        if 'externals' in block and orig_a in block['externals']+block['interfaced']:
+            block['vars'][a]=setattrspec(block['vars'][a], 'external')
+    return a
+
+def analyzeargs(block):
+    setmesstext(block)
+    implicitrules, attrrules=buildimplicitrules(block)
+    if 'args' not in block:
+        block['args']=[]
+    args=[]
+    for a in block['args']:
+        a = expr2name(a, block, args)
+        args.append(a)
+    block['args']=args
+    if 'entry' in block:
+        for k, args1 in list(block['entry'].items()):
+            for a in args1:
+                if a not in block['vars']:
+                    block['vars'][a]={}
+
+    for b in block['body']:
+        if b['name'] in args:
+            if 'externals' not in block:
+                block['externals']=[]
+            if b['name'] not in block['externals']:
+                block['externals'].append(b['name'])
+    if 'result' in block and block['result'] not in block['vars']:
+        block['vars'][block['result']]={}
+    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)
+def _ensure_exprdict(r):
+    if isinstance(r, int):
+        return {'typespec':'integer'}
+    if isinstance(r, float):
+        return {'typespec':'real'}
+    if isinstance(r, complex):
+        return {'typespec':'complex'}
+    if isinstance(r, dict):
+        return r
+    raise AssertionError(repr(r))
+
+def determineexprtype(expr,vars,rules={}):
+    if expr in vars:
+        return _ensure_exprdict(vars[expr])
+    expr=expr.strip()
+    if determineexprtype_re_1.match(expr):
+        return {'typespec':'complex'}
+    m=determineexprtype_re_2.match(expr)
+    if m:
+        if 'name' in m.groupdict() and m.group('name'):
+            outmess('determineexprtype: selected kind types not supported (%s)\n'%repr(expr))
+        return {'typespec':'integer'}
+    m = determineexprtype_re_3.match(expr)
+    if m:
+        if 'name' in m.groupdict() and m.group('name'):
+            outmess('determineexprtype: selected kind types not supported (%s)\n'%repr(expr))
+        return {'typespec':'real'}
+    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)
+    else:
+        m = determineexprtype_re_5.match(expr)
+        if m:
+            rn=m.group('name')
+            t=determineexprtype(m.group('name'), vars, rules)
+            if t and 'attrspec' in t:
+                del t['attrspec']
+            if not t:
+                if rn[0] in rules:
+                    return _ensure_exprdict(rules[rn[0]])
+    if expr[0] in '\'"':
+        return {'typespec':'character','charselector':{'*':'*'}}
+    if not t:
+        outmess('determineexprtype: could not determine expressions (%s) type.\n'%(repr(expr)))
+    return t
+
+######
+def crack2fortrangen(block,tab='\n', as_interface=False):
+    global skipfuncs, onlyfuncs
+    setmesstext(block)
+    ret=''
+    if isinstance(block, list):
+        for g in block:
+            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)
+        return ret
+    prefix=''
+    name=''
+    args=''
+    blocktype=block['block']
+    if blocktype=='program': return ''
+    argsl = []
+    if 'name' in block:
+        name=block['name']
+    if 'args' in block:
+        vars = block['vars']
+        for a in block['args']:
+            a = expr2name(a, block, argsl)
+            if not isintent_callback(vars[a]):
+                argsl.append(a)
+        if block['block']=='function' or argsl:
+            args='(%s)'%','.join(argsl)
+    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', [])[:]
+    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)
+    use=''
+    if 'use' in block:
+        use=use2fortran(block['use'], tab+tabchar)
+    common=''
+    if 'common' in block:
+        common=common2fortran(block['common'], tab+tabchar)
+    if name=='unknown_interface': name=''
+    result=''
+    if 'result' in block:
+        result=' result (%s)'%block['result']
+        if block['result'] not in argsl:
+            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)
+    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()):
+            entry_stmts = '%s%sentry %s(%s)' \
+                          % (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)
+    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]))
+        else:
+            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)
+        if use[m]=={}:
+            if ret and ret[-1]==',': ret=ret[:-1]
+            continue
+        if 'only' in use[m] and use[m]['only']:
+            ret='%s only:'%(ret)
+        if 'map' in use[m] and use[m]['map']:
+            c=' '
+            for k in list(use[m]['map'].keys()):
+                if k==use[m]['map'][k]:
+                    ret='%s%s%s'%(ret, c, k); c=','
+                else:
+                    ret='%s%s%s=>%s'%(ret, c, k, use[m]['map'][k]); c=','
+        if ret and ret[-1]==',': ret=ret[:-1]
+    return ret
+
+def true_intent_list(var):
+    lst = var['intent']
+    ret = []
+    for intent in lst:
+        try:
+            c = eval('isintent_%s(var)' % intent)
+        except NameError:
+            c = 0
+        if c:
+            ret.append(intent)
+    return ret
+
+def vars2fortran(block,vars,args,tab='', as_interface=False):
+    """
+    TODO:
+    public sub
+    ...
+    """
+    setmesstext(block)
+    ret=''
+    nout=[]
+    for a in args:
+        if a in block['vars']:
+            nout.append(a)
+    if 'commonvars' in block:
+        for a in block['commonvars']:
+            if a in vars:
+                if a not in nout:
+                    nout.append(a)
+            else:
+                errmess('vars2fortran: Confused?!: "%s" is not defined in vars.\n'%a)
+    if 'varnames' in block:
+        nout.extend(block['varnames'])
+    if not as_interface:
+        for a in list(vars.keys()):
+            if a not in nout:
+                nout.append(a)
+    for a in nout:
+        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))
+        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)
+            if isoptional(vars[a]):
+                ret='%s%soptional %s'%(ret, tab, a)
+            if a in vars and 'typespec' not in vars[a]:
+                continue
+            cont=1
+            for b in block['body']:
+                if a==b['name'] and b['block']=='function':
+                    cont=0;break
+            if cont:
+                continue
+        if a not in vars:
+            show(vars)
+            outmess('vars2fortran: No definition for argument "%s".\n'%a)
+            continue
+        if a==block['name'] and not block['block']=='function':
+            continue
+        if 'typespec' not in vars[a]:
+            if 'attrspec' in vars[a] and 'external' in vars[a]['attrspec']:
+                if a in args:
+                    ret='%s%sexternal %s'%(ret, tab, a)
+                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'])
+        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['*'])
+            else:
+                vardef='%s*%s'%(vardef, selector['*'])
+        else:
+            if 'len' in selector:
+                vardef='%s(len=%s'%(vardef, selector['len'])
+                if 'kind' in selector:
+                    vardef='%s,kind=%s)'%(vardef, selector['kind'])
+                else:
+                    vardef='%s)'%(vardef)
+            elif 'kind' in selector:
+                vardef='%s(kind=%s)'%(vardef, selector['kind'])
+        c=' '
+        if 'attrspec' in vars[a]:
+            attr=[]
+            for l in vars[a]['attrspec']:
+                if l not in ['external']:
+                    attr.append(l)
+            if 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']))
+            c=','
+        if 'intent' in vars[a]:
+            lst = true_intent_list(vars[a])
+            if 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']))
+            c=','
+        if 'depend' in vars[a]:
+            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']:
+                try:
+                    v = eval(v)
+                    v = '(%s,%s)' % (v.real, v.imag)
+                except:
+                    pass
+            vardef='%s :: %s=%s'%(vardef, a, v)
+        else:
+            vardef='%s :: %s'%(vardef, a)
+        ret='%s%s%s'%(ret, tab, vardef)
+    return ret
+######
+
+def crackfortran(files):
+    global usermodules
+    outmess('Reading fortran codes...\n', 0)
+    readfortrancode(files, crackline)
+    outmess('Post-processing...\n', 0)
+    usermodules=[]
+    postlist=postcrack(grouplist[0])
+    outmess('Post-processing (stage 2)...\n', 0)
+    postlist=postcrack2(postlist)
+    return usermodules+postlist
+
+def crack2fortran(block):
+    global f2py_version
+    pyf=crack2fortrangen(block)+'\n'
+    header="""!    -*- f90 -*-
+! Note: the context of this file is case sensitive.
+"""
+    footer="""
+! This file was auto-generated with f2py (version:%s).
+! See http://cens.ioc.ee/projects/f2py2e/
+"""%(f2py_version)
+    return header+pyf+footer
+
+if __name__ == "__main__":
+    files=[]
+    funcs=[]
+    f=1;f2=0;f3=0
+    showblocklist=0
+    for l in sys.argv[1:]:
+        if l=='': pass
+        elif l[0]==':':
+            f=0
+        elif l=='-quiet':
+            quiet=1
+            verbose=0
+        elif l=='-verbose':
+            verbose=2
+            quiet=0
+        elif l=='-fix':
+            if strictf77:
+                outmess('Use option -f90 before -fix if Fortran 90 code is in fix form.\n', 0)
+            skipemptyends=1
+            sourcecodeform='fix'
+        elif l=='-skipemptyends':
+            skipemptyends=1
+        elif l=='--ignore-contains':
+            ignorecontains=1
+        elif l=='-f77':
+            strictf77=1
+            sourcecodeform='fix'
+        elif l=='-f90':
+            strictf77=0
+            sourcecodeform='free'
+            skipemptyends=1
+        elif l=='-h':
+            f2=1
+        elif l=='-show':
+            showblocklist=1
+        elif l=='-m':
+            f3=1
+        elif l[0]=='-':
+            errmess('Unknown option %s\n'%repr(l))
+        elif f2:
+            f2=0
+            pyffilename=l
+        elif f3:
+            f3=0
+            f77modulename=l
+        elif f:
+            try:
+                open(l).close()
+                files.append(l)
+            except IOError as detail:
+                errmess('IOError: %s\n'%str(detail))
+        else:
+            funcs.append(l)
+    if not strictf77 and f77modulename and not skipemptyends:
+        outmess("""\
+  Warning: You have specifyied module name for non Fortran 77 code
+  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)
+
+    postlist=crackfortran(files, funcs)
+    if pyffilename:
+        outmess('Writing fortran code to file %s\n'%repr(pyffilename), 0)
+        pyf=crack2fortran(postlist)
+        f=open(pyffilename, 'w')
+        f.write(pyf)
+        f.close()
+    if showblocklist:
+        show(postlist)