crackfortran --- read fortran (77,90) code and extract declaration information.
    Usage is explained in the comment block below.

Copyright 1999-2004 Pearu Peterson all rights reserved,
Pearu Peterson <pearu@ioc.ee>          
Permission to use, modify, and distribute this software is given under the
terms of the NumPy License.

NO WARRANTY IS EXPRESSED OR IMPLIED.  USE AT YOUR OWN RISK.
$Date: 2005/09/27 07:13:49 $
Pearu Peterson

Variables

• analyzeargs_re_1

  analyzeargs_re_1 = re.compile('\\A[a-z]+[\\w$]*\\Z', re.I)
  
  

• badnames

  badnames = {  }
  
  

• beforethisafter

  ########## Crack line
  

  beforethisafter = (('\\s*(?P<before>%s(?=\\s*(\\b(%s)\\b)))' + '\\s*(?P<this>(\\b(%s)\\b))') + '\\s*(?P<after>%s)\\s*\\Z')
  
  

• beginpattern77

  beginpattern77 = (re.compile((beforethisafter mod ('', groupbegins77, groupbegins77, '.*')), re.I), 'begin')
  
  

• beginpattern90

  beginpattern90 = (re.compile((beforethisafter mod ('', groupbegins90, groupbegins90, '.*')), re.I), 'begin')
  
  

• callfunpattern

  callfunpattern = (re.compile((beforethisafter mod ('', 'callfun', 'callfun', '.*')), re.I), 'callfun')
  
  

• callnameargspattern

  callnameargspattern = re.compile('\\s*(?P<name>\\b[\\w$]+\\b)\\s*@\\(@\\s*(?P<args>.*)\\s*@\\)@\\s*\\Z', re.I)
  
  

• callpattern

  callpattern = (re.compile((beforethisafter mod ('', 'call', 'call', '.*')), re.I), 'call')
  
  

• charselector

  charselector = re.compile('\\s*(\\((?P<lenkind>.*)\\)|[*]\\s*(?P<charlen>.*))\\s*\\Z', re.I)
  
  

• commonpattern

  commonpattern = (re.compile((beforethisafter mod ('', 'common', 'common', '.*')), re.I), 'common')
  
  

• containspattern

  containspattern = (re.compile((beforethisafter mod ('', 'contains', 'contains', '')), re.I), 'contains')
  
  

• crackline_re_1

  crackline_re_1 = re.compile('\\s*(?P<result>\\b[a-z]+[\\w]*\\b)\\s*[=].*', re.I)
  
  

• currentfilename

  currentfilename = ''
  
  

• datapattern

  datapattern = (re.compile((beforethisafter mod ('', 'data', 'data', '.*')), re.I), 'data')
  
  

• debug

  debug = [  ]
  
  

• defaultimplicitrules

  defaultimplicitrules = {  }
  
  

• determineexprtype_re_1

  determineexprtype_re_1 = re.compile('\\A\\(.+?[,].+?\\)\\Z', re.I)
  
  

• determineexprtype_re_2

  determineexprtype_re_2 = re.compile('\\A[+-]?\\d+(_(P<name>[\\w]+)|)\\Z', re.I)
  
  

• determineexprtype_re_3

  determineexprtype_re_3 = re.compile('\\A[+-]?[\\d.]+[\\d+-de.]*(_(P<name>[\\w]+)|)\\Z', re.I)
  
  

• determineexprtype_re_4

  determineexprtype_re_4 = re.compile('\\A\\(.*\\)\\Z', re.I)
  
  

• determineexprtype_re_5

  determineexprtype_re_5 = re.compile('\\A(?P<name>\\w+)\\s*\\(.*?\\)\\s*\\Z', re.I)
  
  

• dimensionpattern

  dimensionpattern = (re.compile((beforethisafter mod ('', 'dimension|virtual', 'dimension|virtual', '.*')), re.I), 'dimension')
  
  

• dolowercase

  dolowercase = 1
  
  

