PageRenderTime 79ms CodeModel.GetById 19ms RepoModel.GetById 3ms app.codeStats 0ms

/TOOLS/SrcFragments/ANALYZEnotusednow/analyze.py

http://github.com/tkotani/ecalj
Python | 422 lines | 417 code | 1 blank | 4 comment | 0 complexity | 313b6e7ff53484b5dfc11c33b78d2e13 MD5 | raw file
    

  1. #!/usr/bin/env python
    2. 

  2. # This routine checks module-dependency in fortran90 and compile them in right order.
    3. 

  3. #
    4. 

  4. import os
    5. 

  5. import sys
    6. 

  6. import string
    7. 

  7. import re
    8. 

  8. import glob
    9. 

  9. 

  10. #---------------------
    11. 

  11. def rsp(dat):
    12. 

  12. 	dat= string.lower(re.sub(' '  ,'',dat))
    13. 

  13. 	return dat
    14. 

  14. 

  15. def connect(alist):
    16. 

  16. 	result=''
    17. 

  17. 	for lll in alist:
    18. 

  18. 		result = result + ' ' + lll
    19. 

  19. 	return result
    20. 

  20. 

  21. def uniqlist(input): # uniq
    22. 

  22. 	output = []
    23. 

  23. 	for i in input:
    24. 

  24. 		if not i in output:
    25. 

  25. 			output.append(i)
    26. 

  26. 	return output
    27. 

  27. 

  28. def skipc(flines,fin):  #  remove comment, treat continuous lines,
    29. 

  29. 	            #  and make list [number 
    30. 

  30. 	re_nocomm = re.compile('^\ *subroutine', re.IGNORECASE)
    31. 

  31. 	re_char   = re.compile('("[^"]*")|(\'[^\']*\')')
    32. 

  32. 	il=0
    33. 

  33. 	fff =[]
    34. 

  34. 	init=1
    35. 

  35. 	#ixxx=0
    36. 

  36. 	for fl in flines:
    37. 

  37. 		#ixxx=ixxx+1
    38. 

  38. 		#print ixxx, fl
    39. 

  39. 		il=il+1
    40. 

  40. 		if(not re.search('( |#)',fl[0:1])): continue  # skip comment line
    41. 

  41. 		flx = re.split('!',fl)[0]
    42. 

  42. 		if(re.search('#',fl[0:1]) or re.search(' ',fl[5:6]) ):
    43. 

  43. 			if(init==0):
    44. 

  44. 				flo =string.lower(flo)
    45. 

  45. 				flo = re_char.sub('@@@',flo) #
    46. 

  46. 				flo  = re.sub('^ *','',flo) 
    47. 

  47. 				flo  = re.sub(' +',' ',flo) 
    48. 

  48. 				flo  = re.sub('end *do','enddo',flo, re.IGNORECASE) 
    49. 

  49. 				flo  = re.sub('end *if','endif',flo, re.IGNORECASE) 
    50. 

  50. 				flo  = re.sub('end *interface','endinterface',flo, re.IGNORECASE) 
    51. 

  51. 				fff.append([fin,ilo,flo,floo])
    52. 

  52. 			else:
    53. 

  53. 				init=0
    54. 

  54. 			flo =  flx    #new sentence start
    55. 

  55. 			floo=  fl +'\n'   #new sentence start
    56. 

  56. 			ilo= il
    57. 

  57. 		else:   #continuous line            
    58. 

  58. 			flo= flo + flx[6:]
    59. 

  59. 			floo= floo + fl + '\n'
    60. 

  60. 	flo  = re.sub('^ *','',flo) 
    61. 

  61. 	flo  = re.sub(' +',' ',flo) 
    62. 

  62. 	fff.append([fin,ilo,string.lower(flo),floo])
    63. 

  63. #	for x in fff:
    64. 

  64. #		print x[0:3]
    65. 

  65. #	sys.exit()
    66. 

  66. 	return fff
    67. 

  67. 	    
    68. 

  68. re_mod      =  re.compile( '^\ *module(?!( *procedure))', re.IGNORECASE)
    69. 

  69. rcall       =  re.compile( 'call', re.IGNORECASE)
    70. 

  70. re_function =  re.compile( \
    71. 

  71. 	'((^\ *(complex|real|double|character|integer|logical)[^!]* *function))', re.IGNORECASE)
    72. 

  72. re_function2 =  re.compile( \
    73. 

  73. 	'((^\ *function))', re.IGNORECASE)
    74. 

  74. re_end       = re.compile( '((^\ *end( |\Z)+(?!(if|select))))', re.IGNORECASE)
    75. 

  75. re_end_mod   = re.compile( '((^\ *end *module))', re.IGNORECASE)
    76. 

  76. re_contains  = re.compile( '((^\ *contains))', re.IGNORECASE)
    77. 

  77. re_subroutine= re.compile( '^\ *subroutine', re.IGNORECASE)
    78. 

  78. re_blockdata = re.compile( '^\ *blockdata', re.IGNORECASE)
    79. 

  79. re_type      = re.compile( '^\ *type +(?!\()', re.IGNORECASE)
    80. 

  80. re_call      = re.compile( '^\ *call', re.IGNORECASE)
    81. 

  81. re_use       = re.compile( '^\ *use', re.IGNORECASE)
    82. 

  82. re_program   = re.compile( '^\ *program', re.IGNORECASE)
    83. 

  83. re_entry     = re.compile( '^\ *entry', re.IGNORECASE)
    84. 

  84. reff         = re.compile( 'function', re.IGNORECASE)
    85. 

  85. rcal         = re.compile( 'call', re.IGNORECASE)
    86. 

  86. ruse         = re.compile( 'use *', re.IGNORECASE)
    87. 

  87. rsub         = re.compile( 'subroutine', re.IGNORECASE)
    88. 

  88. rmod         = re.compile( 'module', re.IGNORECASE)
    89. 

  89. rprog        = re.compile( 'program', re.IGNORECASE)
    90. 

  90. rent         = re.compile( 'entry', re.IGNORECASE)
    91. 

  91. rblock       = re.compile( 'blockdata', re.IGNORECASE)
    92. 

  92. rtype        = re.compile( 'type', re.IGNORECASE)
    93. 

  93. 

  94. nargv = len(sys.argv) -1
    95. 

  95. if(nargv==0) :
    96. 

  96. 	print 'usage: analyze.py {name of top routine} source files ... (order them as you link them).'
    97. 

  97. 	sys.exit()
    98. 

  98. 

  99. print '######### analyze.py ###### Generate tree for ####### ' ,sys.argv[1]
    100. 

  100. src  = connect(sys.argv[2:])
    101. 

  101. #print '################## src =', src
    102. 

  102. #fff = os.system(zzz+ ' > ' + tmp)
    103. 

  103. #sys.exit()
    104. 

  104. ffiles=src
    105. 

  105. 

  106. # tmp = 'makedat'
    107. 

  107. # oxx = string.split(open(tmp,'rt').read(),'\n')
    108. 

  108. # ### Find all fortran files.
    109. 

  109. # ffiles=[]
    110. 

  110. # #ix=0
    111. 

  111. # for iline in oxx:
    112. 

  112. # #	ix=ix+1
    113. 

  113. # #	if(iline[0:3]!='ifc'): continue
    114. 

  114. # 	offf = re.split(' +',iline)
    115. 

  115. # 	for iff in offf[1:]:
    116. 

  116. # 		if(re.search('\.o',iff)):
    117. 

  117. # 			ffile = re.sub('\.o','.F',iff)
    118. 

  118. # 			ffiles.append(ffile)
    119. 

  119. # #			print ffile
    120. 

  120. #ffiles = uniqlist(ffiles)
    121. 

  121. ffiles = re.split(' *',ffiles)[1:]
    122. 

  122. print ffiles
    123. 

  123. 

  124. ####################################################
    125. 

  125. # test
    126. 

  126. #ffiles=[]
    127. 

  127. #ffiles= ['../gwsrc/genallcf_mod.F']
    128. 

  128. #ffiles= ['../gwsrc/tetwt4.F','../main/h_uumatrix.m.F','../gwsrc/pointops.F','../gwsrc/genallcf_mod.F','../gwsrc/readeigen.F', '../main/hx0fp0.m.F']
    129. 

  129. #ffiles= ['../gwsrc/tetwt4.F']#,'../gwsrc/pointops.F','../main/h_uumatrix.m.F']#,'../gwsrc/genallcf_mod.F','../gwsrc/readeigen.F', '../main/hx0fp0.m.F']
    130. 

  130. #ffiles = re.split(' +',ffiles)
    131. 

  131. #print ffiles
    132. 

  132. ####################################################
    133. 

  133. 

  134. 

  135. 

  136. ### skip comments ##############################
    137. 

  137. #fall=[]
    138. 

  138. sdef={}
    139. 

  139. mdef={}
    140. 

  140. for ffilein in ffiles:
    141. 

  141. 	print 
    142. 

  142. 	print ffilein ," ------------------------"
    143. 

  143. 	flines = string.split(open(ffilein,'rt').read(),'\n')
    144. 

  144. 	flines = skipc(flines,ffilein) #flines are list
    145. 

  145. 	
    146. 

  146. ### find subroutines and range
    147. 

  147. #for ff in fall: #ff contains line data for each file
    148. 

  148. 	level=0
    149. 

  149. 	calllist=[]
    150. 

  150. 	slines=[]
    151. 

  151. 	sstack=[]
    152. 

  152. 	fdat= flines[0]
    153. 

  153. 	fff = ['main',fdat[0],fdat[1],fdat[3]]
    154. 

  154. 	sstack.append(fff)
    155. 

  155. 

  156. # fdat[0]   FileNM
    157. 

  157. # fdat[1]   line number
    158. 

  158. # fdat[2]   line (comment removed)
    159. 

  159. # fdat[3]   line data  
    160. 

  160. 	for fdat in flines:
    161. 

  161. 		fline =fdat[2]
    162. 

  162. 		num =  fdat[1]
    163. 

  163. 		slines.append([num,fline])
    164. 

  164. #		slines[num]=fline
    165. 

  165. #		print fline
    166. 

  166. 		if(  re_mod.search(fline)):
    167. 

  167. 			level=level+1
    168. 

  168. 			subname= re.sub('^ *','',rmod.split(fline,maxsplit=1)[1])
    169. 

  169. 			subname= re.split("( |^Z)",subname)[0]
    170. 

  170. 			fff= ['mod: '+subname,fdat[0],fdat[1],fdat[3]]
    171. 

  171. 			sstack.append(fff)
    172. 

  172. 		elif(re_end_mod.search(fline)): #module
    173. 

  173. 			level=level-1
    174. 

  174. 			fff = sstack.pop()
    175. 

  175. 			subname = string.lower(fff[0])  #[5:]
    176. 

  176. 			mdef[subname]= fff[1:3] + [fdat[1]] + [fff[3]] +[''] +['']#add range end
    177. 

  177. 		elif(re_program.search(fline) ):
    178. 

  178. 			level=level+1
    179. 

  179. 			subname= string.split( rprog.split(fline,maxsplit=1)[1]," " )[1]
    180. 

  180. 			subname= rsp(subname)
    181. 

  181. 			fff= ['mai: '+subname,fdat[0],fdat[1],fdat[3]]
    182. 

  182. 			sstack.append(fff)
    183. 

  183. 		elif(re_subroutine.search(fline) ):
    184. 

  184. 			level=level+1
    185. 

  185. 			subname= string.split( rsub.split(fline,maxsplit=1)[1],"(" )[0]
    186. 

  186. 			subname= rsp(subname)
    187. 

  187. 			fff= ['sub: '+subname,fdat[0],fdat[1],fdat[3]]
    188. 

  188. 			sstack.append(fff)
    189. 

  189. 		elif(re_entry.search(fline) ):
    190. 

  190. 			level=level
    191. 

  191. 			subname= string.split( rent.split(fline,maxsplit=1)[1],"(" )[0]
    192. 

  192. 			subname= rsp(subname)
    193. 

  193. 			fff= ['sub: '+subname,fdat[0],fdat[1],fdat[3]]
    194. 

  194. 			sstack.append(fff)
    195. 

  195. 		elif(re_function.search(fline) or re_function2.search(fline) ):
    196. 

  196. 			level=level+1
    197. 

  197. 			subname= string.split( reff.split(fline,maxsplit=1)[1],"(" )[0]
    198. 

  198. 			subname= rsp(subname)
    199. 

  199. 			fff= ['fun: '+subname,fdat[0],fdat[1],fdat[3]]
    200. 

  200. 			sstack.append(fff)
    201. 

  201. 		elif(re_end.search(fline)):
    202. 

  202. 			level=level-1
    203. 

  203. 			fff = sstack.pop()
    204. 

  204. #			print ' fline =',fline
    205. 

  205. #			print ' sstack =',fff
    206. 

  206.  			if(sdef.has_key(fff[0])):
    207. 

  207. 				fff[0]=fff[0]+'+'
    208. 

  208. 				while(1) :
    209. 

  209. 					if(sdef.has_key(fff[0])):
    210. 

  210. 						fff[0]=fff[0]+'+'
    211. 

  211. 						continue
    212. 

  212. 					break
    213. 

  213. # 				print ' subroutine:: ',fff[0],sdef[fff[0]]
    214. 

  214. # 				print ' subroutine:: ',[fdat[0],fdat[1],fdat[3]]
    215. 

  215. # 				print " ERROR: duplicated subroutine name ..."
    216. 

  216. # 				for x in sdef:
    217. 

  217. # 					print x
    218. 

  218. # 				sys.exit()
    219. 

  219. 			subname = string.lower(fff[0]) #[5:]
    220. 

  220. 			sdef[subname]= fff[1:3] + [fdat[1]] + [fff[3]] + [calllist] + [slines] #add range end
    221. 

  221. 			slines=[]
    222. 

  222. 			calllist=[]
    223. 

  223. 		elif(re_call.search(fline)):
    224. 

  224. 			subname= rsp( string.split( rcall.split(fline,maxsplit=1)[1],"(" )[0] )
    225. 

  225. 			fff= [subname,fdat[0],fdat[1],fdat[3]]
    226. 

  226. 			calllist.append(fff)
    227. 

  227. 		elif(re_use.search(fline)):
    228. 

  228. 			subname= re.sub('^ *','',ruse.split(fline,maxsplit=1)[1])
    229. 

  229. 			subname= rsp( re.split("(,|^Z| )", subname)[0] )
    230. 

  230. 			fff= [subname,fdat[0],fdat[1],fdat[3]]
    231. 

  231. 			calllist.append(fff)
    232. 

  232. 			print fff
    233. 

  233. 		elif(re_blockdata.search(fline) ):
    234. 

  234. 			level=level+1
    235. 

  235. 			subname= rsp( re.split("(\  |\n)", rblock.split(fline,maxsplit=1)[1])[0] )
    236. 

  236. 			fff= ['block: '+subname,fdat[0],fdat[1],fdat[3]]
    237. 

  237. 			sstack.append(fff)
    238. 

  238. 		elif(re_type.search(fline) ):
    239. 

  239. 			level=level+1
    240. 

  240. 			subname= rsp( re.split("(\  |\n)", rtype.split(fline,maxsplit=1)[1])[0] )
    241. 

  241. 			fff= ['type: '+subname,fdat[0],fdat[1],fdat[3]]
    242. 

  242. 			sstack.append(fff)
    243. 

  243. 		else:
    244. 

  244. 			continue
    245. 

  245. #		print  (' %5i ' % fdat[1]) + ( '%2i ' %  level),fdat[2]
    246. 

  246. 		continue
    247. 

  247. 

  248. 		if( re_contains.search(fline)):	level=level+1
    249. 

  249. 

  250. ##########################################
    251. 

  251. # print '################## module ##########################'
    252. 

  252. # for i in mdef:
    253. 

  253. #  	print i+' : ',mdef[i][0:3]
    254. 

  254. #  	print mdef[i][3]
    255. 

  255. #  	print 'def@  ', i, mdef[i][0], mdef[i][1], mdef[i][2]
    256. 

  256. sdef.update(mdef)
    257. 

  257. skeys=sdef.keys()
    258. 

  258. skeys.sort()
    259. 

  259. 

  260. 

  261. ### find functions #######################
    262. 

  262. fun=[]
    263. 

  263. rfun='fjpadpqe341padfeh=>this is for rfun is empty case'
    264. 

  264. init=1
    265. 

  265. for k in sdef.keys():
    266. 

  266. 	if(k[0:5]=='fun: '):
    267. 

  267. 		fun = fun + [k[5:]]
    268. 

  268. 		if(init==1):
    269. 

  269. 			aa=''
    270. 

  270. 			init=0
    271. 

  271. 		else:
    272. 

  272. 			aa='|'
    273. 

  273. 		rrr  = re.sub( '\+','',k[5:] )
    274. 

  274. 		rfun = rfun + aa + rrr
    275. 

  275. 	if(k[0:5]=='mod: '):
    276. 

  276. 		fun = fun + [k[5:]]
    277. 

  277. 		if(init==1):
    278. 

  278. 			aa=''
    279. 

  279. 			init=0
    280. 

  280. 		else:
    281. 

  281. 			aa='|'
    282. 

  282. 		rrr  = re.sub( '\+','',k[5:] )
    283. 

  283. 		rfun = rfun + aa + rrr
    284. 

  284. 	if(k[0:6]=='type: '):
    285. 

  285. 		fun = fun + [k[6:]]
    286. 

  286. 		if(init==1):
    287. 

  287. 			aa=''
    288. 

  288. 			init=0
    289. 

  289. 		else:
    290. 

  290. 			aa='|'
    291. 

  291. 		rrr  = re.sub( '\+','',k[6:] )
    292. 

  292. 		rfun = rfun + aa + rrr
    293. 

  293. 	if(k[0:7]=='block: '):
    294. 

  294. 		fun = fun + [k[7:]]
    295. 

  295. 		if(init==1):
    296. 

  296. 			aa=''
    297. 

  297. 			init=0
    298. 

  298. 		else:
    299. 

  299. 			aa='|'
    300. 

  300. 		rrr  = re.sub( '\+','',k[7:] )
    301. 

  301. 		rfun = rfun + aa + rrr
    302. 

  302. rfun = '(?<=\W)('+ rfun +')(?=\W)'
    303. 

  303. rfff = re.compile(rfun)
    304. 

  304. print ' rfun=',rfun
    305. 

  305. #sys.exit()
    306. 

  306. 

  307. 

  308. ###########find function calls ###############################
    309. 

  309. for i in skeys:
    310. 

  310. 	filen= sdef[i][0] 
    311. 

  311. 	slines=sdef[i][5]
    312. 

  312. 

  313. # 	print 'fff ',filen, slines
    314. 

  314. 

  315. #	init = sdef[i][1]
    316. 

  316. #	end  = sdef[i][2]
    317. 

  317. #	print 'def@  ', i,filen,init,end 
    318. 

  318. #	for ifun in fun:
    319. 

  319. #		slines = re.sub(ifun,'~'+ifun+'~',slines)
    320. 

  320. 	for ix in slines:
    321. 

  321. 		num= ix[0]
    322. 

  322. #		aaa=re.findall(rfun,ix[1])
    323. 

  323. 		aaa= rfff.findall(ix[1])
    324. 

  324. 		output = []
    325. 

  325. #		print 'aaa',ix
    326. 

  326. 		for aaax in aaa:
    327. 

  327. 			if(not (aaax==i[5:])):
    328. 

  328. 				output.append(aaax)
    329. 

  329. 		if(not (output==[])):
    330. 

  330. 			for iout in output:
    331. 

  331. #				print num,iout,ix[1]
    332. 

  332. 				fff= [iout,filen,num]
    333. 

  333. 				sdef[i][4].append(fff)
    334. 

  334. # This is full data
    335. 

  335. #	for line in sdef[i][5]:
    336. 

  336. #		print line # iline =  [line number, line text]
    337. 

  337. 

  338. #	print sdef[i][3],
    339. 

  339. #	for ic in sdef[i][4]:
    340. 

  340. #		print 'cal@  ', i,' ',ic[0],ic[1],ic[2]
    341. 

  341. 

  342. #sys.exit()
    343. 

  343. 

  344. ### Write definition and call. ####
    345. 

  345. print '#############################################'
    346. 

  346. for i in skeys:
    347. 

  347. 	filen= sdef[i][0] 
    348. 

  348. 	init = sdef[i][1]
    349. 

  349. 	end  = sdef[i][2]
    350. 

  350. 	print
    351. 

  351. 	print 'def@  ', i,filen,init,end 
    352. 

  352. # This is full data
    353. 

  353. #	for line in sdef[i][5]:
    354. 

  354. #		print line # iline =  [line number, line text]
    355. 

  355. 

  356. #	print sdef[i][3],
    357. 

  357. 	for ic in sdef[i][4]:
    358. 

  358. 		print 'cal@  ', i,' ',ic[0],ic[1],ic[2]
    359. 

  359. 

  360. 

  361. ### remove header from sdef ############
    362. 

  362. for i in skeys:
    363. 

  363. 	ii  = i[5:]
    364. 

  364. 	sss = sdef[i]
    365. 

  365. 	del sdef[i]
    366. 

  366. 	sdef[ii]= sss
    367. 

  367. 

  368. ### tree generation ####################
    369. 

  369. i=sys.argv[1]
    370. 

  370. once = 1
    371. 

  371. print '###### call tree for ', i,' ##########'
    372. 

  372. 

  373. calling1 = sdef[i][4]
    374. 

  374. for ic1 in calling1:
    375. 

  375. 	print 'tree0 ', ic1[0],ic1[1],ic1[2]
    376. 

  376. 	ir1 = ic1[0]
    377. 

  377. 	try:
    378. 

  378. 		calling2= sdef[ir1][4]
    379. 

  379. 	except:
    380. 

  380. 		continue
    381. 

  381. 	
    382. 

  382. 	icalled2=[]
    383. 

  383. 	for ic2 in calling2:
    384. 

  384. 		ir2 = ic2[0]
    385. 

  385. 		if once==1 and ir2 in icalled2:	continue
    386. 

  386. 		icalled2.append(ir2)
    387. 

  387. 		print 'tree1  |  ',ic2[0],ic2[1],ic2[2]
    388. 

  388. 		try:
    389. 

  389. 			calling3= sdef[ir2][4]
    390. 

  390. 		except:
    391. 

  391. 			continue
    392. 

  392. 

  393. 		icalled3=[]
    394. 

  394. 		for ic3 in calling3:
    395. 

  395. 			ir3 = ic3[0]
    396. 

  396. 			if once==1 and ir3 in icalled3:	continue
    397. 

  397. 			icalled3.append(ir3)
    398. 

  398. 			print 'tree2  |   | ',ic3[0],ic3[1],ic3[2]
    399. 

  399. 			try:
    400. 

  400. 				calling4= sdef[ir3][4]
    401. 

  401. 			except:
    402. 

  402. 				continue
    403. 

  403. 

  404. 			icalled4 = []
    405. 

  405. 			for ic4 in calling4:
    406. 

  406. 				ir4 = ic4[0]
    407. 

  407. 				if once==1 and ir4 in icalled4:	continue
    408. 

  408. 				icalled4.append(ir4)
    409. 

  409. 				
    410. 

  410. 				print 'tree3  |   |  | ',ic4[0],ic4[1],ic4[2]
    411. 

  411. 				try:
    412. 

  412. 					calling5= sdef[ir4][4]
    413. 

  413. 				except:
    414. 

  414. 					continue
    415. 

  415. 

  416. 

  417. sys.exit()
    418. 

  418. 

  419. 

  420. 

  421. 

  422. 

  423.