201
208
'struct','static','register','new','break','do','goto','switch',
202
209
'continue','else','inline','extern','delete','const','auto',
203
210
'len','rank','shape','index','slen','size','_i',
205
213
'string','complex_double','float_double','stdin','stderr','stdout',
206
214
'type','default']:
207
215
badnames[n]=n+'_bn'
208
216
invbadnames[n+'_bn']=n
209
217
def rmbadname1(name):
210
if badnames.has_key(name):
211
219
errmess('rmbadname1: Replacing "%s" with "%s".\n'%(name,badnames[name]))
212
220
return badnames[name]
214
222
def rmbadname(names): return map(rmbadname1,names)
216
224
def undo_rmbadname1(name):
217
if invbadnames.has_key(name):
225
if name in invbadnames:
218
226
errmess('undo_rmbadname1: Replacing "%s" with "%s".\n'\
219
227
%(name,invbadnames[name]))
220
228
return invbadnames[name]
317
325
l=r.group('line')+' ' # Strip comments starting with `!'
318
326
rl=r.group('rest')
319
if string.lower(rl[:4])=='f2py': # f2py directive
327
if rl[:4].lower()=='f2py': # f2py directive
321
329
r=commentline.match(rl[4:])
322
330
if r: l=l+r('line')
323
331
else: l = l + rl[4:]
324
if string.strip(l)=='': # Skip empty line
332
if l.strip()=='': # Skip empty line
327
335
if sourcecodeform=='fix':
328
336
if l[0] in ['*','c','!','C','#']:
329
if string.lower(l[1:5])=='f2py': # f2py directive
337
if l[1:5].lower()=='f2py': # f2py directive
331
339
else: # Skip comment line
450
458
groupbegins77=r'program|block\s*data'
451
459
beginpattern77=re.compile(beforethisafter%('',groupbegins77,groupbegins77,'.*'),re.I),'begin'
452
groupbegins90=groupbegins77+r'|module|python\s*module|interface|type(?!\s*\()'
460
groupbegins90=groupbegins77+r'|module(?!\s*procedure)|python\s*module|interface|type(?!\s*\()'
453
461
beginpattern90=re.compile(beforethisafter%('',groupbegins90,groupbegins90,'.*'),re.I),'begin'
454
462
groupends=r'end|endprogram|endblockdata|endmodule|endpythonmodule|endinterface'
455
463
endpattern=re.compile(beforethisafter%('',groupends,groupends,'[\w\s]*'),re.I),'end'
483
491
def _simplifyargs(argsline):
485
for n in string.split(markoutercomma(argsline),'@,@'):
493
for n in markoutercomma(argsline).split('@,@'):
487
n = string.replace(n,r,'_')
489
return string.join(a,',')
491
499
crackline_re_1 = re.compile(r'\s*(?P<result>\b[a-z]+[\w]*\b)\s*[=].*',re.I)
492
500
def crackline(line,reset=0):
562
570
re_1 = crackline_re_1
563
571
if 0<=skipblocksuntil<=groupcounter:return
564
if groupcache[groupcounter].has_key('externals'):
572
if 'externals' in groupcache[groupcounter]:
565
573
for name in groupcache[groupcounter]['externals']:
566
if invbadnames.has_key(name):
574
if name in invbadnames:
567
575
name=invbadnames[name]
568
if groupcache[groupcounter].has_key('interfaced') and name in groupcache[groupcounter]['interfaced']: continue
576
if 'interfaced' in groupcache[groupcounter] and name in groupcache[groupcounter]['interfaced']:
569
578
m1=re.match(r'(?P<before>[^"]*)\b%s\b\s*@\(@(?P<args>[^@]*)@\)@.*\Z'%name,markouterparen(line),re.I)
571
580
m2 = re_1.match(m1.group('before'))
650
659
assert not f,`f,line,l,cc`
652
661
def unmarkouterparen(line):
653
r = string.replace(string.replace(line,'@(@','('),'@)@',')')
662
r = line.replace('@(@','(').replace('@)@',')')
655
664
def appenddecl(decl,decl2,force=1):
656
665
if not decl: decl={}
748
759
if case in ['call','callfun']:
750
if not groupcache[groupcounter].has_key('args'): return
761
if 'args' not in groupcache[groupcounter]:
751
763
if name not in groupcache[groupcounter]['args']:
753
765
for it in grouplist[groupcounter]:
754
if it['name']==name: return
755
if name in groupcache[groupcounter]['interfaced']: return
768
if name in groupcache[groupcounter]['interfaced']:
756
770
block={'call':'subroutine','callfun':'function'}[case]
757
771
if f77modulename and neededmodule==-1 and groupcounter<=1:
758
772
neededmodule=groupcounter+2
864
878
elif case in ['dimension','intent','optional','required','external','public','private','intrisic']:
865
879
edecl=groupcache[groupcounter]['vars']
866
880
ll=m.group('after').strip()
867
i=string.find(ll,'::')
868
882
if i<0 and case=='intent':
869
i=string.find(markouterparen(ll),'@)@')-2
883
i=markouterparen(ll).find('@)@')-2
870
884
ll=ll[:i+1]+'::'+ll[i+1:]
871
i=string.find(ll,'::')
872
if ll[i:]=='::' and groupcache[groupcounter].has_key('args'):
886
if ll[i:]=='::' and 'args' in groupcache[groupcounter]:
873
887
outmess('All arguments will have attribute %s%s\n'%(m.group('this'),ll[:i]))
874
ll = ll + string.join(groupcache[groupcounter]['args'],',')
888
ll = ll + ','.join(groupcache[groupcounter]['args'])
876
else: pl=string.strip(ll[:i]);ll=ll[i+2:]
877
ch = string.split(markoutercomma(pl),'@,@')
890
else: pl=ll[:i].strip();ll=ll[i+2:]
891
ch = markoutercomma(pl).split('@,@')
880
894
outmess('analyzeline: cannot handle multiple attributes without type specification. Ignoring %r.\n' % (','.join(ch[1:])))
882
for e in map(string.strip,string.split(markoutercomma(ll),'@,@')):
897
for e in [x.strip() for x in markoutercomma(ll).split('@,@')]:
883
898
m1=namepattern.match(e)
885
900
if case in ['public','private']: k=''
891
906
k=rmbadname1(m1.group('name'))
892
if not edecl.has_key(k): edecl[k]={}
893
if case=='dimension': ap=case+m1.group('after')
909
if case=='dimension':
910
ap=case+m1.group('after')
894
911
if case=='intent':
895
912
ap=m.group('this')+pl
896
913
if _intentcallbackpattern.match(ap):
897
914
if k not in groupcache[groupcounter]['args']:
898
if groupcounter>1 and \
899
string.find(groupcache[groupcounter-2]['name'],
901
916
outmess('analyzeline: appending intent(callback) %s'\
902
917
' to %s arguments\n' % (k,groupcache[groupcounter]['name']))
918
if '__user__' not in groupcache[groupcounter-2]['name']:
919
outmess('analyzeline: missing __user__ module (could be nothing)\n')
903
920
groupcache[groupcounter]['args'].append(k)
922
errmess('analyzeline: intent(callback) %s is ignored' % (k))
905
924
errmess('analyzeline: intent(callback) %s is already'\
906
925
' in argument list' % (k))
907
if case in ['optional','required','public','external','private','intrisic']: ap=case
908
if edecl[k].has_key('attrspec'): edecl[k]['attrspec'].append(ap)
909
else: edecl[k]['attrspec']=[ap]
926
if case in ['optional','required','public','external','private','intrisic']:
928
if 'attrspec' in edecl[k]:
929
edecl[k]['attrspec'].append(ap)
931
edecl[k]['attrspec']=[ap]
910
932
if case=='external':
911
933
if groupcache[groupcounter]['block']=='program':
912
934
outmess('analyzeline: ignoring program arguments\n')
923
945
previous_context = ('variable',last_name,groupcounter)
924
946
elif case=='parameter':
925
947
edecl=groupcache[groupcounter]['vars']
926
ll=string.strip(m.group('after'))[1:-1]
948
ll=m.group('after').strip()[1:-1]
928
for e in string.split(markoutercomma(ll),'@,@'):
950
for e in markoutercomma(ll).split('@,@'):
930
k,initexpr=map(string.strip,string.split(e,'='))
952
k,initexpr=[x.strip() for x in e.split('=')]
932
954
outmess('analyzeline: could not extract name,expr in parameter statement "%s" of "%s"\n'%(e,ll));continue
933
955
params = get_parameters(edecl)
935
if not edecl.has_key(k): edecl[k]={}
936
if edecl[k].has_key('=') and (not edecl[k]['=']==initexpr):
959
if '=' in edecl[k] and (not edecl[k]['=']==initexpr):
937
960
outmess('analyzeline: Overwriting the value of parameter "%s" ("%s") with "%s".\n'%(k,edecl[k]['='],initexpr))
938
961
t = determineexprtype(initexpr,params)
961
984
if last_name is not None:
962
985
previous_context = ('variable',last_name,groupcounter)
963
986
elif case=='implicit':
964
if string.lower(string.strip(m.group('after')))=='none':
987
if m.group('after').strip().lower()=='none':
965
988
groupcache[groupcounter]['implicit']=None
966
989
elif m.group('after'):
967
if groupcache[groupcounter].has_key('implicit'):
990
if 'implicit' in groupcache[groupcounter]:
968
991
impl=groupcache[groupcounter]['implicit']
971
994
outmess('analyzeline: Overwriting earlier "implicit none" statement.\n')
973
for e in string.split(markoutercomma(m.group('after')),'@,@'):
996
for e in markoutercomma(m.group('after')).split('@,@'):
975
998
m1=re.match(r'\s*(?P<this>.*?)\s*(\(\s*(?P<after>[a-z-, ]+)\s*\)\s*|)\Z',e,re.I)
986
1009
decl['typename']=typename
987
1010
for k in decl.keys():
988
1011
if not decl[k]: del decl[k]
989
for r in string.split(markoutercomma(m1.group('after')),'@,@'):
1012
for r in markoutercomma(m1.group('after')).split('@,@'):
991
try: begc,endc=map(string.strip,string.split(r,'-'))
1014
try: begc,endc=[x.strip() for x in r.split('-')]
993
1016
outmess('analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement\n'%r);continue
994
else: begc=endc=string.strip(r)
1017
else: begc=endc=r.strip()
995
1018
if not len(begc)==len(endc)==1:
996
1019
outmess('analyzeline: expected "<char>-<char>" instead of "%s" in range list of implicit statement (2)\n'%r);continue
997
1020
for o in range(ord(begc),ord(endc)+1):
1056
1079
if last_name is not None:
1057
1080
previous_context = ('variable',last_name,groupcounter)
1058
1081
elif case=='common':
1059
line=string.strip(m.group('after'))
1082
line=m.group('after').strip()
1060
1083
if not line[0]=='/':line='//'+line
1062
1085
f=0;bn='';ol=''
1064
1087
if c=='/':f=f+1;continue
1066
bn = string.strip(bn)
1067
1090
if not bn: bn='_BLNK_'
1068
1091
cl.append([bn,ol])
1069
1092
f=f-2;bn='';ol=''
1070
1093
if f%2: bn=bn+c
1072
bn = string.strip(bn)
1073
1096
if not bn: bn='_BLNK_'
1074
1097
cl.append([bn,ol])
1076
if groupcache[groupcounter].has_key('common'):
1099
if 'common' in groupcache[groupcounter]:
1077
1100
commonkey=groupcache[groupcounter]['common']
1079
if commonkey.has_key(c[0]):
1102
if c[0] in commonkey:
1080
1103
outmess('analyzeline: previously defined common block encountered. Skipping.\n')
1082
1105
commonkey[c[0]]=[]
1083
for i in map(string.strip,string.split(markoutercomma(c[1]),'@,@')):
1106
for i in [x.strip() for x in markoutercomma(c[1]).split('@,@')]:
1084
1107
if i: commonkey[c[0]].append(i)
1085
1108
groupcache[groupcounter]['common']=commonkey
1086
1109
previous_context = ('common',bn,groupcounter)
1088
1111
m1=re.match(r'\A\s*(?P<name>\b[\w]+\b)\s*((,(\s*\bonly\b\s*:|(?P<notonly>))\s*(?P<list>.*))|)\s*\Z',m.group('after'),re.I)
1090
1113
mm=m1.groupdict()
1091
if not groupcache[groupcounter].has_key('use'): groupcache[groupcounter]['use']={}
1114
if 'use' not in groupcache[groupcounter]:
1115
groupcache[groupcounter]['use']={}
1092
1116
name=m1.group('name')
1093
1117
groupcache[groupcounter]['use'][name]={}
1095
if mm.has_key('list') and mm['list'] is not None:
1096
if mm.has_key('notonly') and mm['notonly'] is None:isonly=1
1119
if 'list' in mm and mm['list'] is not None:
1120
if 'notonly' in mm and mm['notonly'] is None:
1097
1122
groupcache[groupcounter]['use'][name]['only']=isonly
1098
ll=map(string.strip,string.split(mm['list'],','))
1123
ll=[x.strip() for x in mm['list'].split(',')]
1102
1127
m2=re.match(r'\A\s*(?P<local>\b[\w]+\b)\s*=\s*>\s*(?P<use>\b[\w]+\b)\s*\Z',l,re.I)
1103
if m2: rl[string.strip(m2.group('local'))]=string.strip(m2.group('use'))
1128
if m2: rl[m2.group('local').strip()]=m2.group('use').strip()
1105
1130
outmess('analyzeline: Not local=>use pattern found in %s\n'%`l`)
1113
1138
print m.groupdict()
1114
1139
outmess('analyzeline: Could not crack the use statement.\n')
1115
1140
elif case in ['f2pyenhancements']:
1116
if not groupcache[groupcounter].has_key ('f2pyenhancements'):
1141
if 'f2pyenhancements' not in groupcache[groupcounter]:
1117
1142
groupcache[groupcounter]['f2pyenhancements'] = {}
1118
1143
d = groupcache[groupcounter]['f2pyenhancements']
1119
if m.group('this')=='usercode' and d.has_key('usercode'):
1144
if m.group('this')=='usercode' and 'usercode' in d:
1120
1145
if type(d['usercode']) is type(''):
1121
1146
d['usercode'] = [d['usercode']]
1122
1147
d['usercode'].append(m.group('after'))
1138
1163
outmess('analyzeline: No code implemented for line.\n')
1140
1165
def appendmultiline(group, context_name,ml):
1141
if not group.has_key('f2pymultilines'):
1166
if 'f2pymultilines' not in group:
1142
1167
group['f2pymultilines'] = {}
1143
1168
d = group['f2pymultilines']
1144
if not d.has_key(context_name):
1169
if context_name not in d:
1145
1170
d[context_name] = []
1146
1171
d[context_name].append(ml)
1173
1198
lenkindpattern=re.compile(r'\s*(kind\s*=\s*(?P<kind>.*?)\s*(@,@\s*len\s*=\s*(?P<len>.*)|)|(len\s*=\s*|)(?P<len2>.*?)\s*(@,@\s*(kind\s*=\s*|)(?P<kind2>.*)|))\s*\Z',re.I)
1174
1199
lenarraypattern=re.compile(r'\s*(@\(@\s*(?!/)\s*(?P<array>.*?)\s*@\)@\s*[*]\s*(?P<len>.*?)|([*]\s*(?P<len2>.*?)|)\s*(@\(@\s*(?!/)\s*(?P<array2>.*?)\s*@\)@|))\s*(=\s*(?P<init>.*?)|(@\(@|)/\s*(?P<init2>.*?)\s*/(@\)@|)|)\s*\Z',re.I)
1175
1200
def removespaces(expr):
1176
expr=string.strip(expr)
1177
1202
if len(expr)<=1: return expr
1179
1204
for i in range(1,len(expr)-1):
1180
1205
if expr[i]==' ' and \
1181
((expr[i+1] in "()[]{}= ") or (expr[i-1] in "()[]{}= ")): continue
1206
((expr[i+1] in "()[]{}=+-/* ") or (expr[i-1] in "()[]{}=+-/* ")): continue
1182
1207
expr2=expr2+expr[i]
1183
1208
expr2=expr2+expr[-1]
1203
1228
last_name = None
1204
1229
kindselect,charselect,typename=cracktypespec(typespec,selector)
1206
attrspec=map(string.strip,string.split(markoutercomma(attrspec),'@,@'))
1231
attrspec=[x.strip() for x in markoutercomma(attrspec).split('@,@')]
1208
1233
c = re.compile(r'(?P<start>[a-zA-Z]+)')
1209
1234
for a in attrspec:
1212
s = string.lower(m.group('start'))
1237
s = m.group('start').lower()
1213
1238
a = s + a[len(s):]
1216
el=map(string.strip,string.split(markoutercomma(entitydecl),'@,@'))
1241
el=[x.strip() for x in markoutercomma(entitydecl).split('@,@')]
1219
for e1 in map(string.strip,string.split(markoutercomma(removespaces(markinnerspaces(e)),comma=' '),'@ @')):
1220
if e1: el1.append(string.replace(e1,'@_@',' '))
1244
for e1 in [x.strip() for x in markoutercomma(removespaces(markinnerspaces(e)),comma=' ').split('@ @')]:
1245
if e1: el1.append(e1.replace('@_@',' '))
1222
1247
m=namepattern.match(e)
1226
1251
ename=rmbadname1(m.group('name'))
1228
if groupcache[groupcounter]['vars'].has_key(ename):
1253
if ename in groupcache[groupcounter]['vars']:
1229
1254
edecl=groupcache[groupcounter]['vars'][ename].copy()
1230
has_typespec = edecl.has_key('typespec')
1231
if not has_typespec:
1255
not_has_typespec = 'typespec' not in edecl
1256
if not_has_typespec:
1232
1257
edecl['typespec']=typespec
1233
1258
elif typespec and (not typespec==edecl['typespec']):
1234
1259
outmess('updatevars: attempt to change the type of "%s" ("%s") to "%s". Ignoring.\n' % (ename,edecl['typespec'],typespec))
1235
if not edecl.has_key('kindselector'):
1260
if 'kindselector' not in edecl:
1236
1261
edecl['kindselector']=copy.copy(kindselect)
1237
1262
elif kindselect:
1238
1263
for k in kindselect.keys():
1239
if edecl['kindselector'].has_key(k) and (not kindselect[k]==edecl['kindselector'][k]):
1264
if k in edecl['kindselector'] and (not kindselect[k]==edecl['kindselector'][k]):
1240
1265
outmess('updatevars: attempt to change the kindselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (k,ename,edecl['kindselector'][k],kindselect[k]))
1241
1266
else: edecl['kindselector'][k]=copy.copy(kindselect[k])
1242
if not edecl.has_key('charselector') and charselect:
1243
if not has_typespec:
1267
if 'charselector' not in edecl and charselect:
1268
if not_has_typespec:
1244
1269
edecl['charselector']=charselect
1246
1271
errmess('updatevars:%s: attempt to change empty charselector to %r. Ignoring.\n' \
1247
1272
%(ename,charselect))
1248
1273
elif charselect:
1249
1274
for k in charselect.keys():
1250
if edecl['charselector'].has_key(k) and (not charselect[k]==edecl['charselector'][k]):
1275
if k in edecl['charselector'] and (not charselect[k]==edecl['charselector'][k]):
1251
1276
outmess('updatevars: attempt to change the charselector "%s" of "%s" ("%s") to "%s". Ignoring.\n' % (k,ename,edecl['charselector'][k],charselect[k]))
1252
1277
else: edecl['charselector'][k]=copy.copy(charselect[k])
1253
if not edecl.has_key('typename'):
1278
if 'typename' not in edecl:
1254
1279
edecl['typename']=typename
1255
1280
elif typename and (not edecl['typename']==typename):
1256
1281
outmess('updatevars: attempt to change the typename of "%s" ("%s") to "%s". Ignoring.\n' % (ename,edecl['typename'],typename))
1257
if not edecl.has_key('attrspec'):
1282
if 'attrspec' not in edecl:
1258
1283
edecl['attrspec']=copy.copy(attrspec)
1260
1285
for a in attrspec:
1296
1321
% (ename,dm1,dm))
1299
if d1.has_key('len'):
1300
1325
if typespec in ['complex','integer','logical','real']:
1301
if (not edecl.has_key('kindselector')) or (not edecl['kindselector']):
1326
if ('kindselector' not in edecl) or (not edecl['kindselector']):
1302
1327
edecl['kindselector']={}
1303
1328
edecl['kindselector']['*']=d1['len']
1304
1329
elif typespec == 'character':
1305
if (not edecl.has_key('charselector')) or (not edecl['charselector']): edecl['charselector']={}
1306
if edecl['charselector'].has_key('len'): del edecl['charselector']['len']
1330
if ('charselector' not in edecl) or (not edecl['charselector']):
1331
edecl['charselector']={}
1332
if 'len' in edecl['charselector']:
1333
del edecl['charselector']['len']
1307
1334
edecl['charselector']['*']=d1['len']
1308
if d1.has_key('init'):
1309
if edecl.has_key('=') and (not edecl['=']==d1['init']):
1336
if '=' in edecl and (not edecl['=']==d1['init']):
1310
1337
outmess('updatevars: attempt to change the init expression of "%s" ("%s") to "%s". Ignoring.\n' % (ename,edecl['='],d1['init']))
1312
1339
edecl['=']=d1['init']
1314
1341
outmess('updatevars: could not crack entity declaration "%s". Ignoring.\n'%(ename+m.group('after')))
1315
1342
for k in edecl.keys():
1316
if not edecl[k]: del edecl[k]
1317
1345
groupcache[groupcounter]['vars'][ename]=edecl
1318
if groupcache[groupcounter].has_key('varnames'):
1346
if 'varnames' in groupcache[groupcounter]:
1319
1347
groupcache[groupcounter]['varnames'].append(ename)
1320
1348
last_name = ename
1321
1349
return last_name
1386
1416
decl['attrspec'].append(attr)
1388
1419
def setkindselector(decl,sel,force=0):
1389
if not decl: decl={}
1390
if not sel: return decl
1391
if not decl.has_key('kindselector'):
1424
if 'kindselector' not in decl:
1392
1425
decl['kindselector']=sel
1394
1427
for k in sel.keys():
1395
if force or not decl['kindselector'].has_key(k):
1428
if force or k not in decl['kindselector']:
1396
1429
decl['kindselector'][k]=sel[k]
1398
1432
def setcharselector(decl,sel,force=0):
1399
if not decl: decl={}
1400
if not sel: return decl
1401
if not decl.has_key('charselector'):
1437
if 'charselector' not in decl:
1402
1438
decl['charselector']=sel
1404
1440
for k in sel.keys():
1405
if force or not decl['charselector'].has_key(k):
1441
if force or k not in decl['charselector']:
1406
1442
decl['charselector'][k]=sel[k]
1408
1445
def getblockname(block,unknown='unknown'):
1409
if block.has_key('name'): return block['name']
1447
return block['name']
1411
1450
###### post processing
1412
1452
def setmesstext(block):
1413
1453
global filepositiontext
1414
try: filepositiontext='In: %s:%s\n'%(block['from'],block['name'])
1455
filepositiontext='In: %s:%s\n'%(block['from'],block['name'])
1417
1459
def get_usedict(block):
1419
if block.has_key('parent_block'):
1461
if 'parent_block' in block:
1420
1462
usedict = get_usedict(block['parent_block'])
1421
if block.has_key('use'):
1422
1464
usedict.update(block['use'])
1494
1536
for g in block:
1496
1538
g=postcrack(g,tab=tab+'\t')
1497
if g.has_key('name') and string.find(g['name'],'__user__')>=0: # sort user routines to appear first
1539
if 'name' in g and '__user__' in g['name']: # sort user routines to appear first
1501
1543
return uret+gret
1502
1544
setmesstext(block)
1503
if (not type(block)==types.DictType) and not block.has_key('block'):
1545
if (not type(block)==types.DictType) and 'block' not in block:
1504
1546
raise 'postcrack: Expected block dictionary instead of ',block
1505
if block.has_key('name') and not block['name']=='unknown_interface':
1547
if 'name' in block and not block['name']=='unknown_interface':
1506
1548
outmess('%sBlock: %s\n'%(tab,block['name']),0)
1507
1549
blocktype=block['block']
1508
1550
block=analyzeargs(block)
1509
1551
block=analyzecommon(block)
1510
1552
block['vars']=analyzevars(block)
1511
1553
block['sortvars']=sortvarnames(block['vars'])
1512
if block.has_key('args') and block['args']:
1554
if 'args' in block and block['args']:
1513
1555
args=block['args']
1514
1556
block['body']=analyzebody(block,args,tab=tab)
1516
1558
userisdefined=[]
1517
1559
## fromuser = []
1518
if block.has_key('use'):
1519
1561
useblock=block['use']
1520
1562
for k in useblock.keys():
1521
if string.find(k,'__user__')>=0:
1522
1564
userisdefined.append(k)
1523
## if useblock[k].has_key('map'):
1565
## if 'map' in useblock[k]:
1524
1566
## for n in useblock[k]['map'].values():
1525
1567
## if n not in fromuser: fromuser.append(n)
1526
1568
else: useblock={}
1528
if block.has_key('name'):name=block['name']
1529
if block.has_key('externals') and block['externals']:# and not userisdefined: # Build a __user__ module
1572
if 'externals' in block and block['externals']:# and not userisdefined: # Build a __user__ module
1531
if block.has_key('interfaced'): interfaced=block['interfaced']
1574
if 'interfaced' in block:
1575
interfaced=block['interfaced']
1532
1576
mvars=copy.copy(block['vars'])
1533
if name: mname=name+'__user__routines'
1534
else: mname='unknown__user__routines'
1578
mname=name+'__user__routines'
1580
mname='unknown__user__routines'
1535
1581
if mname in userisdefined:
1537
1583
while '%s_%i'%(mname,i) in userisdefined: i=i+1
1617
1663
if m.group('dims'):
1618
dims=map(string.strip,string.split(markoutercomma(m.group('dims')),'@,@'))
1619
n=string.strip(m.group('name'))
1620
if block['vars'].has_key(n):
1621
if block['vars'][n].has_key('attrspec'):
1622
block['vars'][n]['attrspec'].append('dimension(%s)'%(string.join(dims,',')))
1664
dims=[x.strip() for x in markoutercomma(m.group('dims')).split('@,@')]
1665
n=m.group('name').strip()
1666
if n in block['vars']:
1667
if 'attrspec' in block['vars'][n]:
1668
block['vars'][n]['attrspec'].append('dimension(%s)'%(','.join(dims)))
1624
block['vars'][n]['attrspec']=['dimension(%s)'%(string.join(dims,','))]
1670
block['vars'][n]['attrspec']=['dimension(%s)'%(','.join(dims))]
1627
block['vars'][n]={'attrspec':['dimension(%s)'%(string.join(dims,','))]}
1673
block['vars'][n]={'attrspec':['dimension(%s)'%(','.join(dims))]}
1628
1674
else: block['vars'][n]={}
1629
1675
if n not in commonvars: commonvars.append(n)
1632
1678
errmess('analyzecommon: failed to extract "<name>[(<dims>)]" from "%s" in common /%s/.\n'%(e,k))
1633
1679
comvars.append(n)
1634
1680
block['common'][k]=comvars
1635
if not block.has_key('commonvars'):
1681
if 'commonvars' not in block:
1636
1682
block['commonvars']=commonvars
1638
1684
block['commonvars']=block['commonvars']+commonvars
1640
1687
def analyzebody(block,args,tab=''):
1641
1688
global usermodules,skipfuncs,onlyfuncs,f90modulevars
1642
1689
setmesstext(block)
1656
1703
b=postcrack(b,as_,tab=tab+'\t')
1657
1704
if b['block']=='interface' and not b['body']:
1658
if not b.has_key('f2pyenhancements'):
1705
if 'f2pyenhancements' not in b:
1660
if string.replace(b['block'],' ','')=='pythonmodule':
1707
if b['block'].replace(' ','')=='pythonmodule':
1661
1708
usermodules.append(b)
1663
1710
if b['block']=='module':
1664
1711
f90modulevars[b['name']] = b['vars']
1667
1715
def buildimplicitrules(block):
1668
1716
setmesstext(block)
1669
1717
implicitrules=defaultimplicitrules
1671
if block.has_key('implicit'):
1719
if 'implicit' in block:
1672
1720
if block['implicit'] is None:
1673
1721
implicitrules=None
1828
1885
word_pattern = re.compile(r'\b[a-z][\w$]*\b',re.I)
1830
1887
def _get_depend_dict(name, vars, deps):
1831
if vars.has_key(name):
1832
1889
words = vars[name].get('depend',[])
1834
if vars[name].has_key('=') and not isstring(vars[name]):
1891
if '=' in vars[name] and not isstring(vars[name]):
1835
1892
for word in word_pattern.findall(vars[name]['=']):
1836
if word not in words and vars.has_key(word):
1893
if word not in words and word in vars:
1837
1894
words.append(word)
1838
1895
for word in words[:]:
1839
1896
for w in deps.get(word,[]) \
1898
1955
for name,func in [('kind',_kind_func),
1899
1956
('selected_int_kind',_selected_int_kind_func),
1901
if not g_params.has_key(name):
1958
if name not in g_params:
1902
1959
g_params[name] = func
1903
1960
param_names = []
1904
1961
for n in get_sorted_names(vars):
1905
if vars[n].has_key('attrspec') and 'parameter' in vars[n]['attrspec']:
1962
if 'attrspec' in vars[n] and 'parameter' in vars[n]['attrspec']:
1906
1963
param_names.append(n)
1907
1964
kind_re = re.compile(r'\bkind\s*\(\s*(?P<value>.*)\s*\)',re.I)
1908
1965
selected_int_kind_re = re.compile(r'\bselected_int_kind\s*\(\s*(?P<value>.*)\s*\)',re.I)
1909
1966
for n in param_names:
1910
if vars[n].has_key('='):
1911
1968
v = vars[n]['=']
1912
1969
if islogical(vars[n]):
1972
2029
setmesstext(block)
1973
2030
implicitrules,attrrules=buildimplicitrules(block)
1974
2031
vars=copy.copy(block['vars'])
1975
if block['block']=='function' and not vars.has_key(block['name']):
2032
if block['block']=='function' and block['name'] not in vars:
1976
2033
vars[block['name']]={}
1977
if block['vars'].has_key(''):
2034
if '' in block['vars']:
1979
if block['vars'][''].has_key('attrspec'):
2036
if 'attrspec' in block['vars']['']:
1980
2037
gen=block['vars']['']['attrspec']
1981
2038
for n in vars.keys():
1982
2039
for k in ['public','private']:
2008
2065
for n in svars:
2009
2066
if n[0] in attrrules.keys():
2010
2067
vars[n]=setattrspec(vars[n],attrrules[n[0]])
2011
if not vars[n].has_key('typespec'):
2012
if not(vars[n].has_key('attrspec') and 'external' in vars[n]['attrspec']):
2068
if 'typespec' not in vars[n]:
2069
if not('attrspec' in vars[n] and 'external' in vars[n]['attrspec']):
2013
2070
if implicitrules:
2014
ln0 = string.lower(n[0])
2015
2072
for k in implicitrules[ln0].keys():
2016
2073
if k=='typespec' and implicitrules[ln0][k]=='undefined':
2018
if not vars[n].has_key(k):
2075
if k not in vars[n]:
2019
2076
vars[n][k]=implicitrules[ln0][k]
2020
2077
elif k=='attrspec':
2021
2078
for l in implicitrules[ln0][k]:
2042
2099
vars[n]['kindselector']['kind'] = l
2044
2101
savelindims = {}
2045
if vars[n].has_key('attrspec'):
2102
if 'attrspec' in vars[n]:
2046
2103
attr=vars[n]['attrspec']
2048
2105
vars[n]['attrspec']=[]
2049
2106
dim,intent,depend,check,note=None,None,None,None,None
2051
if a[:9]=='dimension': dim=(string.strip(a[9:]))[1:-1]
2052
elif a[:6]=='intent': intent=(string.strip(a[6:]))[1:-1]
2053
elif a[:6]=='depend': depend=(string.strip(a[6:]))[1:-1]
2054
elif a[:5]=='check': check=(string.strip(a[5:]))[1:-1]
2055
elif a[:4]=='note': note=(string.strip(a[4:]))[1:-1]
2108
if a[:9]=='dimension': dim=(a[9:].strip())[1:-1]
2109
elif a[:6]=='intent': intent=(a[6:].strip())[1:-1]
2110
elif a[:6]=='depend': depend=(a[6:].strip())[1:-1]
2111
elif a[:5]=='check': check=(a[5:].strip())[1:-1]
2112
elif a[:4]=='note': note=(a[4:].strip())[1:-1]
2056
2113
else: vars[n]=setattrspec(vars[n],a)
2058
if not vars[n].has_key('intent'): vars[n]['intent']=[]
2059
for c in map(string.strip,string.split(markoutercomma(intent),'@,@')):
2115
if 'intent' not in vars[n]:
2116
vars[n]['intent']=[]
2117
for c in [x.strip() for x in markoutercomma(intent).split('@,@')]:
2060
2118
if not c in vars[n]['intent']:
2061
2119
vars[n]['intent'].append(c)
2064
note=string.replace(note,'\\n\\n','\n\n')
2065
note=string.replace(note,'\\n ','\n')
2066
if not vars[n].has_key('note'): vars[n]['note']=[note]
2067
else: vars[n]['note'].append(note)
2122
note=note.replace('\\n\\n','\n\n')
2123
note=note.replace('\\n ','\n')
2124
if 'note' not in vars[n]:
2125
vars[n]['note']=[note]
2127
vars[n]['note'].append(note)
2069
2129
if depend is not None:
2070
if not vars[n].has_key('depend'): vars[n]['depend']=[]
2071
for c in rmbadname(map(string.strip,string.split(markoutercomma(depend),'@,@'))):
2130
if 'depend' not in vars[n]:
2131
vars[n]['depend']=[]
2132
for c in rmbadname([x.strip() for x in markoutercomma(depend).split('@,@')]):
2072
2133
if c not in vars[n]['depend']:
2073
2134
vars[n]['depend'].append(c)
2075
2136
if check is not None:
2076
if not vars[n].has_key('check'): vars[n]['check']=[]
2077
for c in map(string.strip,string.split(markoutercomma(check),'@,@')):
2137
if 'check' not in vars[n]:
2139
for c in [x.strip() for x in markoutercomma(check).split('@,@')]:
2078
2140
if not c in vars[n]['check']:
2079
2141
vars[n]['check'].append(c)
2081
if dim and not vars[n].has_key('dimension'):
2143
if dim and 'dimension' not in vars[n]:
2082
2144
vars[n]['dimension']=[]
2083
for d in rmbadname(map(string.strip,string.split(markoutercomma(dim),'@,@'))):
2145
for d in rmbadname([x.strip() for x in markoutercomma(dim).split('@,@')]):
2086
if params.has_key(d):
2087
2150
d = str(params[d])
2088
2151
for p in params.keys():
2089
2152
m = re.match(r'(?P<before>.*?)\b'+p+r'\b(?P<after>.*)',d,re.I)
2104
2167
if di and di[-4:] == '/(1)': di = di[:-4]
2105
2168
if v: savelindims[d] = v,di
2106
2169
vars[n]['dimension'].append(d)
2107
if vars[n].has_key('dimension'):
2170
if 'dimension' in vars[n]:
2108
2171
if isintent_c(vars[n]):
2109
2172
shape_macro = 'shape'
2111
2174
shape_macro = 'shape'#'fshape'
2112
2175
if isstringarray(vars[n]):
2113
if vars[n].has_key('charselector'):
2176
if 'charselector' in vars[n]:
2114
2177
d = vars[n]['charselector']
2117
2180
errmess('analyzevars: character array "character*%s %s(%s)" is considered as "character %s(%s)"; "intent(c)" is forced.\n'\
2120
2183
n,','.join(vars[n]['dimension']+[d])))
2121
2184
vars[n]['dimension'].append(d)
2122
2185
del vars[n]['charselector']
2123
if not vars[n].has_key('intent'):
2186
if 'intent' not in vars[n]:
2124
2187
vars[n]['intent'] = []
2125
2188
if 'c' not in vars[n]['intent']:
2126
2189
vars[n]['intent'].append('c')
2128
2191
errmess("analyzevars: charselector=%r unhandled." % (d))
2129
if not vars[n].has_key('check') and block.has_key('args') and n in block['args']:
2130
flag=not vars[n].has_key('depend')
2131
if flag: vars[n]['depend']=[]
2192
if 'check' not in vars[n] and 'args' in block and n in block['args']:
2193
flag = 'depend' not in vars[n]
2195
vars[n]['depend']=[]
2132
2196
vars[n]['check']=[]
2133
if vars[n].has_key('dimension'):
2197
if 'dimension' in vars[n]:
2134
2198
#/----< no check
2135
2199
#vars[n]['check'].append('rank(%s)==%s'%(n,len(vars[n]['dimension'])))
2136
2200
i=-1; ni=len(vars[n]['dimension'])
2142
if not vars.has_key(d):
2143
if savelindims.has_key(d):
2207
if d in savelindims:
2144
2208
pd,ad='(',savelindims[d][1]
2145
2209
d = savelindims[d][0]
2147
2211
for r in block['args']:
2148
2212
#for r in block['vars'].keys():
2149
if not vars.has_key(r): continue
2150
2215
if re.match(r'.*?\b'+r+r'\b',d,re.I):
2151
2216
ddeps.append(r)
2153
if vars[d].has_key('attrspec'):
2218
if 'attrspec' in vars[d]:
2154
2219
for aa in vars[d]['attrspec']:
2155
2220
if aa[:6]=='depend':
2156
ddeps=ddeps+string.split((string.strip(aa[6:]))[1:-1],',')
2157
if vars[d].has_key('depend'):
2221
ddeps += aa[6:].strip()[1:-1].split(',')
2222
if 'depend' in vars[d]:
2158
2223
ddeps=ddeps+vars[d]['depend']
2160
if vars.has_key(d) and (not vars[d].has_key('depend')) \
2161
and (not vars[d].has_key('=')) and (d not in vars[n]['depend']) \
2162
and l_or(isintent_in,isintent_inout,isintent_inplace)(vars[n]):
2225
if d in vars and ('depend' not in vars[d]) \
2226
and ('=' not in vars[d]) and (d not in vars[n]['depend']) \
2227
and l_or(isintent_in, isintent_inout, isintent_inplace)(vars[n]):
2163
2228
vars[d]['depend']=[n]
2165
2230
vars[d]['=']='%s%s(%s,%s)%s'% (pd,shape_macro,n,i,ad)
2167
2232
vars[d]['=']='%slen(%s)%s'% (pd,n,ad)
2168
2233
# /---< no check
2169
if 1 and not vars[d].has_key('check'):
2234
if 1 and 'check' not in vars[d]:
2171
2236
vars[d]['check']=['%s%s(%s,%i)%s==%s'\
2172
2237
%(pd,shape_macro,n,i,ad,d)]
2174
2239
vars[d]['check']=['%slen(%s)%s>=%s'%(pd,n,ad,d)]
2175
if not vars[d].has_key('attrspec'): vars[d]['attrspec']=['optional']
2240
if 'attrspec' not in vars[d]:
2241
vars[d]['attrspec']=['optional']
2176
2242
if ('optional' not in vars[d]['attrspec']) and\
2177
2243
('required' not in vars[d]['attrspec']):
2178
2244
vars[d]['attrspec'].append('optional')
2181
2247
#if ni>1: vars[n]['check'].append('shape(%s,%i)==%s'%(n,i,d))
2182
2248
#else: vars[n]['check'].append('len(%s)>=%s'%(n,d))
2185
2251
if n not in ddeps:
2186
2252
vars[n]['depend'].append(d)
2188
2254
vars[n]['depend'] = vars[n]['depend'] + ddeps
2189
2255
elif isstring(vars[n]):
2191
if vars[n].has_key('charselector'):
2192
if vars[n]['charselector'].has_key('*'):
2257
if 'charselector' in vars[n]:
2258
if '*' in vars[n]['charselector']:
2193
2259
length = _eval_length(vars[n]['charselector']['*'],
2195
2261
vars[n]['charselector']['*']=length
2196
elif vars[n]['charselector'].has_key('len'):
2262
elif 'len' in vars[n]['charselector']:
2197
2263
length = _eval_length(vars[n]['charselector']['len'],
2199
2265
del vars[n]['charselector']['len']
2200
2266
vars[n]['charselector']['*']=length
2202
if not vars[n]['check']: del vars[n]['check']
2203
if flag and not vars[n]['depend']: del vars[n]['depend']
2204
if vars[n].has_key('='):
2205
if not vars[n].has_key('attrspec'): vars[n]['attrspec']=[]
2268
if not vars[n]['check']:
2269
del vars[n]['check']
2270
if flag and not vars[n]['depend']:
2271
del vars[n]['depend']
2273
if 'attrspec' not in vars[n]:
2274
vars[n]['attrspec']=[]
2206
2275
if ('optional' not in vars[n]['attrspec']) and \
2207
2276
('required' not in vars[n]['attrspec']):
2208
2277
vars[n]['attrspec'].append('optional')
2209
if not vars[n].has_key('depend'):
2278
if 'depend' not in vars[n]:
2210
2279
vars[n]['depend']=[]
2211
2280
for v,m in dep_matches.items():
2212
2281
if m(vars[n]['=']): vars[n]['depend'].append(v)
2217
2286
for n in vars.keys():
2218
2287
if n==block['name']: # n is block name
2219
if vars[n].has_key('note'):
2288
if 'note' in vars[n]:
2220
2289
block['note']=vars[n]['note']
2221
2290
if block['block']=='function':
2222
if block.has_key('result') and vars.has_key(block['result']):
2291
if 'result' in block and block['result'] in vars:
2223
2292
vars[n]=appenddecl(vars[n],vars[block['result']])
2224
if block.has_key('prefix'):
2293
if 'prefix' in block:
2225
2294
pr=block['prefix']; ispure=0; isrec=1
2226
pr1=string.replace(pr,'pure','')
2295
pr1=pr.replace('pure','')
2227
2296
ispure=(not pr==pr1)
2228
pr=string.replace(pr1,'recursive','')
2297
pr=pr1.replace('recursive','')
2229
2298
isrec=(not pr==pr1)
2230
2299
m=typespattern[0].match(pr)
2247
2316
outmess('analyzevars: prefix (%s) were not used\n'%`block['prefix']`)
2248
2317
if not block['block'] in ['module','pythonmodule','python module','block data']:
2249
if block.has_key('commonvars'):
2318
if 'commonvars' in block:
2250
2319
neededvars=copy.copy(block['args']+block['commonvars'])
2252
2321
neededvars=copy.copy(block['args'])
2253
2322
for n in vars.keys():
2254
2323
if l_or(isintent_callback,isintent_aux)(vars[n]):
2255
2324
neededvars.append(n)
2256
if block.has_key('entry'):
2325
if 'entry' in block:
2257
2326
neededvars.extend(block['entry'].keys())
2258
2327
for k in block['entry'].keys():
2259
2328
for n in block['entry'][k]:
2260
2329
if n not in neededvars:
2261
2330
neededvars.append(n)
2262
2331
if block['block']=='function':
2263
if block.has_key('result'):
2332
if 'result' in block:
2264
2333
neededvars.append(block['result'])
2266
2335
neededvars.append(block['name'])
2267
2336
if block['block'] in ['subroutine','function']:
2268
2337
name = block['name']
2269
if vars.has_key(name) and vars[name].has_key('intent'):
2338
if name in vars and 'intent' in vars[name]:
2270
2339
block['intent'] = vars[name]['intent']
2271
2340
if block['block'] == 'type':
2272
2341
neededvars.extend(vars.keys())
2291
2362
if na[-1]=='_': na=na+'e'
2292
2363
else: na=na+'_e'
2294
while block['vars'].has_key(a) or a in block['args']: a=a+'r'
2365
while a in block['vars'] or a in block['args']:
2295
2367
block['vars'][a]=at
2297
if not block['vars'].has_key(a):
2369
if a not in block['vars']:
2298
2370
block['vars'][a]={}
2299
if block.has_key('externals') and a in block['externals']+block['interfaced']:
2371
if 'externals' in block and a in block['externals']+block['interfaced']:
2300
2372
block['vars'][a]=setattrspec(block['vars'][a],'external')
2301
2373
block['args']=args
2303
if block.has_key('entry'):
2375
if 'entry' in block:
2304
2376
for k,args1 in block['entry'].items():
2305
2377
for a in args1:
2306
if not block['vars'].has_key(a):
2378
if a not in block['vars']:
2307
2379
block['vars'][a]={}
2309
2381
for b in block['body']:
2310
2382
if b['name'] in args:
2311
if not block.has_key('externals'): block['externals']=[]
2383
if 'externals' not in block:
2384
block['externals']=[]
2312
2385
if b['name'] not in block['externals']:
2313
2386
block['externals'].append(b['name'])
2314
if block.has_key('result') and not block['vars'].has_key(block['result']):
2387
if 'result' in block and block['result'] not in block['vars']:
2315
2388
block['vars'][block['result']]={}
2317
2391
determineexprtype_re_1 = re.compile(r'\A\(.+?[,].+?\)\Z',re.I)
2318
2392
determineexprtype_re_2 = re.compile(r'\A[+-]?\d+(_(P<name>[\w]+)|)\Z',re.I)
2319
2393
determineexprtype_re_3 = re.compile(r'\A[+-]?[\d.]+[\d+-de.]*(_(P<name>[\w]+)|)\Z',re.I)
2332
2406
def determineexprtype(expr,vars,rules={}):
2333
if vars.has_key(expr):
2334
2408
return _ensure_exprdict(vars[expr])
2335
expr=string.strip(expr)
2336
2410
if determineexprtype_re_1.match(expr):
2337
2411
return {'typespec':'complex'}
2338
2412
m=determineexprtype_re_2.match(expr)
2340
if m.groupdict().has_key('name') and m.group('name'):
2414
if 'name' in m.groupdict() and m.group('name'):
2341
2415
outmess('determineexprtype: selected kind types not supported (%s)\n'%`expr`)
2342
2416
return {'typespec':'integer'}
2343
2417
m = determineexprtype_re_3.match(expr)
2345
if m.groupdict().has_key('name') and m.group('name'):
2419
if 'name' in m.groupdict() and m.group('name'):
2346
2420
outmess('determineexprtype: selected kind types not supported (%s)\n'%`expr`)
2347
2421
return {'typespec':'real'}
2348
2422
for op in ['+','-','*','/']:
2349
for e in map(string.strip,string.split(markoutercomma(expr,comma=op),'@'+op+'@')):
2423
for e in [x.strip() for x in markoutercomma(expr,comma=op).split('@'+op+'@')]:
2351
2425
return _ensure_exprdict(vars[e])
2353
2427
if determineexprtype_re_4.match(expr): # in parenthesis
2358
2432
rn=m.group('name')
2359
2433
t=determineexprtype(m.group('name'),vars,rules)
2360
if t and t.has_key('attrspec'): del t['attrspec']
2434
if t and 'attrspec' in t:
2362
if rules.has_key(rn[0]):
2363
2438
return _ensure_exprdict(rules[rn[0]])
2364
2439
if expr[0] in '\'"':
2365
2440
return {'typespec':'character','charselector':{'*':'*'}}
2367
2442
outmess('determineexprtype: could not determine expressions (%s) type.\n'%(`expr`))
2370
2446
def crack2fortrangen(block,tab='\n'):
2371
2447
global skipfuncs, onlyfuncs
2386
2462
blocktype=block['block']
2387
2463
if blocktype=='program': return ''
2389
if block.has_key('name'): name=block['name']
2390
if block.has_key('args'):
2391
2468
vars = block['vars']
2392
2469
al = [a for a in block['args'] if not isintent_callback(vars[a])]
2393
2470
if block['block']=='function' or al:
2394
args='(%s)'%string.join(al,',')
2471
args='(%s)'%','.join(al)
2395
2472
f2pyenhancements = ''
2396
if block.has_key('f2pyenhancements'):
2473
if 'f2pyenhancements' in block:
2397
2474
for k in block['f2pyenhancements'].keys():
2398
2475
f2pyenhancements = '%s%s%s %s'%(f2pyenhancements,tab+tabchar,k,block['f2pyenhancements'][k])
2399
2476
intent_lst = block.get('intent',[])[:]
2403
2480
f2pyenhancements = '%s%sintent(%s) %s'%\
2404
2481
(f2pyenhancements,tab+tabchar,
2405
string.join(intent_lst,','),name)
2482
','.join(intent_lst),name)
2407
if block.has_key('use'):
2408
2485
use=use2fortran(block['use'],tab+tabchar)
2410
if block.has_key('common'):
2487
if 'common' in block:
2411
2488
common=common2fortran(block['common'],tab+tabchar)
2412
2489
if name=='unknown_interface': name=''
2414
if block.has_key('result'):
2491
if 'result' in block:
2415
2492
result=' result (%s)'%block['result']
2416
2493
if block['result'] not in al:
2417
2494
al.append(block['result'])
2418
#if block.has_key('prefix'): prefix=block['prefix']+' '
2495
#if 'prefix' in block:
2496
# prefix=block['prefix']+' '
2419
2497
body=crack2fortrangen(block['body'],tab+tabchar)
2420
2498
vars=vars2fortran(block,block['vars'],al,tab+tabchar)
2422
if block.has_key('from'):
2423
2501
mess='! in %s'%block['from']
2424
if block.has_key('entry'):
2502
if 'entry' in block:
2425
2503
entry_stmts = ''
2426
2504
for k,i in block['entry'].items():
2427
2505
entry_stmts = '%s%sentry %s(%s)' \
2428
% (entry_stmts,tab+tabchar,k,string.join(i,','))
2506
% (entry_stmts,tab+tabchar,k,','.join(i))
2429
2507
body = body + entry_stmts
2430
2508
if blocktype=='block data' and name=='_BLOCK_DATA_':
2432
2510
ret='%s%s%s %s%s%s %s%s%s%s%s%s%send %s %s'%(tab,prefix,blocktype,name,args,result,mess,f2pyenhancements,use,vars,common,body,tab,blocktype,name)
2434
2513
def common2fortran(common,tab=''):
2436
2515
for k in common.keys():
2437
2516
if k=='_BLNK_':
2438
ret='%s%scommon %s'%(ret,tab,string.join(common[k],','))
2517
ret='%s%scommon %s'%(ret,tab,','.join(common[k]))
2440
ret='%s%scommon /%s/ %s'%(ret,tab,k,string.join(common[k],','))
2519
ret='%s%scommon /%s/ %s'%(ret,tab,k,','.join(common[k]))
2442
2522
def use2fortran(use,tab=''):
2444
2524
for m in use.keys():
2481
if block['vars'].has_key(a): nout.append(a)
2482
if block.has_key('commonvars'):
2563
if a in block['vars']:
2565
if 'commonvars' in block:
2483
2566
for a in block['commonvars']:
2485
if a not in nout: nout.append(a)
2486
else: errmess('vars2fortran: Confused?!: "%s" is not defined in vars.\n'%a)
2487
if block.has_key('varnames'):
2571
errmess('vars2fortran: Confused?!: "%s" is not defined in vars.\n'%a)
2572
if 'varnames' in block:
2488
2573
nout.extend(block['varnames'])
2489
2574
for a in vars.keys():
2490
if a not in nout: nout.append(a)
2492
if vars[a].has_key('depend'):
2578
if 'depend' in vars[a]:
2493
2579
for d in vars[a]['depend']:
2494
if vars.has_key(d) and vars[d].has_key('depend') and a in vars[d]['depend']:
2580
if d in vars and 'depend' in vars[d] and a in vars[d]['depend']:
2495
2581
errmess('vars2fortran: Warning: cross-dependence between variables "%s" and "%s"\n'%(a,d))
2496
if block.has_key('externals') and a in block['externals']:
2582
if 'externals' in block and a in block['externals']:
2497
2583
if isintent_callback(vars[a]):
2498
2584
ret='%s%sintent(callback) %s'%(ret,tab,a)
2499
2585
ret='%s%sexternal %s'%(ret,tab,a)
2500
2586
if isoptional(vars[a]):
2501
2587
ret='%s%soptional %s'%(ret,tab,a)
2502
if vars.has_key(a) and not vars[a].has_key('typespec'):
2588
if a in vars and 'typespec' not in vars[a]:
2505
2591
for b in block['body']:
2506
if a==b['name'] and b['block']=='function': cont=0;break
2508
if not vars.has_key(a):
2592
if a==b['name'] and b['block']=='function':
2510
2598
outmess('vars2fortran: No definition for argument "%s".\n'%a)
2512
2600
if a==block['name'] and not block['block']=='function':
2514
if not vars[a].has_key('typespec'):
2515
if vars[a].has_key('attrspec') and 'external' in vars[a]['attrspec']:
2602
if 'typespec' not in vars[a]:
2603
if 'attrspec' in vars[a] and 'external' in vars[a]['attrspec']:
2517
2605
ret='%s%sexternal %s'%(ret,tab,a)
2520
2608
outmess('vars2fortran: No typespec for argument "%s".\n'%a)
2522
2610
vardef=vars[a]['typespec']
2523
if vardef=='type' and vars[a].has_key('typename'):
2611
if vardef=='type' and 'typename' in vars[a]:
2524
2612
vardef='%s(%s)'%(vardef,vars[a]['typename'])
2526
if vars[a].has_key('kindselector'): selector=vars[a]['kindselector']
2527
elif vars[a].has_key('charselector'): selector=vars[a]['charselector']
2528
if selector.has_key('*'):
2614
if 'kindselector' in vars[a]:
2615
selector=vars[a]['kindselector']
2616
elif 'charselector' in vars[a]:
2617
selector=vars[a]['charselector']
2529
2619
if selector['*'] in ['*',':']:
2530
2620
vardef='%s*(%s)'%(vardef,selector['*'])
2532
2622
vardef='%s*%s'%(vardef,selector['*'])
2534
if selector.has_key('len'):
2624
if 'len' in selector:
2535
2625
vardef='%s(len=%s'%(vardef,selector['len'])
2536
if selector.has_key('kind'):
2626
if 'kind' in selector:
2537
2627
vardef='%s,kind=%s)'%(vardef,selector['kind'])
2539
2629
vardef='%s)'%(vardef)
2540
elif selector.has_key('kind'):
2630
elif 'kind' in selector:
2541
2631
vardef='%s(kind=%s)'%(vardef,selector['kind'])
2543
if vars[a].has_key('attrspec'):
2633
if 'attrspec' in vars[a]:
2545
2635
for l in vars[a]['attrspec']:
2546
2636
if l not in ['external']:
2549
vardef='%s %s'%(vardef,string.join(attr,','))
2639
vardef='%s %s'%(vardef,','.join(attr))
2551
if vars[a].has_key('dimension'):
2641
if 'dimension' in vars[a]:
2552
2642
# if not isintent_c(vars[a]):
2553
2643
# vars[a]['dimension'].reverse()
2554
vardef='%s%sdimension(%s)'%(vardef,c,string.join(vars[a]['dimension'],','))
2644
vardef='%s%sdimension(%s)'%(vardef,c,','.join(vars[a]['dimension']))
2556
if vars[a].has_key('intent'):
2646
if 'intent' in vars[a]:
2557
2647
lst = true_intent_list(vars[a])
2559
vardef='%s%sintent(%s)'%(vardef,c,string.join(lst,','))
2561
if vars[a].has_key('check'):
2562
vardef='%s%scheck(%s)'%(vardef,c,string.join(vars[a]['check'],','))
2564
if vars[a].has_key('depend'):
2565
vardef='%s%sdepend(%s)'%(vardef,c,string.join(vars[a]['depend'],','))
2567
if vars[a].has_key('='):
2649
vardef='%s%sintent(%s)'%(vardef,c,','.join(lst))
2651
if 'check' in vars[a]:
2652
vardef='%s%scheck(%s)'%(vardef,c,','.join(vars[a]['check']))
2654
if 'depend' in vars[a]:
2655
vardef='%s%sdepend(%s)'%(vardef,c,','.join(vars[a]['depend']))
2568
2658
v = vars[a]['=']
2569
2659
if vars[a]['typespec'] in ['complex','double complex']:
added
removed
numpy/f2py/crackfortran.py