• endifpattern

  endifpattern = (re.compile((beforethisafter mod ('[\\w]*?', endifs, endifs, '[\\w\\s]*')), re.I), 'endif')
  
  

• endifs

  endifs='end\s*(if|do|where|select|while|forall)'
  

  endifs = '(end\\s*(if|do|where|select|while|forall))|(module\\s*procedure)'
  
  

• endpattern

  endpattern = (re.compile((beforethisafter mod ('', groupends, groupends, '[\\w\\s]*')), re.I), 'end')
  
  

• entrypattern

  entrypattern = (re.compile((beforethisafter mod ('', 'entry', 'entry', '.*')), re.I), 'entry')
  
  

• errmess

  errmess = sys.stderr.write
  
  

• expectbegin

  expectbegin = 1
  
  

• externalpattern

  externalpattern = (re.compile((beforethisafter mod ('', 'external', 'external', '.*')), re.I), 'external')
  
  

• f2py_version

  f2py_version = __version__.version
  
  

• f2pyenhancementspattern

  # Non-fortran and f2py-specific statements
  

  f2pyenhancementspattern = (re.compile((beforethisafter mod ('', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', 'threadsafe|fortranname|callstatement|callprotoargument|usercode|pymethoddef', '.*')), (re.I | re.S)), 'f2pyenhancements')
  
  

• f77modulename

  f77modulename = ''
  
  

• f90modulevars

  f90modulevars = {  }
  
  

• filepositiontext

  filepositiontext = ''
  
  

• formatpattern

  formatpattern = (re.compile((beforethisafter mod ('', 'format', 'format', '.*')), re.I), 'format')
  
  

• fortrantypes

  #
  

  fortrantypes = 'character|logical|integer|real|complex|double\\s*(precision\\s*(complex|)|complex)|type(?=\\s*\\([\\w\\s,=(*)]*\\))|byte'
  
  

• functionpattern

  functionpattern = (re.compile((beforethisafter mod ('([a-z]+[\\w\\s(=*+-/)]*?|)', 'function', 'function', '.*')), re.I), 'begin')
  
  

• getlincoef_re_1

  getlincoef_re_1 = re.compile('\\A\\b\\w+\\b\\Z', re.I)
  
  

• gotnextfile

  gotnextfile = 1
  
  

• groupbegins77

  modulepattern=re.compile(beforethisafter%('[a-z\s]*?','module','module','.*'),re.I),'begin'
  
  

  groupbegins77 = 'program|block\\s*data'
  
  

• groupbegins90

  groupbegins90 = (groupbegins77 + '|module|python\\s*module|interface|type(?!\\s*\\()')
  
  

• groupcounter

  groupcounter = 0
  
  

• groupends

  groupends = 'end|endprogram|endblockdata|endmodule|endpythonmodule|endinterface'
  
  

• grouplist

  grouplist = { Name('groupcounter') : List(()) }
  
  

• ignorecontains

  ignorecontains = 1
  
  

• implicitpattern

  implicitpattern = (re.compile((beforethisafter mod ('', 'implicit', 'implicit', '.*')), re.I), 'implicit')
  
  

• include_paths

  include_paths = [  ]
  
  

• intentpattern

  intentpattern = (re.compile((beforethisafter mod ('', 'intent|depend|note|check', 'intent|depend|note|check', '\\s*\\(.*?\\).*')), re.I), 'intent')
  
  

• intrisicpattern

  intrisicpattern = (re.compile((beforethisafter mod ('', 'intrisic', 'intrisic', '.*')), re.I), 'intrisic')
  
  

• invbadnames

  invbadnames = {  }
  
  

• is_f_file

  is_f_file = re.compile('.*[.](for|ftn|f77|f)\\Z', re.I).match
  
  

• kindselector

  kindselector = re.compile('\\s*(\\(\\s*(kind\\s*=)?\\s*(?P<kind>.*)\\s*\\)|[*]\\s*(?P<kind2>.*?))\\s*\\Z', re.I)
  
  

• lenarraypattern

  lenarraypattern = re.compile('\\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)
  
  

• lenkindpattern

  lenkindpattern = re.compile('\\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)
  
  

• multilinepattern

  multilinepattern = (re.compile("\\s*(?P<before>''')(?P<this>.*?)(?P<after>''')\\s*\\Z", re.S), 'multiline')
  
  

• nameargspattern

  nameargspattern = re.compile('\\s*(?P<name>\\b[\\w$]+\\b)\\s*(@\\(@\\s*(?P<args>[\\w\\s,]*)\\s*@\\)@|)\\s*(result(\\s*@\\(@\\s*(?P<result>\\b[\\w$]+\\b)\\s*@\\)@|))*\\s*\\Z', re.I)
  
  

• namepattern

  ####
  

  namepattern = re.compile('\\s*(?P<name>\\b[\\w]+\\b)\\s*(?P<after>.*)\\s*\\Z', re.I)
  
  

• neededmodule

  neededmodule = -Const(1)
  
  

• onlyfuncs

  onlyfuncs = [  ]
  
  

• optionalpattern

  optionalpattern = (re.compile((beforethisafter mod ('', 'optional', 'optional', '.*')), re.I), 'optional')
  
  

• parameterpattern

  parameterpattern = (re.compile((beforethisafter mod ('', 'parameter', 'parameter', '\\s*\\(.*')), re.I), 'parameter')
  
  

• previous_context

  previous_context = None
  
  

• privatepattern

  privatepattern = (re.compile((beforethisafter mod ('', 'private', 'private', '.*')), re.I), 'private')
  
  

• publicpattern

  publicpattern = (re.compile((beforethisafter mod ('', 'public', 'public', '.*')), re.I), 'public')
  
  

• pyffilename

  pyffilename = ''
  
  

• quiet

  quiet = 0
  
  

• real16pattern

  real16pattern = re.compile('([-+]?(?:\\d+(?:\\.\\d*)?|\\d*\\.\\d+))[dD]((?:[-+]?\\d+)?)')
  
  

• real8pattern

  real8pattern = re.compile('([-+]?((?:\\d+(?:\\.\\d*)?|\\d*\\.\\d+))[eE]((?:[-+]?\\d+)?)|(\\d+\\.\\d*))')
  
  

• requiredpattern

  requiredpattern = (re.compile((beforethisafter mod ('', 'required', 'required', '.*')), re.I), 'required')
  
  

• selectpattern

  selectpattern = re.compile('\\s*(?P<this>(@\\(@.*?@\\)@|[*][\\d*]+|[*]\\s*@\\(@.*?@\\)@|))(?P<after>.*)\\Z', re.I)
  
  

• skipblocksuntil

  skipblocksuntil = -Const(1)
  
  

• skipemptyends

  skipemptyends = 0
  
  

• skipfuncs

  skipfuncs = [  ]
  
  

• skipfunctions

  skipfunctions = [  ]
  
  

• sourcecodeform

  sourcecodeform = 'fix'
  
  

• strictf77

  Global flags:
  

  strictf77 = 1
  
  

• subroutinepattern

  subroutinepattern = (re.compile((beforethisafter mod ('[a-z\\s]*?', 'subroutine', 'subroutine', '.*')), re.I), 'begin')
  
  

• tabchar

  tabchar = (4 * ' ')
  
  

• typespattern

  typespattern = (re.compile((beforethisafter mod ('', fortrantypes, fortrantypes, '.*')), re.I), 'type')
  
  

• typespattern4implicit

  typespattern4implicit = re.compile((beforethisafter mod ('', (fortrantypes + '|static|automatic|undefined'), (fortrantypes + '|static|automatic|undefined'), '.*')), re.I)
  
  

• usepattern

  usepattern = (re.compile((beforethisafter mod ('', 'use', 'use', '.*')), re.I), 'use')
  
  

• usermodules

  usermodules = [  ]
  
  

• verbose

  verbose = 1
  
  

• word_pattern

  word_pattern = re.compile('\\b[a-z][\\w$]*\\b', re.I)
  
  

Function summary

• analyzeargs(block)
• analyzebody(block, args, tab = '')
• analyzecommon(block)
• analyzeline(m, case, line)
• analyzevars(block)
• appenddecl(decl, decl2, force = 1)
• appendmultiline(group, context_name, ml)
• buildimplicitrules(block)
• common2fortran(common, tab = '')
• crack2fortran(block)
• crack2fortrangen(block, tab = """ """)
• crackfortran(files)
• crackline(line, reset = 0)
• cracktypespec(typespec, selector)
• cracktypespec0(typespec, ll)
• determineexprtype(expr, vars, rules = { })
• get_parameters(vars, global_params = { })
• get_sorted_names(vars)
• get_usedict(block)
• get_useparameters(block, param_map = None)
• getarrlen(dl, args, star = '*')
• getblockname(block, unknown = 'unknown')
• getextension(name)
• getlincoef(e, xset)
• is_free_format(file)
• markinnerspaces(line)
• markoutercomma(line, comma = ',')
• markouterparen(line)
• myeval(e, g = None, l = None)
• outmess(line, flag = 1)
• postcrack(block, args = None, tab = '')
• postcrack2(block, tab = '', param_map = None)
• readfortrancode(ffile, dowithline = show, istop = 1)
• removespaces(expr)
• rmbadname(names)
• rmbadname1(name)
• setattrspec(decl, attr, force = 0)
• setcharselector(decl, sel, force = 0)
• setkindselector(decl, sel, force = 0)
• setmesstext(block)
• show(o, f = 0)
• sortvarnames(vars)
• true_intent_list(var)
• undo_rmbadname(names)
• undo_rmbadname1(name)
• unmarkouterparen(line)
• updatevars(typespec, selector, attrspec, entitydecl)
• use2fortran(use, tab = '')
• vars2fortran(block, vars, args, tab = '')

Functions

• analyzeargs(block)

• analyzebody(block, args, tab = '')

• analyzecommon(block)

• analyzeline(m, case, line)

• analyzevars(block)

• appenddecl(decl, decl2, force = 1)

• appendmultiline(group, context_name, ml)

• buildimplicitrules(block)

• common2fortran(common, tab = '')

• crack2fortran(block)

• crack2fortrangen(block, tab = """ """)

• crackfortran(files)

• 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].
      

• cracktypespec(typespec, selector)

• cracktypespec0(typespec, ll)

• determineexprtype(expr, vars, rules = { })

• get_parameters(vars, global_params = { })

• get_sorted_names(vars)

• get_usedict(block)

• get_useparameters(block, param_map = None)

• getarrlen(dl, args, star = '*')

• getblockname(block, unknown = 'unknown')

• getextension(name)

• getlincoef(e, xset)

• is_free_format(file)

  Check if file is in free format Fortran.

• markinnerspaces(line)

• markoutercomma(line, comma = ',')

• markouterparen(line)

• myeval(e, g = None, l = None)

• outmess(line, flag = 1)

• postcrack(block, args = None, tab = '')

      TODO:
            function return values
            determine expression types if in argument list
      

• postcrack2(block, tab = '', param_map = None)

• 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.
      

• removespaces(expr)

• rmbadname(names)

• rmbadname1(name)

• setattrspec(decl, attr, force = 0)

• setcharselector(decl, sel, force = 0)

• setkindselector(decl, sel, force = 0)

• setmesstext(block)

• show(o, f = 0)

• sortvarnames(vars)

• true_intent_list(var)

• undo_rmbadname(names)

• undo_rmbadname1(name)

• unmarkouterparen(line)

• updatevars(typespec, selector, attrspec, entitydecl)

• use2fortran(use, tab = '')

• vars2fortran(block, vars, args, tab = '')

      TODO:
      public sub
      ...
      

Imported names