PageRenderTime 91ms CodeModel.GetById 25ms RepoModel.GetById 0ms app.codeStats 0ms

/pytel/parsers/parserFortran.py

http://github.com/ogoe/OpenTelemac-svn-mirror
Python | 1099 lines | 1038 code | 11 blank | 50 comment | 5 complexity | 2bea19292cc0973fe661361d8b3e89ed MD5 | raw file
Possible License(s): GPL-2.0 
    

  1. """@author Sebastien E. Bourban and Noemie Durand
    2. 

  2. """
    3. 

  3. """@note ... this work is based on a collaborative effort between
    4. 

  4.   .________.                                                          ,--.
    5. 

  5.   |        |                                                      .  (  (
    6. 

  6.   |,-.    /   HR Wallingford                EDF - LNHE           / \_ \_/ .--.
    7. 

  7.   /   \  /    Howbery Park,                 6, quai Watier       \   )   /_   )
    8. 

  8.    ,.  `'     Wallingford, Oxfordshire      78401 Cedex           `-'_  __ `--
    9. 

  9.   /  \   /    OX10 8BA, United Kingdom      Chatou, France        __/ \ \ `.
    10. 

  10.  /    `-'|    www.hrwallingford.com         innovation.edf.com   |    )  )  )
    11. 

  11. !________!                                                        `--'   `--
    12. 

  12. """
    13. 

  13. """@history 28/04/2011 -- Sebastien E. Bourban
    14. 

  14.       Now supports SYSTELCFG as a directory (old Perl version, to which
    15. 

  15.       systel.cfg is added) or as a file.
    16. 

  16. """
    17. 

  17. """@history 30/04/2011 -- Sebastien E. Bourban
    18. 

  18.       Upgrade made to config parsing to include the option to reset the
    19. 

  19.       version and the root from the command line option:
    20. 

  20.       -v <version>, reset the version read in the config file with this
    21. 

  21.       -r <root>, reset the root path read in the config file with this
    22. 

  22. """
    23. 

  23. """@brief
    24. 

  24. """
    25. 

    26. 

  26. # _____          ___________________________________________________
    27. 

  27. # ____/ Imports /__________________________________________________/
    28. 

  28. #
    29. 

  29. # ~~> dependencies towards standard python
    30. 

  30. import re
    31. 

  31. import sys
    32. 

  32. from os import path,walk
    33. 

  33. # ~~> dependencies towards the root of pytel
    34. 

  34. from config import OptionParser,parseConfigFile, parseConfig_CompileTELEMAC
    35. 

  35. # ~~> dependencies towards other pytel/modules
    36. 

  36. from utils.files import getTheseFiles,isNewer,addToList
    37. 

  37. from utils.progressbar import ProgressBar
    38. 

  38. 

  39. debug = False
    40. 

  40. 

  41. # _____               ______________________________________________
    42. 

  42. # ____/ Instructions /_____________________________________________/
    43. 

  43. #
    44. 

  44. 

  45. listINSTRUCTION = ['ALLOCATE','ASSIGN',  \
    46. 

  46.    'BACKSPACE','BLOCK DATA',  \
    47. 

  47.    'CALL','CASE','CLOSE','COMMON','CYCLE','CONTINUE',  \
    48. 

  48.    'DATA','DEALLOCATE','DEFAULT','DO',  \
    49. 

  49.    'ELSE','ELSEIF','ENDIF','ENDDO','END','ENDFILE','EQUIVALENCE','EXIT',  \
    50. 

  50.    'FORMAT',  \
    51. 

  51.    'GO','TO','GOTO',  \
    52. 

  52.    'IF','IMPLICIT NONE','INCLUDE','INQUIRE','INTERFACE',  \
    53. 

  53.    'MULTIPLE',  \
    54. 

  54.    'NAMELIST','NULLIFY',  \
    55. 

  55.    'OPEN',  \
    56. 

  56.    'PRINT',  \
    57. 

  57.    'READ','REWIND','RETURN',  \
    58. 

  58.    'SELECT','STOP','SAVE', \
    59. 

  59.    'THEN', 'USE',  \
    60. 

  60.    'WHILE','WHERE','WRITE' ]
    61. 

  61. 

  62. listINTRINSIC = [ \
    63. 

  63.    'ABS', 'ACCESS','ACHAR','ACOS','ACOSH','ADJUSTL','ADJUSTR','AIMAG','AINT','ALARM','ALL', \
    64. 

  64.    'ALLOCATED','AND','ANINT','ANY','ASIN','ASINH','ASSOCIATED','ATAN','ATAN2','ATANH', \
    65. 

  65.    'BESJ0','BESJ1','BESJN','BESY0','BESY1','BESYN','BIT_SIZE','BTEST', \
    66. 

  66.    'CEILING','CHAR','CHDIR','CHMOD','CMPLX','COMMAND_ARGUMENT_COUNT','CONJG','COS','COSH','COUNT','CPU_TIME','CSHIFT','CTIME', \
    67. 

  67.    'DATE_AND_TIME','DBLE','DCMPLX','DFLOAT','DIGITS','DIM','DOT_PRODUCT','DPROD','DREAL','DTIME', \
    68. 

  68.    'DMAX1','DMIN1','DMOD','DSQRT','DSIN','DCOS','DTAN','DABS','DATAN','DATAN2','DEXP','DLOG','DSINH','DCOSH','DTANH', \
    69. 

  69.    'EOSHIFT','EPSILON','ERF','ERFC','ETIME','EXIT','EXP','EXPONENT', \
    70. 

  70.    'FDATE','FGET','FGETC','FLOAT','FLOOR','FLUSH','FNUM','FPUT','FPUTC','FRACTION','FREE','FSEEK','FSTAT','FTELL', \
    71. 

  71.    'GERROR','GETARG','GET_COMMAND','GET_COMMAND_ARGUMENT','GETCWD','GETENV','GET_ENVIRONMENT_VARIABLE','GETGID','GETLOG','GETPID','GETUID','GMTIME', \
    72. 

  72.    'HOSTNM','HUGE', \
    73. 

  73.    'IACHAR','IAND','IARGC','IBCLR','IBITS','IBSET','ICHAR','IDATE','IEOR','IERRNO', \
    74. 

  74.    'INDEX','IDINT','INT','INT2','INT8','IOR','IRAND','ISATTY','ISHFT','ISHFTC','ITIME', \
    75. 

  75.    'KILL','KIND', \
    76. 

  76.    'LBOUND','LEN','LEN_TRIM','LGE','LGT','LINK','LLE','LLT','LNBLNK','LOC','LOG','LOG10','LOGICAL','LONG','LSHIFT','LSTAT','LTIME', \
    77. 

  77.    'MALLOC','MATMUL','MAX','MAX0','MAXEXPONENT','MAXLOC','MAXVAL','MCLOCK','MCLOCK8','MERGE','MIN','MIN0','MINEXPONENT','MINLOC','MINVAL','MOD','MODULO','MOVE_ALLOC','MVBITS', \
    78. 

  78.    'NEAREST','NEW_LINE','NINT','NOT','NULL', \
    79. 

  79.    'OR', \
    80. 

  80.    'PACK','PERROR','PRECISION','PRESENT','PRODUCT', \
    81. 

  81.    'RADIX','RANDOM_NUMBER','RANDOM_SEED','RAND','RANGE','RAN','REAL','RENAME','REPEAT','RESHAPE','RRSPACING','RSHIFT', \
    82. 

  82.    'SCALE','SCAN','SECNDS','SECOND','SELECTED_INT_KIND','SELECTED_REAL_KIND','SET_EXPONENT','SHAPE','SIGN','SIGNAL','SIN','SINH','SIZE', \
    83. 

  83.    'SLEEP','SNGL','SPACING','SPREAD','SQRT','SRAND','STAT','SUM','SYMLNK','SYSTEM','SYSTEM_CLOCK', \
    84. 

  84.    'TAN','TANH','TIME','TIME8','TINY','TRANSFER','TRANSPOSE','TRIM','TTYNAM', \
    85. 

  85.    'UBOUND','UMASK','UNLINK','UNPACK','VERIFY','XOR' ]
    86. 

  86. 

  87. # _____                             ________________________________
    88. 

  88. # ____/ Global Regular Expressions /_______________________________/
    89. 

  89. #
    90. 

  90. """
    91. 

  91.    
    92. 

  92. """
    93. 

  93. #?beforethisafter=r'\s*(?P<before>%s(?=\s*(\b(%s)\b)))'+ \
    94. 

  94. #?                          r'\s*(?P<this>(\b(%s)\b))'+ \
    95. 

  95. #?                          r'\s*(?P<after>%s)\s*\Z'
    96. 

  96. beforethisafter=r'(?P<before>%s(?=\s?(\b(%s)\b)))'+ \
    97. 

  97.                           r'\s?(?P<this>(\b(%s)\b))'+ \
    98. 

  98.                           r'\s?(?P<after>%s)\Z'
    99. 

  99. 

  100. #?emptyline = re.compile(r'\s*\Z') #,re.I)
    101. 

  101. emptyline = re.compile(r'\Z') #,re.I)
    102. 

  102. 

  103. f77comment = re.compile(r'[C!#*]') #,re.I)
    104. 

  104. f77continu2 = re.compile(r'(\s{5}\S\s*)(?P<line>.*)') #,re.I)
    105. 

  105. #?f90comment = re.compile(r'(?P<line>([^"]*"[^"]*"[^"!]*|[^\']*\'[^\']*\'[^\'!]*|[^!]*))!{1}(?P<rest>.*)') #,re.I)
    106. 

  106. f90comment = re.compile(r'(?P<line>([^"]*"[^"]*"[^"!]*|[^\']*\'[^\']*\'[^\'!]*|[^!]*))!{1}(?P<rest>[^\Z]*)') #,re.I)
    107. 

  107. #?f90continu1 = re.compile(r'(?P<line>.*)&\s*\Z') #,re.I)
    108. 

  108. f90continu1 = re.compile(r'(?P<line>.*)&\Z') #,re.I)
    109. 

  109. #?f90continu2 = re.compile(r'(\s*&\s*)(?P<line>.*)&\s*\Z') #,re.I)
    110. 

  110. f90continu2 = re.compile(r'(&\s?)(?P<line>.*)&\Z') #,re.I)
    111. 

  111. #?f90continu3 = re.compile(r'(\s*&\s*)(?P<line>.*)') #,re.I)
    112. 

  112. f90continu3 = re.compile(r'(&\s?)(?P<line>.*)') #,re.I)
    113. 

  113. 

  114. var_dquots = re.compile(r'(?P<dquot>".*?")') #,re.I)
    115. 

  115. var_squots = re.compile(r"(?P<squot>'.*?')") #,re.I)
    116. 

  116. var_bracks = re.compile(r'(?P<brack>\([\w,*\s+-/:]*?\))') #,re.I)
    117. 

  117. 

  118. # no (\+|\-)? to capture the sign if there ... different from the utils version
    119. 

  119. #?var_doublep = re.compile(r'\s*(?P<before>.*?)(?P<number>\b(|[^a-zA-Z(,])(?:(\d+(|\.)\d*[dDeE](\+|\-)?\d+|\d+\.\d+)(\b|[^a-zA-Z,)])))(?P<after>.*?)\s*\Z') #,re.I)
    120. 

  120. var_doublep = re.compile(r'(?P<before>.*?)(?P<number>\b(|[^a-zA-Z(,])(?:(\d+(|\.)\d*[dDeE](\+|\-)?\d+|\d+\.\d+)(\b|[^a-zA-Z,)])))(?P<after>[^\Z]*)\Z') #,re.I)
    121. 

  121. #?var_integer = re.compile(r'\s*(?P<before>.*?)(?P<number>\b(|[^a-zA-Z(,])(?:(\d+)(\b|[^a-zA-Z,)])))(?P<after>.*?)\s*\Z') #,re.I)
    122. 

  122. var_integer = re.compile(r'(?P<before>.*?)(?P<number>\b(|[^a-zA-Z(,])(?:(\d+)(\b|[^a-zA-Z,)])))(?P<after>[^\Z]*)\Z') #,re.I)
    123. 

  123. f90logic = '(FALSE|TRUE|EQ|NE|GT|LT|GE|LE|OR|AND|XOR)'
    124. 

  124. #?var_logical = re.compile(r'.*?(?P<logic>\.\s*?%s\s*?\.).*?'%(f90logic)) #,re.I)
    125. 

  125. var_logical = re.compile(r'[^\.](?P<logic>\.\s?%s\s?\.)'%(f90logic)) #,re.I)
    126. 

  126. #?var_pointer = re.compile(r'\s*(?P<before>.*?)(?P<this>%\w+)(?P<after>.*?)\s*\Z') #,re.I)
    127. 

  127. var_pointer = re.compile(r'(?P<before>.*?)(?P<this>%\w+)(?P<after>[^\Z]*)\Z') #,re.I)
    128. 

  128. #?var_word = re.compile(r'\s*(?P<before>.*?)(?P<word>\b\w+?\b)(?P<after>.*?)\s*\Z') #,re.I)
    129. 

  129. var_word = re.compile(r'(?P<before>.*?)(?P<word>\b\w+?\b)(?P<after>[^\Z]*)\Z') #,re.I)
    130. 

  130. 

  131. #?var_assocs = re.compile(r'\s*(?P<before>.*?)(?P<name>\s*\b\w+?\b\s*=\s*)(?P<after>.*?)\s*\Z') #,re.I)
    132. 

  132. var_assocs = re.compile(r'(?P<before>.*?)(?P<name>\s?\b\w+?\b\s?=\s?)(?P<after>[^\Z]*)\Z') #,re.I)
    133. 

  133. #?var_equals = re.compile(r'\s*(?P<before>.*?)(?P<name>\s*\b\w+?\b)(?P<value>\s*=[^,]*)(?P<after>.*?)\s*\Z') #,re.I)
    134. 

  134. var_equals = re.compile(r'(?P<before>.*?)(?P<name>\s?\b\w+?\b)(?P<value>\s?=[^,]*)(?P<after>[^\Z]*)\Z') #,re.I)
    135. 

  135. #?var_operand = re.compile(r'\s*(?P<before>.*?)(?=[^\s])\W+(?P<after>.*?)\s*\Z') #,re.I)
    136. 

  136. var_operand = re.compile(r'(?P<before>.*?)(?=[^\s])\W+(?P<after>[^\Z]*)\Z') #,re.I)
    137. 

  137. #?argnames = re.compile(r'\s*(?P<name>\b\w+\b)\s*?(|\((?P<args>.*)\))\s*\Z') #,re.I)
    138. 

  138. argnames = re.compile(r'(?P<name>\b\w+\b)\s?(|\((?P<args>.*)\))\Z') #,re.I)
    139. 

  139. 

  140. #?itf_title = re.compile(r'\s*?\bINTERFACE\b(|\s+?(?P<name>\w+).*?)\s*\Z') #,re.I)
    141. 

  141. itf_title = re.compile(r'\bINTERFACE\b(|\s(?P<name>\w+)[^\Z]*)\Z') #,re.I)
    142. 

  142. #?itf_uless = re.compile(r'\s*?\bMODULE\s+?PROCEDURE\s+?(?P<name>\w+).*?\s*\Z') #,re.I)
    143. 

  143. itf_uless = re.compile(r'\bMODULE\sPROCEDURE\s(?P<name>\w+)[^\Z]*\Z') #,re.I)
    144. 

  144. #?itf_close = re.compile(r'\s*?\bEND\s+INTERFACE\b(|\s+?(?P<name>\w+).*?)\s*\Z') #,re.I)
    145. 

  145. itf_close = re.compile(r'\bEND\sINTERFACE\b(|\s(?P<name>\w+)[^\Z]*)\Z') #,re.I)
    146. 

  146. #?use_title = re.compile(r'\s*?\bUSE\b\s+?(?P<name>\b\w+\b)\s*(|,\s*(?P<after>.*?))\s*\Z') #,re.I)
    147. 

  147. use_title = re.compile(r'\bUSE\b\s(?P<name>\b\w+\b)\s?(|,\s?(?P<after>[^\Z]*))\Z') #,re.I)
    148. 

  148. #?xtn_title = re.compile(r'.*?\bEXTERNAL\b(.*?::)?\s*?(?P<vars>.*?)\s*\Z') #,re.I)
    149. 

  149. xtn_title = re.compile(r'.*?\bEXTERNAL\b(.*?::)?\s?(?P<vars>[^\Z]*)\Z') #,re.I)
    150. 

  150. #?itz_title = re.compile(r'\s*?\bINTRINSIC\b(.*?::)?\s*?(?P<vars>.*?)\s*\Z') #,re.I)
    151. 

  151. itz_title = re.compile(r'\bINTRINSIC\b([^:]?::)?\s?(?P<vars>[^\Z]*)\Z') #,re.I)
    152. 

  152. #?implictNone = re.compile(r'\s*?\bIMPLICIT\s+NONE\b\s*\Z') #,re.I)
    153. 

  153. implictNone = re.compile(r'\bIMPLICIT\sNONE\b\Z') #,re.I)
    154. 

  154. #?inc_title = re.compile(r'\s*?\bINCLUDE\b\s*(?P<file>.*?)\s*\Z') #,re.I)
    155. 

  155. inc_title = re.compile(r'\bINCLUDE\b\s?(?P<file>[^\Z]*)\Z') #,re.I)
    156. 

  156. #?cmn_title = re.compile(r'\s*?\bCOMMON\b\s*?/\s*(?P<name>\w*)\s*/\s*?(?P<after>.*?)\s*\Z') #,re.I)
    157. 

  157. cmn_title = re.compile(r'\bCOMMON\b\s?/\s?(?P<name>\w*)\s?/\s?(?P<after>[^\Z]*)\Z') #,re.I)
    158. 

  158. #?ctn_title = re.compile(r'\s*?\bCONTAINS\b\s*\Z') #,re.I)
    159. 

  159. ctn_title = re.compile(r'\bCONTAINS\b\Z') #,re.I)
    160. 

  160. #?def_title = re.compile(r'\s*?\bTYPE\b\s+?(?P<name>\b\w+\b)\s*\Z') #,re.I)
    161. 

  161. def_title = re.compile(r'\bTYPE\b\s(?P<name>\b\w+\b)\Z') #,re.I)
    162. 

  162. #?def_close = re.compile(r'\s*?\bEND TYPE\b\s+?(?P<name>\b\w+\b)\s*\Z') #,re.I)
    163. 

  163. def_close = re.compile(r'\bEND TYPE\b\s(?P<name>\b\w+\b)\Z') #,re.I)
    164. 

  164. 

  165. #?als_core = re.compile(r'(?P<before>.*?)(?P<alias>\b\w([\w%]|\([\w(,:)%]*\))*)\s*=>\s*(?P<link>\b\w+?\b)(?P<after>.*?)\s*\Z') #,re.I)
    166. 

  166. als_core = re.compile(r'(?P<before>.*?)(?P<alias>\b\w([\w%]|\([\w(,:)%]*\))*)\s?=>\s?(?P<link>\b\w+?\b)(?P<after>[^\Z]*)\Z') #,re.I)
    167. 

  167. #?var_format = re.compile(r'\s*(?P<before>.*?)\d+?\s+?\bFORMAT\b(?P<after>.*?)\s*\Z') #,re.I)
    168. 

  168. var_format = re.compile(r'(?P<before>.*?)\d+?\s\bFORMAT\b(?P<after>[^\Z]*)\Z') #,re.I)
    169. 

  169. 

  170. #?cls_title = re.compile(r".*?\bCALL\b\s+?(?P<name>\b\w+\b)\s*?(|\((?P<args>[\w\s\*\+\-\/=,%('.:)]*)\))\s*\Z") #,re.I)
    171. 

  171. cls_title = re.compile(r".*?\bCALL\b\s(?P<name>\b\w+\b)\s?(|\((?P<args>[\w\s\*\+\-\/=,%('.:)]*)\))\Z") #,re.I)
    172. 

  172. #?fct_title = re.compile(r"\s*(?P<before>.*?)(?P<name>\b\w+\b)\s*?\((?P<args>[\w\s\*\+\-\/=,%('.:)]*)\)(?P<after>.*?)\s*\Z") #,re.I)
    173. 

  173. fct_title = re.compile(r"(?P<before>.*?)(?P<name>\b\w+\b)\s?\((?P<args>[\w\s\*\+\-\/=,%('.:)]*)\)(?P<after>[^\Z]*)\Z") #,re.I)
    174. 

  174. #?f90types = '(CHARACTER|LOGICAL|INTEGER|REAL|COMPLEX|DOUBLE\s*(PRECISION\s*(COMPLEX|)|COMPLEX))\s*?(\**\s*?\d+|\**\(.*?\))?|TYPE\s*\([\w\s,=(*)]*?\)'
    175. 

  175. f90types = '(CHARACTER|LOGICAL|INTEGER|REAL|COMPLEX|DOUBLE\s?(PRECISION\s?(COMPLEX|)|COMPLEX))\s?(\**\s?\d+|\**\(.*?\))?|TYPE\s?\([\w\s,=(*)]*?\)'
    176. 

  176. #?f90xport = '(PUBLIC|PRIVATE|SAVE|PARAMETER|DATA|SEQUENCE)\s*?'
    177. 

  177. f90xport = '(PUBLIC|PRIVATE|SAVE|PARAMETER|DATA|SEQUENCE)'
    178. 

  178. #?f95_name = re.compile(r"\s*(?P<name>\b\w+\b)\s*?:\s*(?P<after>.*?)\s*\Z") #,re.I)
    179. 

  179. f95_name = re.compile(r"(?P<name>\b\w+\b)\s?:\s?(?P<after>[^\Z]*)\Z") #,re.I)
    180. 

  180. #?typ_args = re.compile(r'\s*?(.*?::)?\s*?(?P<vars>.*?)\s*\Z',re.I)
    181. 

  181. typ_args = re.compile(r'(.*?::)?\s?(?P<vars>[^\Z]*)\Z') #,re.I)
    182. 

  182. #?typ_name = re.compile(r'\s*?(?P<type>(%s))\s*?\Z'%(f90types)) #,re.I)
    183. 

  183. typ_name = re.compile(r'(?P<type>(%s))\Z'%(f90types)) #,re.I)
    184. 

  184. #?typ_title = re.compile(r'\s*?(?P<type>(%s))\s*?(?P<after>.*?)\s*\Z'%(f90types)) #,re.I)
    185. 

  185. typ_name = re.compile(r'(?P<type>(%s))\Z'%(f90types)) #,re.I)
    186. 

  186. #?typ_title = re.compile(r'\s*?(?P<type>(%s))\s*?(?P<after>.*?)\s*\Z'%(f90types)) #,re.I)
    187. 

  187. typ_title = re.compile(r'(?P<type>(%s))\s?(?P<after>[^\Z]*)\Z'%(f90types)) #,re.I)
    188. 

  188. #?typ_xport = re.compile(r'\s*?(?P<type>(%s))\s*?(?P<after>.*?)\s*\Z'%(f90xport)) #,re.I)
    189. 

  189. typ_xport = re.compile(r'(?P<type>(%s))\s?(?P<after>[^\Z]*)\Z'%(f90xport)) #,re.I)
    190. 

  190. 

  191. #?pcl_title = re.compile(r'\s*?((?P<type>[\w\s(=*+-/)]*?)|)\b(?P<object>(PROGRAM|FUNCTION|SUBROUTINE|MODULE))\b\s*(?P<after>.*?)\s*?(\bRESULT\b\s*?(?P<result>\w+[\w\s]*)|)\s*\Z') #,re.I)
    192. 

  192. pcl_title = re.compile(r'((?P<type>[\w\s(=*+-/)]*?)|)\b(?P<object>(PROGRAM|FUNCTION|SUBROUTINE|MODULE))\b\s?(?P<after>.*?)\s?(\bRESULT\b\s?(?P<result>\w+[\w\s]*)|)\Z') #,re.I)
    193. 

  193. #?pcl_close = re.compile(r'\s*?\bEND\b(|\s+?(?P<object>(PROGRAM|FUNCTION|SUBROUTINE|MODULE))(|\s+?(?P<name>\w+?)))\s*\Z') #,re.I)
    194. 

  194. pcl_close = re.compile(r'\bEND\b(|\s(?P<object>(PROGRAM|FUNCTION|SUBROUTINE|MODULE))(|\s(?P<name>\w+?)))\Z') #,re.I)
    195. 

  195. 

  196. # _____                         ____________________________________
    197. 

  197. # ____/ FORTRAN Parser Toolbox /___________________________________/
    198. 

  198. #
    199. 

  199. 

  200. def cleanSpaces(istr):
    201. 

  201.    return istr.strip().replace('  ',' ').replace('  ',' ')
    202. 

  202. 

  203. def cleanAssoc(istr):
    204. 

  204.    while 1:
    205. 

  205.       ostr = istr
    206. 

  206.       proc = re.match(var_assocs,ostr)
    207. 

  207.       if proc:
    208. 

  208.          istr = proc.group('before')+proc.group('after')
    209. 

  209.       if ostr == istr: break
    210. 

  210.    return cleanSpaces(ostr)
    211. 

  211. 

  212. def cleanBracks(istr):
    213. 

  213.    while 1:
    214. 

  214.       ostr = istr
    215. 

  215.       for brack in re.findall(var_bracks,ostr):
    216. 

  216.          istr = istr.replace(brack,'')
    217. 

  217.       if ostr == istr: return cleanSpaces(ostr)
    218. 

  218. 

  219. def cleanEquals(istr):
    220. 

  220.    while 1:
    221. 

  221.       ostr = istr
    222. 

  222.       proc = re.match(var_equals,ostr)
    223. 

  223.       if proc:
    224. 

  224.          istr = proc.group('before')+proc.group('name')+proc.group('after')
    225. 

  225.       if ostr == istr: break
    226. 

  226.    return cleanSpaces(ostr)
    227. 

  227. 

  228. def cleanFormatted(istr):
    229. 

  229.    proc = re.match(var_format,istr)
    230. 

  230.    if proc: istr = ''
    231. 

  231.    return istr.strip()
    232. 

  232. 

  233. def cleanInstruction(istr,list):
    234. 

  234.    ostr = ''
    235. 

  235.    while 1:
    236. 

  236.       proc = re.match(var_word,istr)
    237. 

  237.       if proc:
    238. 

  238.          ostr = ostr + ' ' + proc.group('before')
    239. 

  239.          istr = proc.group('after')
    240. 

  240.          instr = proc.group('word')
    241. 

  241.          if instr not in list: ostr = ostr + ' ' + instr
    242. 

  242.       else: break
    243. 

  243.    return cleanSpaces(ostr)
    244. 

  244. 

  245. def cleanLogicals(istr):
    246. 

  246.    while 1:
    247. 

  247.       ostr = istr
    248. 

  248.       proc = re.match(var_logical,ostr)
    249. 

  249.       if proc:
    250. 

  250.          istr = istr.replace(proc.group('logic'),' ')
    251. 

  251.       if ostr == istr: break
    252. 

  252.    return cleanSpaces(ostr)
    253. 

  253. 

  254. def cleanNumbers(istr):
    255. 

  255.    while 1:
    256. 

  256.       ostr = istr
    257. 

  257.       proc = re.match(var_doublep,ostr)
    258. 

  258.       if proc:
    259. 

  259.          istr = proc.group('before')+proc.group('after')
    260. 

  260.       if ostr == istr: break
    261. 

  261.    while 1:
    262. 

  262.       ostr = istr
    263. 

  263.       proc = re.match(var_integer,ostr)
    264. 

  264.       if proc:
    265. 

  265.          istr = proc.group('before')+proc.group('after')
    266. 

  266.       if ostr == istr: break
    267. 

  267.    return cleanSpaces(ostr)
    268. 

  268. 

  269. def cleanOperators(istr):
    270. 

  270.    while 1:
    271. 

  271.       ostr = istr
    272. 

  272.       proc = re.match(var_operand,ostr)
    273. 

  273.       if proc:
    274. 

  274.          istr = proc.group('before')+' '+proc.group('after')
    275. 

  275.       if ostr == istr: break
    276. 

  276.    return cleanSpaces(ostr)
    277. 

  277. 

  278. def cleanPointers(istr):
    279. 

  279.    while 1:
    280. 

  280.       ostr = istr
    281. 

  281.       proc = re.match(var_pointer,ostr)
    282. 

  282.       if proc:
    283. 

  283.          istr = proc.group('before')+proc.group('after')
    284. 

  284.       if ostr == istr: break
    285. 

  285.    return cleanSpaces(ostr)
    286. 

  286. 

  287. def cleanQuotes(istr):
    288. 

  288.    istr = istr.replace("'''","'").replace('"""',"'")
    289. 

  289.    # ~~> Deal with single quotes
    290. 

  290.    while 1:
    291. 

  291.       ostr = istr
    292. 

  292.       for quote in re.findall(var_squots,ostr):
    293. 

  293.          istr = istr.replace(quote,"''")
    294. 

  294.       if ostr == istr: break
    295. 

  295.    # ~~> Deal with double quotes (replace by sigle quotes)
    296. 

  296.    while 1:
    297. 

  297.       ostr = istr
    298. 

  298.       for quote in re.findall(var_dquots,ostr):
    299. 

  299.          istr = istr.replace(quote,"''")
    300. 

  300.       if ostr == istr: break
    301. 

  301.    # ~~> Remove the internal apostrophies
    302. 

  302.    ostr = ostr.replace("''''","''").replace("''''","''")
    303. 

  303.    return ostr
    304. 

  304. 

  305. def parseAlias(lines):
    306. 

  306.    listAlias = []; count = 0
    307. 

  307.    core = []; core.extend(lines)
    308. 

  308.    for line in lines :
    309. 

  309.       line = cleanQuotes(line)
    310. 

  310.       proc = re.match(als_core,line)
    311. 

  311.       if proc:
    312. 

  312.          alias = proc.group('alias').strip()
    313. 

  313.          if not re.match(var_pointer,alias):
    314. 

  314.             if alias not in listAlias: listAlias.append(alias)
    315. 

  315.          core[count] = proc.group('before') + ' ' + proc.group('link') + proc.group('after')
    316. 

  316.       count = count + 1
    317. 

  317.    return core,listAlias
    318. 

  318. 

  319. def parseArgs(ilist):
    320. 

  320.    return cleanPointers(cleanNumbers(cleanLogicals(cleanEquals(cleanBracks(cleanQuotes(ilist)))))).replace(' ','').split(',')
    321. 

  321. 

  322. def parseImplicitNone(lines):
    323. 

  323.    core = []; core.extend(lines)
    324. 

  324.    if lines == []: return lines,False
    325. 

  325.    line = lines[0]
    326. 

  326.    proc = re.match(implictNone,line)
    327. 

  327.    if proc :
    328. 

  328.       core.pop(0)
    329. 

  329.       return core,True
    330. 

  330.    return core,False
    331. 

  331. 

  332. def parseDeclarations(lines):
    333. 

  333.    listCommon = []; listDeclar = []; listIntrinsic = []; listExternal = []
    334. 

  334.    core = []; core.extend(lines)
    335. 

  335.    ignoreblock = False
    336. 

  336.    for line in lines :
    337. 

  337.       headline = False
    338. 

  338. 

  339.       # ~~ TYPE Definition ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    340. 

  340.       if not ignoreblock:
    341. 

  341.          proc = re.match(def_title,line)
    342. 

  342.          if proc :
    343. 

  343.             ignoreblock = True
    344. 

  344.             core.pop(0); headline = True; continue
    345. 

  345.       else:
    346. 

  346.          proc = re.match(def_close,line)
    347. 

  347.          if proc : ignoreblock = False
    348. 

  348.          core.pop(0); headline = True; continue
    349. 

  349. 

  350.       # ~~ Common Declaration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    351. 

  351.       proc = re.match(cmn_title,line)
    352. 

  352.       if proc :
    353. 

  353.          listCommon.append([proc.group('name'),parseArgs(proc.group('after'))])
    354. 

  354.          core.pop(0); headline = True; continue
    355. 

  355. 

  356.       # ~~ Private/Public Declarations ~~~~~~~~~~~~~~~~~~~~~~~~~~
    357. 

  357.       proc = re.match(typ_xport,line)
    358. 

  358.       if proc :
    359. 

  359.          #listCommon.append([proc.group('name'),parseArgs(proc.group('after'))])
    360. 

  360.          core.pop(0); headline = True; continue
    361. 

  361. 

  362.       # ~~ INCLUDE Declarations ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    363. 

  363.       proc = re.match(inc_title,line) # you should parse the content from MainWrap
    364. 

  364.       if proc : core.pop(0); headline = True; continue
    365. 

  365. 

  366.       # ~~ Type Declaration ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    367. 

  367.       proc = re.match(typ_title,line)
    368. 

  368.       if proc :
    369. 

  369.          if not re.match(xtn_title,proc.group('after')):
    370. 

  370.             proc = re.match(typ_args,proc.group('after'))
    371. 

  371.             if proc :
    372. 

  372.                if proc.group('vars') != None: listDeclar.extend(parseArgs(proc.group('vars')))
    373. 

  373.                core.pop(0); headline = True; continue
    374. 

  374. 

  375.       # ~~ Intrinsic Declaration ~~~~~~~~~~~~~~~~~~~~~~~~~~
    376. 

  376.       proc = re.match(itz_title,line)
    377. 

  377.       if proc :
    378. 

  378.          if proc.group('vars') != None: listIntrinsic.extend(parseArgs(proc.group('vars')))
    379. 

  379.          core.pop(0); headline = True; continue
    380. 

  380. 

  381.       # ~~ External Declaration ~~~~~~~~~~~~~~~~~~~~~~~~
    382. 

  382.       proc = re.match(xtn_title,line)
    383. 

  383.       if proc :
    384. 

  384.          if proc.group('vars') != None: listExternal.extend(parseArgs(proc.group('vars')))
    385. 

  385.          core.pop(0); headline = True; continue
    386. 

  386. 

  387.       # ~~ Reached main core ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    388. 

  388.       if not headline: break
    389. 

  389. 

  390.    return core,{ 'cmn':listCommon, 'dec':listDeclar, 'itz':listIntrinsic, 'xtn':listExternal, 'als':[] }
    391. 

  391. 

  392. def parseUses(lines):
    393. 

  393.    listUses = {}; listAlias = {}; core = []; core.extend(lines)
    394. 

  394.    for line in lines :
    395. 

  395.       proc = re.match(use_title,line)
    396. 

  396.       if proc :
    397. 

  397.          name = proc.group('name')                                               # You should not find None here
    398. 

  398.          args = ''
    399. 

  399.          if proc.group('after') != None: args = proc.group('after')              # Do you need to distinguish the ONLYs ?
    400. 

  400.          core.pop(0)
    401. 

  401.          addToList(listUses,name,args)
    402. 

  402.       else: break
    403. 

  403.    return core,listUses
    404. 

  404. 

  405. def parseVars(ilist):
    406. 

  406.    return cleanPointers(cleanNumbers(cleanLogicals(cleanAssoc(cleanBracks(cleanQuotes(ilist)))))).replace(' ','').split(',')
    407. 

  407. 

  408. def parseCalls(lines):
    409. 

  409.    listCalls = {} #; count = 0
    410. 

  410.    core = []; core.extend(lines)
    411. 

  411.    for line in lines :
    412. 

  412.       proc = re.match(cls_title,cleanPointers(cleanQuotes(line))) # you might not want to clean Logical at this stage /!\
    413. 

  413.       if proc :
    414. 

  414.          name = proc.group('name'); args = []
    415. 

  415.          if proc.group('args') != None: args = parseVars(proc.group('args'))
    416. 

  416.          addToList(listCalls,name,args)
    417. 

  417.    return core,listCalls
    418. 

  418. 

  419. def parseFunctions(lines):
    420. 

  420.    listFcts = set([]); listTags = []
    421. 

  421.    for line in lines :
    422. 

  422.       line = cleanQuotes(line)
    423. 

  423.       line = cleanPointers(line)
    424. 

  424.       proc = re.match(cls_title,cleanLogicals(line))
    425. 

  425.       if proc :
    426. 

  426.          line = ''
    427. 

  427.          if proc.group('args') != None: line = ' '.join(parseVars(proc.group('args')))
    428. 

  428.       line = cleanFormatted(line)
    429. 

  429.       proc = re.match(fct_title,line)
    430. 

  430.       if proc : line = proc.group('before')+proc.group('name')+'('+cleanAssoc(proc.group('args'))+')'+proc.group('after')
    431. 

  431.       line = cleanLogicals(line)
    432. 

  432.       line = cleanNumbers(line)
    433. 

  433.       proc = re.match(f95_name,line)
    434. 

  434.       if proc:
    435. 

  435.          line = proc.group('after')
    436. 

  436.          listTags.append(proc.group('name'))
    437. 

  437.       line = cleanInstruction(line,listTags)
    438. 

  438.       line = cleanOperators(line)
    439. 

  439.       line = cleanInstruction(line,listINSTRUCTION)
    440. 

  440.       line = cleanInstruction(line,listINTRINSIC)
    441. 

  441.       if line != '':
    442. 

  442.          listFcts = listFcts | set(line.split())
    443. 

  443.    return listFcts
    444. 

  444. 

  445. def parsePrincipalWrap(lines):
    446. 

  446. # you could be parsing the INTERFACE / END INTERFACE as well
    447. 

  447. # and in the case of a module ... declarations / definitions
    448. 

  448.    core = []; core.extend(lines)
    449. 

  449.    face = []
    450. 

  450.    proc = re.match(pcl_title,lines[0])
    451. 

  451.    if proc :
    452. 

  452.       name = proc.group('after')
    453. 

  453.       resu = proc.group('result')
    454. 

  454.       objt = proc.group('object')
    455. 

  455.       type = proc.group('type').strip()
    456. 

  456.       if ( type != '' ):
    457. 

  457.          if not re.match(typ_name,type):
    458. 

  458.             print 'Invalid header type ' + type + ' ' + objt + ' ' + name
    459. 

  459.             sys.exit() #return [],[],[],lines
    460. 

  460.       proc = re.match(argnames,name)
    461. 

  461.       if proc :
    462. 

  462.          name = proc.group('name')
    463. 

  463.          args = []
    464. 

  464.          if proc.group('args') != None: args = parseArgs(proc.group('args'))
    465. 

  465.          #~~> header completed
    466. 

  466.          count = 0; block = 0
    467. 

  467.          ctain = 0; ltain = False; lface = False
    468. 

  468.          for line in lines[1:]:                                  # /!\ does not work with empty lines
    469. 

  469.             count = count + 1
    470. 

  470.             #~~> interface
    471. 

  471.             if lface:
    472. 

  472.                proc = re.match(itf_close,line)
    473. 

  473.                if proc:
    474. 

  474.                   lface = False
    475. 

  475.                else:
    476. 

  476.                   proc = re.match(itf_uless,line)
    477. 

  477.                   if not proc: face.append(line)
    478. 

  478.                core.pop(count)
    479. 

  479.                count = count - 1
    480. 

  480.                continue  # THIS IS TO IGNORE THE LOCAL VARIABLES
    481. 

  481.             else:
    482. 

  482.                proc = re.match(itf_title,line)
    483. 

  483.                if proc :
    484. 

  484.                   lface = True
    485. 

  485.                   core.pop(count)
    486. 

  486.                   count = count - 1
    487. 

  487.             #~~> contains
    488. 

  488.             if ltain: ctain = ctain - 1
    489. 

  489.             if not ltain:
    490. 

  490.                if re.match(ctn_title,line) : ltain = True
    491. 

  491.             proc = re.match(pcl_close,line)
    492. 

  492.             if proc :
    493. 

  493.                block = block - 1
    494. 

  494.             else:
    495. 

  495.                proc = re.match(pcl_title,line)
    496. 

  496.                if proc :
    497. 

  497.                   t = proc.group('type').strip()
    498. 

  498.                   if ( t != '' ):
    499. 

  499.                      if not re.match(typ_name,t): continue
    500. 

  500.                   block = block + 1
    501. 

  501.             if block < 0 :
    502. 

  502.                if proc.group('name') != name:
    503. 

  503.                   if debug: print 'Different name at END ' + objt + ' ' + name
    504. 

  504.                if proc.group('object') != objt:
    505. 

  505.                   if debug: print 'Different type at END ' + objt
    506. 

  506.                return core[1:count+ctain],[ objt[0:1], name, args, resu ],face,core[count+ctain+1:count],core[count+1:]
    507. 

  507.          # ~~> Acount for empty MODULE (including only INTERFACE and CONTAINS)
    508. 

  508.          if ltain and block == 0 and count+1 >= len(core)-1:
    509. 

  509.             if proc.group('name') != name:
    510. 

  510.                if debug: print 'Different name at END ' + objt + ' ' + name
    511. 

  511.             if proc.group('object') != objt:
    512. 

  512.                if debug: print 'Different type at END ' + objt
    513. 

  513.             return core[1:count+ctain],[ objt[0:1], name, args, resu ],face,core[count+ctain+1:count],core[count+2:]
    514. 

  514.       else:
    515. 

  515.          print 'Invalid header type for first line' + lines[0]
    516. 

  516.          sys.exit()
    517. 

  517. 

  518.    print 'Invalid header type for first line' + lines[0]
    519. 

  519.    sys.exit()
    520. 

  520.    return # /!\ this return is just for python parsing
    521. 

  521. 

  522. def parsePrincipalMain(lines,who,type,name,args,resu):
    523. 

  523.    core = []; core.extend(lines)
    524. 

  524.    whi = dict.copy(who); whi['uses'] = {}; whi['vars'] = {}; whi['calls'] = {}; whi['called'] = [] #; whi['alias'] = {}
    525. 

  525.    whi['type'] = type; whi['name'] = name; whi['args'] = args; whi['resu'] = resu
    526. 

  526. 

  527.    # ~~ Lists aliases in File ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    528. 

  528.    core,alias = parseAlias(core)
    529. 

  529. 

  530.    # ~~ Lists uses in File ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    531. 

  531.    core,uses = parseUses(core)
    532. 

  532.    for k in uses.keys():
    533. 

  533.       whi['uses'].update({k:[]})
    534. 

  534.       for v in uses[k]: addToList(whi['uses'],k,v)
    535. 

  535. 

  536.    # ~~ Imposes IMPLICIT NONE ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    537. 

  537.    core,l = parseImplicitNone(core)
    538. 

  538.    if not l and whi['type'] != 'M' and debug:
    539. 

  539.       print 'No IMPLICIT NONE in ',whi['name'],whi['file']
    540. 

  540. 

  541.    # ~~ Lists declarations in File ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    542. 

  542.    core,decs = parseDeclarations(core)
    543. 

  543.    for dec in decs['xtn']:
    544. 

  544.       if dec in decs['dec']: decs['dec'].remove(dec)
    545. 

  545.    for dec in decs['cmn']:
    546. 

  546.       for k in dec[1]:
    547. 

  547.          if k in decs['dec']: decs['dec'].remove(k)
    548. 

  548.    for dec in args:
    549. 

  549.       if dec in decs['dec']: decs['dec'].remove(dec)
    550. 

  550.    for k in decs.keys():
    551. 

  551.       whi['vars'][k] = []
    552. 

  552.       for v in decs[k]: addToList(whi['vars'],k,v)
    553. 

  553.    whi['vars']['als'] = alias
    554. 

  554. 

  555.    # ~~ Lists calls in File ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    556. 

  556.    core,calls = parseCalls(core)
    557. 

  557.    for k in calls.keys():
    558. 

  558.       whi['calls'][k] = []
    559. 

  559.       for v in calls[k]: addToList(whi['calls'],k,v) # still includes xtn calls
    560. 

  560. 

  561.    # ~~ Lists functions in File ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    562. 

  562.    fcts = []
    563. 

  563.    for fct in parseFunctions(core):
    564. 

  564.       if fct not in args:
    565. 

  565.          if fct not in whi['vars']['dec']:
    566. 

  566.             if fct not in whi['vars']['als']:
    567. 

  567.                found = False
    568. 

  568.                for cmn in whi['vars']['cmn']:
    569. 

  569.                   if fct in cmn[1]: found = True
    570. 

  570.                if not found and fct != name: fcts.append(fct)
    571. 

  571.    whi['functions'] = fcts # still includes the ones from the USEs (and xtn)
    572. 

  572. 

  573.    return name,whi,core
    574. 

  574. 

  575. """
    576. 

  576.    In order for multiple line of code to be interpreted, remove the
    577. 

  577.    continuation symbols so every line is self contained --
    578. 

  578.    This takes into account the possibility for f77 and f90
    579. 

  579.    continuation -- assumes that in between comments have been
    580. 

  580.    removed already
    581. 

  581.    Return the set of lines without continuation
    582. 

  582. """
    583. 

    584. 

  584. def delContinuedsF77(lines):
    585. 

  585.    # ~~ Assumes code without comments ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    586. 

  586.    cmds = []
    587. 

  587.    cmd  = ''
    588. 

  588.    for line in lines :
    589. 

  589.       proc1 = re.match(f77continu2,line)
    590. 

  590.       if proc1:
    591. 

  591.          #?cmd = cmd.rstrip() + proc1.group('line')
    592. 

  592.          cmd = ( cmd.rstrip() + proc1.group('line') ).strip().replace('  ',' ').replace('  ',' ') # /!\ Looking to save on upper space
    593. 

  593.       else:
    594. 

  594.          if cmd is not '' : cmds.append(cmd)
    595. 

  595.          #?cmd = line
    596. 

  596.          cmd = line.strip().replace('  ',' ').replace('  ',' ') # /!\ Looking to save on upper space
    597. 

  597.    cmds.append(cmd)
    598. 

  598.    return cmds
    599. 

  599. 

  600. def delContinuedsF90(lines):
    601. 

  601.    # ~~ Assumes code without comments ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    602. 

  602.    cmds = []
    603. 

  603.    cmd  = ''
    604. 

  604.    cnt = False
    605. 

  605.    for line in lines :
    606. 

  606.       proc2 = re.match(f90continu1,line)
    607. 

  607.       proc3 = re.match(f90continu2,line)
    608. 

  608.       proc4 = re.match(f90continu3,line)
    609. 

  609.       if proc3 :
    610. 

  610.          #?cmd = cmd.rstrip() + proc3.group('line')
    611. 

  611.          cmd = cleanSpaces( cmd + proc3.group('line') ) # /!\ Looking to save on upper space
    612. 

  612.          cnt = True
    613. 

  613.       elif proc2 :
    614. 

  614.          if not cnt:
    615. 

  615.             if cmd is not '' : cmds.append(cmd)
    616. 

  616.             cmd = ''
    617. 

  617.          #?cmd = cmd.rstrip() + proc2.group('line')
    618. 

  618.          cmd = cleanSpaces( cmd + proc2.group('line') ) # /!\ Looking to save on upper space
    619. 

  619.          cnt = True
    620. 

  620.       elif proc4 :
    621. 

  621.          #?cmd = cmd.rstrip() + proc4.group('line')
    622. 

  622.          cmd = cleanSpaces( cmd + proc4.group('line') ) # /!\ Looking to save on upper space
    623. 

  623.          cnt = False
    624. 

  624.       else:
    625. 

  625.          if cnt:
    626. 

  626.             #?cmd = cmd.rstrip() + line
    627. 

  627.             cmd = cleanSpaces( cmd + line ) # /!\ Looking to save on upper space
    628. 

  628.          else:
    629. 

  629.             if cmd is not '' : cmds.append(cmd)
    630. 

  630.             #?cmd = line
    631. 

  631.             cmd = cleanSpaces(line) # /!\ Looking to save on upper space
    632. 

  632.          cnt = False
    633. 

  633.    if cmd is not '' : cmds.append(cmd)
    634. 

  634.    return cmds
    635. 

  635. 

  636. """
    637. 

  637.    In order for multiple lines of code to be interpreted, remove all
    638. 

  638.    comments form these, whether they include f77 or f09 comments --
    639. 

  639.    Return the command lines (without empty lines)
    640. 

  640. """
    641. 

  641. def delComments(lines):
    642. 

  642.    # ~~ Also removes end lines and sets to UPPERCASE ~~~~~~~~~~~~~~~
    643. 

  643.    cmds = []
    644. 

  644.    for line in lines :
    645. 

  645.       line = cleanQuotes(line).rstrip().upper()
    646. 

  646.       proc1 = re.match(f77continu2,line) # no strip here
    647. 

  647.       proc = re.match(f77comment,line)   # no strip here
    648. 

  648.       if proc and not proc1 :
    649. 

  649.          cmd = ''
    650. 

  650.       else :
    651. 

  651.          while 1:
    652. 

  652.             cmd = line
    653. 

  653.             proc = re.match(f90comment,cmd)
    654. 

  654.             if proc: line = proc.group('line').rstrip()
    655. 

  655.             if cmd == line: break
    656. 

  656.       if cmd != '' :
    657. 

  657.          proc = re.match(emptyline,cmd)
    658. 

  658.          if not proc:
    659. 

  659.             cmds.append(cmd.replace('\n','').replace('\r',''))
    660. 

  660.    return cmds
    661. 

  661. 

  662. def scanSources(cfgdir,cfg,BYPASS):
    663. 

  663.    fic = {}; mdl = {}; sbt = {}; fct = {}; prg = {}; dep = {}; wcw = {}
    664. 

  664. 

  665.    # ~~ Looking at each file individually ~~~~~~~~~~~~~~~~~~~~~~~~~~
    666. 

  666.    for mod in cfg['MODULES'].keys() :
    667. 

  667. 

  668.       wcw.update({mod:{'path':cfg['MODULES'][mod]['path']}})
    669. 

  669.       fic.update({mod:{}})
    670. 

  670.       # ~~ Scans the sources that are relevant to the model ~~~~~~~~
    671. 

  671.       SrcDir = path.join(cfg['MODULES'][mod]['path'],'sources')     # assumes the sources are under ./sources
    672. 

  672.       FileList = getTheseFiles(SrcDir,['.f','.f90'])
    673. 

  673.       ODir = path.join(cfg['MODULES'][mod]['path'],cfgdir)
    674. 

  674. 

  675.       print '... now scanning ', path.basename(cfg['MODULES'][mod]['path'])
    676. 

  676. 

  677.       ibar = 0; pbar = ProgressBar(maxval=len(FileList)).start()
    678. 

  678.       #/!\ if you need to print within this loop, you now need to use
    679. 

  679.       #    pbar.write(text,ibar) so the progress bar moves along
    680. 

  680.       for File in FileList :
    681. 

  681.          ibar = ibar + 1; pbar.update(ibar)
    682. 

  682. 

  683.          if not fic.has_key(mod): update({mod:{}})
    684. 

  684.          fic[mod].update({File:[]})
    685. 

  685.          #pbar.write(File,ibar)
    686. 

  686.          who = { 'path':path.abspath(path.dirname(File)), \
    687. 

  687.             'file':path.basename(File), \
    688. 

  688.             'libname':mod,   \
    689. 

  689.             'type':'',       \
    690. 

  690.             'name':'',       \
    691. 

  691.             'args':[],       \
    692. 

  692.             'resu':'',       \
    693. 

  693.             'contains':[],   \
    694. 

  694.             'uses':{},       \
    695. 

  695.             'vars':{},       \
    696. 

  696.             'calls':{},      \
    697. 

  697.             'called':[],     \
    698. 

  698.             'functions':[],  \
    699. 

  699.             'rank':1,        \
    700. 

  700.             'time':0 }
    701. 

  701.          if path.isdir(ODir) :
    702. 

  702.             if cfg['COMPILER']['REBUILD'] == 2:
    703. 

  703.                who['time'] = 0
    704. 

  704.             else:
    705. 

  705.                #who['time'] = isNewer(path.join(ODir,path.splitext(path.basename(File))[0] + cfg['SYSTEM']['sfx_obj'].lower()),File)
    706. 

  706.                who['time'] = isNewer(File,path.join(ODir,path.splitext(path.basename(File))[0] + cfg['SYSTEM']['sfx_obj'].lower()))
    707. 

  707. 

  708.          SrcF = open(File,'r')
    709. 

  709.          if path.splitext(who['file'])[1].lower() in ['.f90','.f95']:
    710. 

  710.             flines = delContinuedsF90(delComments(SrcF))        # Strips the F90+ commented lines
    711. 

  711.          else:
    712. 

  712.             flines = delContinuedsF77(delComments(SrcF))        # Strips the F77 commented lines
    713. 

  713.          SrcF.close()                                           # and deletes the continuation characters
    714. 

  714.          
    715. 

  715.          core = flines
    716. 

  716.          found = False #ndu
    717. 

  717.          while core != [] and not found:                             # ignores what might be in the file after the main program
    718. 

  718. 

  719.             # ~~ Parse Main Structure ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    720. 

  720.             code,w,face,ctns,core = parsePrincipalWrap(core)
    721. 

  721.             name,whoi,rest = parsePrincipalMain(code,who,w[0],w[1],w[2],w[3])
    722. 

  722.             if w[0] == 'P': prg = addToList(prg,name,whoi['libname'])# main program
    723. 

  723.             if w[0] == 'P': found = BYPASS
    724. 

  724.             if w[0] == 'S': sbt = addToList(sbt,name,whoi['libname'])# subroutine
    725. 

  725.             if w[0] == 'M': mdl = addToList(mdl,name,whoi['libname'])# module
    726. 

  726.             if w[0] == 'F': fct = addToList(fct,name,whoi['libname'])# function
    727. 

  727.             fic[mod][File].append(name)
    728. 

  728.             while face != []:
    729. 

  729.                fcode,fw,ff,ft,face = parsePrincipalWrap(face)
    730. 

  730.                if fcode != []:
    731. 

  731.                   fname,whof,rest = parsePrincipalMain(fcode,who,fw[0],fw[1],fw[2],fw[3])
    732. 

  732.                   for k in whof['uses'].keys():
    733. 

  733.                      for v in whof['uses'][k]: addToList(whoi['uses'],k,v)
    734. 

  734.             while ctns != []:                                      # contains fcts & subs
    735. 

  735.                ccode,cw,cf,ct,ctns = parsePrincipalWrap(ctns)
    736. 

  736.                if ccode != []:
    737. 

  737.                   cname,whoc,rest = parsePrincipalMain(ccode,who,cw[0],cw[1],cw[2],cw[3])
    738. 

  738.                   whoi['contains'].append(cname)
    739. 

  739.                   if cw[0] == 'S': sbt = addToList(sbt,cname,whoi['libname'])# subroutine
    740. 

  740.                   if cw[0] == 'F': fct = addToList(fct,cname,whoi['libname'])# function
    741. 

  741.                   for k in whoc['uses'].keys():
    742. 

  742.                      for v in whoc['uses'][k]: addToList(whoi['uses'],k,v)
    743. 

  743.                   for k in whoc['vars'].keys():
    744. 

  744.                      for v in whoc['vars'][k]: addToList(whoi['vars'],k,v)
    745. 

  745.                   for k in whoc['calls'].keys():
    746. 

  746.                      for v in whoc['calls'][k]: addToList(whoi['calls'],k,v)
    747. 

  747.                   for k in whoc['functions']:
    748. 

  748.                      if k not in whoi['functions']: whoi['functions'].append(k)
    749. 

  749.             whoi['vars'].update({'use':{}})
    750. 

  750.             wcw[mod].update({name:whoi})         # ~~ All ~~~~~~~~~~
    751. 

  751.             #if core == []: break
    752. 

  752. 

  753.       pbar.finish()
    754. 

  754. 

  755.    # ~~ Cross-referencing CALLS together ~~~~~~~~~~~~~~~~~~~~~~~~~~~
    756. 

  756.    # For those CALLs stored in 'calls' but not part of the system:
    757. 

  757.    #   move them from 'calls' to 'function' (outsiders remain)
    758. 

  758.    for mod in wcw.keys() :
    759. 

  759.       for name in wcw[mod]:
    760. 

  760.          if name != 'path':
    761. 

  761.             who = wcw[mod][name]
    762. 

  762.             for s in who['calls'].keys():
    763. 

  763.                if s not in sbt.keys():
    764. 

  764.                   del wcw[mod][name]['calls'][s]
    765. 

  765.                   wcw[mod][name]['functions'].append(s)
    766. 

  766. 

  767.    # ~~ Cross-referencing FUNCTIONS together ~~~~~~~~~~~~~~~~~~~~~~~
    768. 

  768.    for mod in wcw.keys() :
    769. 

  769.       for name in wcw[mod]:
    770. 

  770.          if name != 'path':
    771. 

  771.             who = wcw[mod][name]
    772. 

  772.             for f in who['vars']['xtn']:
    773. 

  773.                if f not in who['functions']:
    774. 

  774.                   if debug: print f,' declared but not used in ',who['name']
    775. 

  775.                   who['functions'].append(f)
    776. 

  776.             for f in fct.keys():
    777. 

  777.                while f in who['functions']:
    778. 

  778.                   who['functions'].remove(f)
    779. 

  779.                   who['calls'].update({f:[['']]})
    780. 

  780.    for mod in wcw.keys() :
    781. 

  781.       for name in wcw[mod]:
    782. 

  782.          if name != 'path':
    783. 

  783.             who = wcw[mod][name]
    784. 

  784.             f,u = sortFunctions(who['functions'],who['vars']['use'],wcw,mdl,who['uses'])
    785. 

  785.             who['functions'] = f
    786. 

  786.             who['vars']['use'].update(u) # because this is a dico-list, updating who updates wcw
    787. 

  787. 

  788.    # ~~ Sort out referencing ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    789. 

  789.    # Fill-in the 'called' category
    790. 

  790.    for mod in wcw.keys() :
    791. 

  791.       for name in wcw[mod]:
    792. 

  792.          if name != 'path':
    793. 

  793.             for call in wcw[mod][name]['calls'].keys():
    794. 

  794.                if sbt.has_key(call):
    795. 

  795.                   for u in sbt[call]:
    796. 

  796.                      if wcw[u].has_key(call):
    797. 

  797.                         wcw[u][call]['called'].append(name)
    798. 

  798.                if fct.has_key(call):
    799. 

  799.                   for u in fct[call]:
    800. 

  800.                      if wcw[u].has_key(call):
    801. 

  801.                         wcw[u][call]['called'].append(name)
    802. 

  802. 

  803.    return fic,mdl,sbt,fct,prg,dep,wcw
    804. 

  804. 

  805. def sortFunctions(ifcts,iuses,list,mods,xuses):
    806. 

  806.    #found = False
    807. 

  807.    ofcts = []; ofcts.extend(ifcts)
    808. 

  808.    for d in ifcts:
    809. 

  809.       for u in xuses:
    810. 

  810.          if u not in mods.keys():
    811. 

  811.             continue
    812. 

  812.          if d in list[mods[u][0]][u]['vars']['dec']:
    813. 

  813.             ofcts.remove(d)
    814. 

  814.             addToList(iuses,u,d)
    815. 

  815.             break
    816. 

  816.          if d in list[mods[u][0]][u]['vars']['als']:
    817. 

  817.             ofcts.remove(d)
    818. 

  818.             addToList(iuses,u,d)
    819. 

  819.             break
    820. 

  820.    ifcts = ofcts
    821. 

  821.    for u in xuses:
    822. 

  822.       if u in mods.keys() and ifcts != []:
    823. 

  823.          ifcts,iuses = sortFunctions(ifcts,iuses,list,mods,list[mods[u][0]][u]['uses'])
    824. 

  824. 

  825.    return ifcts,iuses
    826. 

  826. 

  827. # _____                 ____________________________________________
    828. 

  828. # ____/ DOXYGEN parse  /___________________________________________/
    829. 

  829. #
    830. 

  830. 

  831. doxycomment = re.compile(r'!>(?P<doxy>.*)\s*\Z') #,re.I)
    832. 

  832. doxy_tag = re.compile(r'!>\s*?@(?P<tag>[\w\[,\]]+)(?P<after>.*)\s*\Z') #,re.I)
    833. 

  833. doxy_title = re.compile(r'\s+(?P<title>.*)\s*\Z') #,re.I)
    834. 

  834. 

  835. """
    836. 

  836.    Parse a list of entry lines, removing the lines that are
    837. 

  837.    understood to be part of a tag -- the lines are removed
    838. 

  838.    from the 'core' iteratively -- Return one complete tag
    839. 

  839. """
    840. 

  840. def getNextDoxyTag(core):
    841. 

  841.    ltag = []; tag = ''; name = ''
    842. 

  842.    found = False
    843. 

  843.    while core != []:
    844. 

  844.       proc = re.match(doxy_tag,core[0])
    845. 

  845.       if proc:
    846. 

  846.          if not found:
    847. 

  847.             tag = proc.group('tag')
    848. 

  848.             proc = re.match(doxy_title,proc.group('after'))
    849. 

  849.             if proc: name = proc.group('title')
    850. 

  850.             found = True
    851. 

  851.          else: break
    852. 

  852.       if found: ltag.append(core[0])
    853. 

  853.       core.pop(0)
    854. 

  854. 

  855.    return tag,name,ltag,core
    856. 

  856. 

  857. """
    858. 

  858.    Parse a list of entry lines, removing the doxygen blocks
    859. 

  859.    listing them out by tag names -- the doxygen blocks are removed
    860. 

  860.    from the 'core' iteratively -- Return the list of tags by blocks
    861. 

  861. """
    862. 

  862. def parseDoxyTags(core):
    863. 

  863.    tags = []
    864. 

  864.    while 1:
    865. 

  865.       tname,title,field,core = getNextDoxyTag(core)
    866. 

  866.       if tname =='': break
    867. 

  867.       tags.append([tname,title,field])
    868. 

  868.    return tags
    869. 

  869. 

  870. # _____                 ____________________________________________
    871. 

  871. # ____/ FORTRAN parse  /___________________________________________/
    872. 

  872. #
    873. 

  873. 

  874. #?varcomment = re.compile(r'[C!#*]\s*?[|!]\s*?(?P<vars>[\s\w,()]*)(?P<inout>(|[|!->=<\s]*[|!]))(?P<after>(|[^|!]*))\s*[|!]?\s*\Z') #,re.I)
    875. 

  875. varcomment = re.compile(r'[C!#*]\s*?[|!]\s*?(?P<vars>[\s\w,()]*)(?P<inout>(|[|!->=<\s]*[|!]))(?P<after>(|[^|!]*))\s*[|!]?\s*\Z') #,re.I)
    876. 

  876. 

  877. def parseFortHeader(core):
    878. 

  878.    docs = []; title = []; vars = {}
    879. 

  879.    while 1:
    880. 

  880.       line = delComments([core[0]])
    881. 

  881.       if line == []:
    882. 

  882.          proc = re.match(varcomment,core[0])
    883. 

  883.          if proc:
    884. 

  884.             #print core[0].rstrip()
    885. 

  885.             if proc.group('vars').strip() != '':
    886. 

  886.                var = proc.group('vars').strip()
    887. 

  887.                val = proc.group('after').strip()
    888. 

  888.                ino = proc.group('inout').strip()
    889. 

  889.                if ino == '!!' or ino == '||': ino = '<>'
    890. 

  890.                #print val
    891. 

  891.                vars.update({var:[ino,[val]]})
    892. 

  892.             elif proc.group('after').strip() != '':
    893. 

  893.                #print vars
    894. 

  894.                vars[var][1].append(proc.group('after').strip())
    895. 

  895.             #print '##'+proc.group('vars')+'##','@@'+proc.group('inout')+'@@','>>'+proc.group('after')+'<<'
    896. 

  896.             #print var,vars[var]
    897. 

  897.          core.pop(0)
    898. 

  898.          continue
    899. 

  899.       line = line[0].rstrip()
    900. 

  900.       proc = re.match(pcl_title,line)
    901. 

  901.       if proc:
    902. 

  902.          type = proc.group('type').strip()
    903. 

  903.          if ( type != '' ):
    904. 

  904.             if not re.match(typ_name,type): break
    905. 

  905.          docs.append(core[0].rstrip())
    906. 

  906.          core.pop(0)
    907. 

  907.          continue
    908. 

  908.       proc = re.match(use_title,line)
    909. 

  909.       proc = proc or re.match(implictNone,line)
    910. 

  910.       proc = proc or re.match(itf_title,line)
    911. 

  911.       proc = proc or re.match(def_title,line)
    912. 

  912.       proc = proc or re.match(cmn_title,line)
    913. 

  913.       proc = proc or re.match(typ_xport,line)
    914. 

  914.       proc = proc or re.match(inc_title,line)
    915. 

  915.       proc = proc or re.match(typ_title,line)
    916. 

  916.       proc = proc or re.match(itz_title,line)
    917. 

  917.       proc = proc or re.match(xtn_title,line)
    918. 

  918.       if proc: break
    919. 

  919.       #proc = re.match(f77comment,line)
    920. 

  920.       #if not proc:
    921. 

  921.       docs.append(core[0].rstrip())
    922. 

  922.       core.pop(0)
    923. 

  923. 

  924.    return docs,vars,core
    925. 

  925. 

  926. # Note that the spaces are kept in the 'after' text for possible formatting
    927. 

  927. doxytags = '(brief|note|warning|history|bug|code)'
    928. 

  928. doxycomment = re.compile(r'\s*!(?P<name>%s\b)(?P<after>.*?)\s*\Z'%(doxytags)) #,re.I)
    929. 

  929. doxycommentadd = re.compile(r"\s*!\+(?P<after>.*?)\s*\Z") #,re.I)
    930. 

  930. 

  931. def parseDoxyHeader(body):
    932. 

  932.    # It is now assumed that doxytags could be part of the main
    933. 

  933.    # core of the Fortran.
    934. 

  934.    tags = []; tfound = False; tcount = -1
    935. 

  935.    core = []; core.extend(body); bcount = -1
    936. 

  936.    nfound = False
    937. 

  937.    # ~~ Parse Doxygen Tags ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    938. 

  938.    while core != []:
    939. 

  939.       line = core[0].rstrip()
    940. 

  940.       bcount = bcount + 1
    941. 

  941. 

  942.       # ~~> parsing the tags
    943. 

  943.       proc = re.match(doxycomment,line)
    944. 

  944.       if proc:
    945. 

  945.          tcount = tcount + 1
    946. 

  946.          tags.extend([[]])
    947. 

  947.          tags[tcount].append(proc.group('name'))
    948. 

  948.          tags[tcount].append([proc.group('after')])
    949. 

  949.          tfound = True
    950. 

  950.          core.pop(0)
    951. 

  951.          body.pop(bcount)
    952. 

  952.          bcount = bcount - 1
    953. 

  953.          continue
    954. 

  954.       proc = re.match(doxycommentadd,line)
    955. 

  955.       if proc and tfound:
    956. 

  956.          tags[tcount][1].append(proc.group('after'))
    957. 

  957.          core.pop(0)
    958. 

  958.          body.pop(bcount)
    959. 

  959.          bcount = bcount - 1
    960. 

  960.          continue
    961. 

  961.       tfound = False
    962. 

  962. 

  963.       # ~~> parsing the name of the program for later reference
    964. 

  964.       if not nfound:
    965. 

  965.          proc = re.match(pcl_title,line)
    966. 

  966.          if proc :
    967. 

  967.             proc = re.match(var_word,proc.group('after'))
    968. 

  968.             if proc : name = proc.group('word')
    969. 

  969.             nfound = True
    970. 

  970.       core.pop(0)
    971. 

  971. 

  972.    return name,tags
    973. 

  973. 

  974. """
    975. 

  975.    Split a set of lines (content of a file) into a Doxygen header
    976. 

  976.    the definition of the FORTRAN entity and the text between the
    977. 

  977.    the definition oan the core of the FORTRAN entity -- The wrap
    978. 

  978.    iteratively goes through all included entities and sub-entities
    979. 

  979.    - lines contains the content of the file
    980. 

  980.    - icount is the number of entities included (functions, subroutines, etc.)
    981. 

  981. """
    982. 

  982. def parseDoxyWrap(lines):
    983. 

  983.    core = []; core.extend(lines)
    984. 

  984.    wrap = []; wrap.extend([[]])
    985. 

  985.    blevel = 0; bcount = 0
    986. 

  986. 

  987.    # ~~ Split the content of the file by blocks ~~~~~~~~~~~~~~~~~~~~
    988. 

  988.    while core != []:
    989. 

  989.       line = core[0].rstrip()
    990. 

  990.       wrap[bcount].append(line)
    991. 

  991.       core.pop(0)
    992. 

  992. 

  993.       proc = re.match(pcl_close,line)
    994. 

  994.       if proc:
    995. 

  995.          blevel = blevel - 1
    996. 

  996.          if blevel == 0:
    997. 

  997.             bcount = bcount + 1
    998. 

  998.             wrap.extend([[]])
    999. 

  999.          continue
    1000. 

  1000.       proc = re.match(pcl_title,line)
    1001. 

  1001.       if proc:
    1002. 

  1002.          blevel = blevel + 1
    1003. 

  1003.          continue
    1004. 

  1004. 

  1005.    # ~~ Clean the wrap ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    1006. 

  1006.    # remove the the last item of the wrap,
    1007. 

  1007.    # which is empty since it gets set just after the pcl_close
    1008. 

  1008.    ##>wrap.pop(len(wrap)-1)
    1009. 

  1009. 

  1010.    # ~~ Parse the DOXYGEN tags ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    1011. 

  1011.    doxy = []; name = ''
    1012. 

  1012.    for w in wrap:
    1013. 

  1013.       if w != []:
    1014. 

  1014.          n,d = parseDoxyHeader(w)
    1015. 

  1015.          if name == '': name = n   #/!\ here takes the first name of the file
    1016. 

  1016.          doxy.extend([(name,n,d,w)])
    1017. 

  1017. 

  1018.    return doxy
    1019. 

  1019. 

  1020. # _____             ________________________________________________
    1021. 

  1021. # ____/ MAIN CALL  /_______________________________________________/
    1022. 

  1022. #
    1023. 

  1023. 

  1024. __author__="Sebastien E. Bourban; Noemie Durand"
    1025. 

  1025. __date__ ="$19-Jul-2010 08:51:29$"
    1026. 

  1026. 

  1027. if __name__ == "__main__":
    1028. 

  1028. 

  1029. # <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    1030. 

  1030. # ~~~~ Reads config file ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    1031. 

  1031.    print '\n\nLoading Options and Configurations\n\
    1032. 

  1032. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n'
    1033. 

  1033.    USETELCFG = ''
    1034. 

  1034.    if environ.has_key('USETELCFG'): USETELCFG = environ['USETELCFG']
    1035. 

  1035.    SYSTELCFG = 'systel.cfg'
    1036. 

  1036.    if environ.has_key('SYSTELCFG'): SYSTELCFG = environ['SYSTELCFG']
    1037. 

  1037.    if path.isdir(SYSTELCFG): SYSTELCFG = path.join(SYSTELCFG,'systel.cfg')
    1038. 

  1038.    parser = OptionParser("usage: %prog [options] \nuse -h for more help.")
    1039. 

  1039.    parser.add_option("-c", "--configname",
    1040. 

  1040.                       type="string",
    1041. 

  1041.                       dest="configName",
    1042. 

  1042.                       default=USETELCFG,
    1043. 

  1043.                       help="specify configuration name, default is randomly found in the configuration file" )
    1044. 

  1044.    parser.add_option("-f", "--configfile",
    1045. 

  1045.                       type="string",
    1046. 

  1046.                       dest="configFile",
    1047. 

  1047.                       default=SYSTELCFG,
    1048. 

  1048.                       help="specify configuration file, default is systel.cfg" )
    1049. 

  1049.    parser.add_option("-r", "--rootdir",
    1050. 

  1050.                       type="string",
    1051. 

  1051.                       dest="rootDir",
    1052. 

  1052.                       default='',
    1053. 

  1053.                       help="specify the root, default is taken from config file" )
    1054. 

  1054.    parser.add_option("-v", "--version",
    1055. 

  1055.                       type="string",
    1056. 

  1056.                       dest="version",
    1057. 

  1057.                       default='',
    1058. 

  1058.                       help="specify the version number, default is taken from config file" )
    1059. 

  1059.    options, args = parser.parse_args()
    1060. 

  1060.    if not path.isfile(options.configFile):
    1061. 

  1061.       print '\nNot able to get to the configuration file: ' + options.configFile + '\n'
    1062. 

  1062.       dircfg = path.dirname(options.configFile)
    1063. 

  1063.       if path.isdir(dircfg) :
    1064. 

  1064.          print ' ... in directory: ' + dircfg + '\n ... use instead: '
    1065. 

  1065.          for dirpath,dirnames,filenames in walk(dircfg) : break
    1066. 

  1066.          for file in filenames :
    1067. 

  1067.             head,tail = path.splitext(file)
    1068. 

  1068.             if tail == '.cfg' : print '    +> ',file
    1069. 

  1069.       sys.exit()
    1070. 

  1070. 

  1071. # <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    1072. 

  1072. # ~~~~ Works for all configurations unless specified ~~~~~~~~~~~~~~~
    1073. 

  1073.    cfgs = parseConfigFile(options.configFile)
    1074. 

  1074.    cfgnames = cfgs.keys()
    1075. 

  1075.    if options.configName != '':
    1076. 

  1076.       if options.configName not in cfgnames:
    1077. 

  1077.          print '\nNot able to find your configuration in the configuration file: ' + options.configFile + '\n'
    1078. 

  1078.          print ' ... use instead:'
    1079. 

  1079.          for cfgname in cfgnames : print '    +> ',cfgname
    1080. 

  1080.          sys.exit()
    1081. 

  1081.       cfgnames = [options.configName]
    1082. 

  1082. 

  1083.    #  /!\  for testing purposes ... no real use
    1084. 

  1084.    for cfgname in cfgnames:
    1085. 

  1085.       # still in lower case
    1086. 

  1086.       if options.rootDir != '': cfgs[cfgname]['root'] = options.rootDir
    1087. 

  1087.       if options.version != '': cfgs[cfgname]['version'] = options.version
    1088. 

  1088.       # parsing for proper naming
    1089. 

  1089.       cfg = parseConfig_CompileTELEMAC(cfgs[cfgname])
    1090. 

  1090. 

  1091.       debug = True
    1092. 

  1092. 

  1093.       # ~~ Scans all source files to build a relation database ~~~~~
    1094. 

  1094.       print '\n\nScanning the source code\n\
    1095. 

  1095. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n'
    1096. 

  1096.       fic,mdl,sbt,fct,prg,dep,all = scanSources(cfgname,cfg,False)
    1097. 

  1097.       
    1098. 

  1098.    sys.exit()
    1099. 

  1099. 

  1100.