LCPQ
/
irpf90
mirror of https://gitlab.com/scemama/irpf90.git
10
0
Fork 0
Code Releases Activity

Switched to Python3

This commit is contained in:
Anthony Scemama 2020-01-27 18:22:35 +01:00
parent 02a5f1c3d9
commit 2ea0e86564
37 changed files with 510 additions and 513 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
bin/irpf90_indent
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA

2
bin/irpman
View File

@ -37,7 +37,7 @@ case "$0" in
echo "source " $0 echo "source " $0
fi fi
else else
exec python2 $(dirname $0)/../src/irpman.py $1 exec python3 $(dirname $0)/../src/irpman.py $1
fi fi
;; ;;

2
bin/profile
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA

2
example/Makefile
View File

@ -1,4 +1,4 @@
IRPF90 = python2 ../src/irpf90.py -I input IRPF90 = python3 ../src/irpf90.py -I input
FC = ifort FC = ifort
FCFLAGS= -O2 FCFLAGS= -O2
NINJA = NINJA =

2
packages/make_version.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
import sys, os import sys, os
wd = os.path.abspath(os.path.dirname(__file__)) wd = os.path.abspath(os.path.dirname(__file__))

2
pip/irpman
View File

@ -28,7 +28,7 @@
function run () function run ()
{ {
cat << EOF | exec python2 - $@ cat << EOF | exec python3 - $@
import sys, os import sys, os
from irpf90_libs.irpf90_t import mandir from irpf90_libs.irpf90_t import mandir

16
src/checkpoint.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,10 +25,10 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from irpf90_t import * from .irpf90_t import *
from util import * from .util import *
from variables import variables from .variables import variables
from modules import modules from .modules import modules
CHECKPOINT_UNIT_NUMBER=63 CHECKPOINT_UNIT_NUMBER=63
@ -36,10 +36,10 @@ FILENAME=irpdir+'irp_checkpoint.irp.F90'
def create(): def create():
out_write = [ "subroutine irp_checkpoint_write" ] out_write = [ "subroutine irp_checkpoint_write" ]
l = variables.keys() l = list(variables.keys())
l.sort l.sort
main_modules = filter(lambda x: modules[x].is_main, modules) main_modules = [x for x in modules if modules[x].is_main]
for m in filter(lambda x: not modules[x].is_main, modules): for m in [x for x in modules if not modules[x].is_main]:
out_write += [ " use %s"%(modules[m].name) ] out_write += [ " use %s"%(modules[m].name) ]
out_write += [ " implicit none" ] out_write += [ " implicit none" ]
out_write += [ " integer, parameter :: iunit = %d"%(CHECKPOINT_UNIT_NUMBER) ] out_write += [ " integer, parameter :: iunit = %d"%(CHECKPOINT_UNIT_NUMBER) ]

6
src/codelet.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -24,8 +24,8 @@
# 31062 Toulouse Cedex 4 # 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from command_line import command_line from .command_line import command_line
import irpf90_t from . import irpf90_t
def run(): def run():
template = """ template = """

30
src/command_line.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -26,7 +26,7 @@
import getopt, sys import getopt, sys
from version import version from .version import version
import re import re
description = "IRPF90 Fortran preprocessor." description = "IRPF90 Fortran preprocessor."
@ -76,7 +76,7 @@ class CommandLine(object):
for o,a in self.opts: for o,a in self.opts:
if o in [ "-I", '--'+options['I'][0] ]: if o in [ "-I", '--'+options['I'][0] ]:
if len(a) < 1: if len(a) < 1:
print "Error: -I option needs a directory" print("Error: -I option needs a directory")
if a[-1] != '/': if a[-1] != '/':
a = a+'/' a = a+'/'
self._include_dir.append(a) self._include_dir.append(a)
@ -116,12 +116,12 @@ class CommandLine(object):
elif len(buffer) == 3: elif len(buffer) == 3:
self._codelet = [buffer[0], int(buffer[2]), buffer[1], filename] self._codelet = [buffer[0], int(buffer[2]), buffer[1], filename]
else: else:
print """ print("""
Error in codelet definition. Use: Error in codelet definition. Use:
--codelet=provider:NMAX --codelet=provider:NMAX
or or
--codelet=provider:precondition:NMAX --codelet=provider:precondition:NMAX
""" """)
sys.exit(1) sys.exit(1)
return self._codelet return self._codelet
codelet = property(fget=codelet) codelet = property(fget=codelet)
@ -209,11 +209,11 @@ Options:
""" """
t = t.replace("$EXE",self.executable_name) t = t.replace("$EXE",self.executable_name)
t = t.replace("$DESCR",description) t = t.replace("$DESCR",description)
print t print(t)
print_options() print_options()
print "" print("")
print "Version : ", version print("Version : ", version)
print "" print("")
def opts(self): def opts(self):
if self._opts is None: if self._opts is None:
@ -228,10 +228,10 @@ Options:
try: try:
self._opts, args = getopt.getopt(self.argv[1:], optlist[0], optlist[1]) self._opts, args = getopt.getopt(self.argv[1:], optlist[0], optlist[1])
except getopt.GetoptError, err: except getopt.GetoptError as err:
# print help information and exit: # print help information and exit:
self.usage() self.usage()
print str(err) # will print something like "option -a not recognized" print(str(err)) # will print something like "option -a not recognized"
sys.exit(2) sys.exit(2)
return self._opts return self._opts
@ -250,7 +250,7 @@ do_$LONG = property(fget=do_$LONG)
""" """
for short in options: for short in options:
long = options[short][0] long = options[short][0]
exec t.replace("$LONG",long).replace("$SHORT",short) #in locals() exec(t.replace("$LONG",int).replace("$SHORT",short)) #in locals()
def do_run(self): def do_run(self):
if '_do_run' not in self.__dict__: if '_do_run' not in self.__dict__:
@ -267,7 +267,7 @@ do_$LONG = property(fget=do_$LONG)
command_line = CommandLine() command_line = CommandLine()
def print_options(): def print_options():
keys = options.keys() keys = list(options.keys())
keys.sort() keys.sort()
import subprocess import subprocess
for k in keys: for k in keys:
@ -275,8 +275,8 @@ def print_options():
p1 = subprocess.Popen(["fold", "-s", "-w", "40"],stdout=subprocess.PIPE,stdin=subprocess.PIPE) p1 = subprocess.Popen(["fold", "-s", "-w", "40"],stdout=subprocess.PIPE,stdin=subprocess.PIPE)
description = p1.communicate(description)[0] description = p1.communicate(description)[0]
description = description.replace('\n','\n'.ljust(27)) description = description.replace('\n','\n'.ljust(27))
print ("-%s, --%s"%(k,options[k][0])).ljust(25), description+'\n' print(("-%s, --%s"%(k,options[k][0])).ljust(25), description+'\n')
print "\n" print("\n")
if __name__ == '__main__': if __name__ == '__main__':
print_options() print_options()

218
src/create_man.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,22 +25,22 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from variable import Variable from .variable import Variable
from variables import variables from .variables import variables
from subroutine import Sub from .subroutine import Sub
from subroutines import subroutines from .subroutines import subroutines
from irpf90_t import * from .irpf90_t import *
from util import * from .util import *
def do_print_short(file,var): def do_print_short(file,var):
"""Makes a short print, as in irpf90_entities""" """Makes a short print, as in irpf90_entities"""
assert type(var) == Variable assert type(var) == Variable
print >>file, "%s : %s :: %s %s"%( \ print("%s : %s :: %s %s"%( \
var.line.filename[0].ljust(35), var.line.filename[0].ljust(35),
var.type.ljust(30), var.type.ljust(30),
var.name.ljust(25), var.name.ljust(25),
build_dim(var.dim) ) build_dim(var.dim) ), file=file)
###################################################################### ######################################################################
def process_doc(file,line): def process_doc(file,line):
@ -48,13 +48,13 @@ def process_doc(file,line):
line = line.strip() line = line.strip()
if line == "": if line == "":
line = ".br" line = ".br"
print >>file, line print(line, file=file)
###################################################################### ######################################################################
def process_deps(file,l): def process_deps(file,l):
assert type(l) == list assert type(l) == list
for v in l: for v in l:
print >>file, "%s\n.br"%(v,) print("%s\n.br"%(v,), file=file)
###################################################################### ######################################################################
def process_types(file,var): def process_types(file,var):
@ -65,7 +65,7 @@ def process_types(file,var):
var = variables[var] var = variables[var]
Type = var.type Type = var.type
dim = build_dim(var.dim) dim = build_dim(var.dim)
print >>file, "%s\t:: %s\t%s"%(Type,name,dim) print("%s\t:: %s\t%s"%(Type,name,dim), file=file)
###################################################################### ######################################################################
def do_print(var): def do_print(var):
@ -73,32 +73,32 @@ def do_print(var):
filename = var.line.filename[0] filename = var.line.filename[0]
name = var.name name = var.name
file = open("%s%s.l"%(mandir,var.name), "w") file = open("%s%s.l"%(mandir,var.name), "w")
print >>file, '.TH "IRPF90 entities" l %s "IRPF90 entities" %s'%(name,name) print('.TH "IRPF90 entities" l %s "IRPF90 entities" %s'%(name,name), file=file)
if var.same_as != var.name: if var.same_as != var.name:
var = variables[var.same_as] var = variables[var.same_as]
print >>file, ".SH Declaration" print(".SH Declaration", file=file)
print >>file, ".nf" print(".nf", file=file)
process_types(file,var) process_types(file,var)
print >>file, ".ni" print(".ni", file=file)
if var.doc != []: if var.doc != []:
print >>file, ".SH Description" print(".SH Description", file=file)
for l in var.doc: for l in var.doc:
process_doc(file,l) process_doc(file,l)
print >>file, ".SH File\n.P" print(".SH File\n.P", file=file)
print >>file, filename print(filename, file=file)
if var.needs != []: if var.needs != []:
var.needs.sort() var.needs.sort()
print >>file, ".SH Needs" print(".SH Needs", file=file)
process_deps(file,var.needs) process_deps(file,var.needs)
if var.needed_by != []: if var.needed_by != []:
var.needed_by.sort() var.needed_by.sort()
print >>file, ".SH Needed by" print(".SH Needed by", file=file)
process_deps(file,var.needed_by) process_deps(file,var.needed_by)
print >>file, ".SH Instability factor" print(".SH Instability factor", file=file)
fo = len(var.children) fo = len(var.children)
fi = len(var.parents) fi = len(var.parents)
print >>file, "%5.1f %%"%(100.* (fi / (fi+fo+.000001) )) print("%5.1f %%"%(100.* (fi / (fi+fo+.000001) )), file=file)
print >>file, ".br" print(".br", file=file)
file.close() file.close()
###################################################################### ######################################################################
@ -108,12 +108,12 @@ def do_print_rst(var):
filename = var.line.filename[0] filename = var.line.filename[0]
name = var.name name = var.name
file = open("%s%s.rst"%(mandir,var.name), "w") file = open("%s%s.rst"%(mandir,var.name), "w")
print >>file, ".. c:var:: %s\n"%(var.name.lower()) print(".. c:var:: %s\n"%(var.name.lower()), file=file)
print >>file, "" print("", file=file)
print >>file, " File : :file:`"+filename+"`" print(" File : :file:`"+filename+"`", file=file)
print >>file, "" print("", file=file)
print >>file, " .. code:: fortran" print(" .. code:: fortran", file=file)
print >>file, "" print("", file=file)
if var.same_as != var.name: if var.same_as != var.name:
var = variables[var.same_as] var = variables[var.same_as]
for v in [var.name] + var.others: for v in [var.name] + var.others:
@ -121,9 +121,9 @@ def do_print_rst(var):
v = variables[v] v = variables[v]
Type = v.type Type = v.type
dim = build_dim(v.dim) dim = build_dim(v.dim)
print >>file, " %s\t:: %s\t%s"%(Type,name,dim) print(" %s\t:: %s\t%s"%(Type,name,dim), file=file)
print >>file, "" print("", file=file)
print >>file, "" print("", file=file)
if var.doc != []: if var.doc != []:
d = [] d = []
@ -146,33 +146,33 @@ def do_print_rst(var):
if loop: if loop:
d = [ l[1:] for l in d ] d = [ l[1:] for l in d ]
for line in d: for line in d:
print >>file, " "+line print(" "+line, file=file)
print >>file, "" print("", file=file)
if var.needs != []: if var.needs != []:
var.needs.sort() var.needs.sort()
print >>file, " Needs:" print(" Needs:", file=file)
print >>file, "" print("", file=file)
print >>file, " .. hlist::" print(" .. hlist::", file=file)
print >>file, " :columns: 3" print(" :columns: 3", file=file)
print >>file, "" print("", file=file)
for v in var.needs: for v in var.needs:
print >>file, " * :c:data:`%s`"%(variables[v].same_as.lower(),) print(" * :c:data:`%s`"%(variables[v].same_as.lower(),), file=file)
print >>file, "" print("", file=file)
if var.needed_by != []: if var.needed_by != []:
var.needed_by.sort() var.needed_by.sort()
print >>file, " Needed by:" print(" Needed by:", file=file)
print >>file, "" print("", file=file)
print >>file, " .. hlist::" print(" .. hlist::", file=file)
print >>file, " :columns: 3" print(" :columns: 3", file=file)
print >>file, "" print("", file=file)
for v in var.needed_by: for v in var.needed_by:
print >>file, " * :c:data:`%s`"%(variables[v].same_as.lower(),) print(" * :c:data:`%s`"%(variables[v].same_as.lower(),), file=file)
print >>file, "" print("", file=file)
file.close() file.close()
###################################################################### ######################################################################
def process_declaration_subroutine(file, sub): def process_declaration_subroutine(file, sub):
print >>file, sub.line.text.split('!')[0].strip() print(sub.line.text.split('!')[0].strip(), file=file)
# for line in sub.text: # for line in sub.text:
###################################################################### ######################################################################
@ -181,38 +181,38 @@ def do_print_subroutines(sub):
filename = sub.line.filename filename = sub.line.filename
name = sub.name name = sub.name
file = open("%s%s.l"%(mandir,sub.name), "w") file = open("%s%s.l"%(mandir,sub.name), "w")
print >>file, '.TH "IRPF90 entities" l %s "IRPF90 entities" %s'%(name,name) print('.TH "IRPF90 entities" l %s "IRPF90 entities" %s'%(name,name), file=file)
print >>file, ".SH Declaration" print(".SH Declaration", file=file)
print >>file, ".nf" print(".nf", file=file)
process_declaration_subroutine(file,sub) process_declaration_subroutine(file,sub)
print >>file, ".ni" print(".ni", file=file)
if sub.doc != []: if sub.doc != []:
print >>file, ".SH Description" print(".SH Description", file=file)
for l in sub.doc: for l in sub.doc:
process_doc(file,l) process_doc(file,l)
print >>file, ".SH File\n.P" print(".SH File\n.P", file=file)
print >>file, filename print(filename, file=file)
if sub.needs != []: if sub.needs != []:
sub.needs.sort() sub.needs.sort()
print >>file, ".SH Needs" print(".SH Needs", file=file)
process_deps(file,sub.needs) process_deps(file,sub.needs)
if sub.called_by != []: if sub.called_by != []:
sub.called_by.sort() sub.called_by.sort()
print >>file, ".SH Called by" print(".SH Called by", file=file)
process_deps(file,sub.called_by) process_deps(file,sub.called_by)
if sub.calls != []: if sub.calls != []:
sub.calls.sort() sub.calls.sort()
print >>file, ".SH Calls" print(".SH Calls", file=file)
process_deps(file,sub.calls) process_deps(file,sub.calls)
if sub.touches != []: if sub.touches != []:
sub.touches.sort() sub.touches.sort()
print >>file, ".SH Touches" print(".SH Touches", file=file)
process_deps(file,sub.touches) process_deps(file,sub.touches)
print >>file, ".SH Instability factor" print(".SH Instability factor", file=file)
fo = len(sub.needs)+len(sub.calls)+len(sub.touches) fo = len(sub.needs)+len(sub.calls)+len(sub.touches)
fi = len(sub.called_by) fi = len(sub.called_by)
print >>file, "%5.1f %%"%(100.* (fi / (fi+fo+.000001) )) print("%5.1f %%"%(100.* (fi / (fi+fo+.000001) )), file=file)
print >>file, ".br" print(".br", file=file)
file.close() file.close()
###################################################################### ######################################################################
@ -222,15 +222,15 @@ def do_print_subroutines_rst(sub):
filename = sub.line.filename filename = sub.line.filename
name = sub.name name = sub.name
file = open("%s%s.rst"%(mandir,sub.name), "w") file = open("%s%s.rst"%(mandir,sub.name), "w")
print >>file, ".. c:function:: %s:\n"%(sub.name.lower()) print(".. c:function:: %s:\n"%(sub.name.lower()), file=file)
print >>file, "" print("", file=file)
print >>file, " File : :file:`"+filename+"`" print(" File : :file:`"+filename+"`", file=file)
print >>file, "" print("", file=file)
print >>file, " .. code:: fortran" print(" .. code:: fortran", file=file)
print >>file, "" print("", file=file)
print >>file, " "+sub.line.text.split('!')[0].strip() print(" "+sub.line.text.split('!')[0].strip(), file=file)
print >>file, "" print("", file=file)
print >>file, "" print("", file=file)
if sub.doc != []: if sub.doc != []:
d = list(sub.doc) d = list(sub.doc)
loop = True loop = True
@ -246,63 +246,63 @@ def do_print_subroutines_rst(sub):
if loop: if loop:
d = [ l[1:] for l in d ] d = [ l[1:] for l in d ]
for l in d: for l in d:
print >>file, " "+l print(" "+l, file=file)
print >>file, "" print("", file=file)
if sub.needs != []: if sub.needs != []:
sub.needs.sort() sub.needs.sort()
print >>file, " Needs:" print(" Needs:", file=file)
print >>file, "" print("", file=file)
print >>file, " .. hlist::" print(" .. hlist::", file=file)
print >>file, " :columns: 3" print(" :columns: 3", file=file)
print >>file, "" print("", file=file)
for v in sub.needs: for v in sub.needs:
print >>file, " * :c:data:`%s`"%(variables[v].same_as.lower(),) print(" * :c:data:`%s`"%(variables[v].same_as.lower(),), file=file)
print >>file, "" print("", file=file)
if sub.called_by != []: if sub.called_by != []:
sub.called_by.sort() sub.called_by.sort()
print >>file, " Called by:" print(" Called by:", file=file)
print >>file, "" print("", file=file)
print >>file, " .. hlist::" print(" .. hlist::", file=file)
print >>file, " :columns: 3" print(" :columns: 3", file=file)
print >>file, "" print("", file=file)
for v in sub.called_by: for v in sub.called_by:
if v in subroutines: if v in subroutines:
print >>file, " * :c:func:`%s`"%(v.lower(),) print(" * :c:func:`%s`"%(v.lower(),), file=file)
elif v in variables: elif v in variables:
print >>file, " * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),) print(" * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),), file=file)
print >>file, "" print("", file=file)
if sub.calls != []: if sub.calls != []:
sub.calls.sort() sub.calls.sort()
print >>file, " Calls:" print(" Calls:", file=file)
print >>file, "" print("", file=file)
print >>file, " .. hlist::" print(" .. hlist::", file=file)
print >>file, " :columns: 3" print(" :columns: 3", file=file)
print >>file, "" print("", file=file)
for v in sub.calls: for v in sub.calls:
print >>file, " * :c:func:`%s`"%(v.lower(),) print(" * :c:func:`%s`"%(v.lower(),), file=file)
print >>file, "" print("", file=file)
if sub.touches != []: if sub.touches != []:
sub.touches.sort() sub.touches.sort()
print >>file, " Touches:" print(" Touches:", file=file)
print >>file, "" print("", file=file)
print >>file, " .. hlist::" print(" .. hlist::", file=file)
print >>file, " :columns: 3" print(" :columns: 3", file=file)
print >>file, "" print("", file=file)
for v in sub.touches: for v in sub.touches:
print >>file, " * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),) print(" * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),), file=file)
print >>file, "" print("", file=file)
file.close() file.close()
###################################################################### ######################################################################
def run(): def run():
import parsed_text from . import parsed_text
import os,sys import os,sys
pid1 = os.fork() pid1 = os.fork()
if pid1 == 0: if pid1 == 0:
for v in variables.values(): for v in list(variables.values()):
do_print(v) do_print(v)
do_print_rst(v) do_print_rst(v)
for s in subroutines.values(): for s in list(subroutines.values()):
do_print_subroutines(s) do_print_subroutines(s)
do_print_subroutines_rst(s) do_print_subroutines_rst(s)
sys.exit(0) sys.exit(0)
@ -310,7 +310,7 @@ def run():
pid2 = os.fork() pid2 = os.fork()
if pid2 == 0: if pid2 == 0:
tags = [] tags = []
l = variables.keys() l = list(variables.keys())
file = open("irpf90_entities","w") file = open("irpf90_entities","w")
l.sort() l.sort()
for v in l: for v in l:
@ -318,7 +318,7 @@ def run():
line = variables[v].line line = variables[v].line
tags.append( '%s\t%s\t%d\n'%(v,line.filename[0],line.i) ) tags.append( '%s\t%s\t%d\n'%(v,line.filename[0],line.i) )
file.close() file.close()
l = subroutines.keys() l = list(subroutines.keys())
for v in l: for v in l:
line = subroutines[v].line line = subroutines[v].line
tags.append('%s\t%s\t%d\n'%(v,line.filename,line.i)) tags.append('%s\t%s\t%d\n'%(v,line.filename,line.i))

24
src/error.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -26,20 +26,20 @@
import sys import sys
from irpf90_t import * from .irpf90_t import *
from command_line import command_line from .command_line import command_line
do_warnings = command_line.do_warnings do_warnings = command_line.do_warnings
###################################################################### ######################################################################
def fail(line,message): def fail(line,message):
print """ print("""
Error: Error:
----- -----
""" """)
print message, '\n' print(message, '\n')
if line is not None: if line is not None:
assert isinstance(line,Line) assert isinstance(line,Line)
print "file %s ; line %d :\n %s"%(line.filename,line.i,line.text) print("file %s ; line %d :\n %s"%(line.filename,line.i,line.text))
sys.exit(1) sys.exit(1)
@ -49,14 +49,14 @@ def warn(line,message):
return return
if line is not None: if line is not None:
assert isinstance(line,Line) assert isinstance(line,Line)
print """ print("""
Warning: Warning:
------- -------
""" """)
print message, '\n' print(message, '\n')
print "file %s, line %d:\n %s"%(line.filename,line.i,line.text) print("file %s, line %d:\n %s"%(line.filename,line.i,line.text))
else: else:
print "Warning: %s"%(message) print("Warning: %s"%(message))
###################################################################### ######################################################################

14
src/init.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -27,10 +27,10 @@
import os import os
import util from . import util
import makefile from . import makefile
import irpf90_t from . import irpf90_t
from command_line import command_line from .command_line import command_line
initialized = False initialized = False
@ -67,7 +67,7 @@ def init():
try: try:
os.stat(dir) os.stat(dir)
except: except:
print dir,'not in dir' print(dir,'not in dir')
continue continue
for filename in os.listdir(dir): for filename in os.listdir(dir):
filename = dir+filename filename = dir+filename
@ -76,7 +76,7 @@ def init():
file = open(filename,"r") file = open(filename,"r")
except IOError: except IOError:
if command_line.do_warnings: if command_line.do_warnings:
print "Warning : Unable to read file %s."%(filename) print("Warning : Unable to read file %s."%(filename))
else: else:
buffer = file.read() buffer = file.read()
file.close() file.close()

10
src/irp_stack.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,14 +25,14 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
import util from . import util
from command_line import command_line from .command_line import command_line
do_debug = command_line.do_debug do_debug = command_line.do_debug
do_openmp = command_line.do_openmp do_openmp = command_line.do_openmp
do_memory = command_line.do_memory do_memory = command_line.do_memory
import irpf90_t from . import irpf90_t
FILENAME = irpf90_t.irpdir+"irp_stack.irp.F90" FILENAME = irpf90_t.irpdir+"irp_stack.irp.F90"
@ -149,7 +149,7 @@ end subroutine
""" """
txt = txt.split('\n') txt = txt.split('\n')
txt = map(lambda x: x+"\n",txt) txt = [x+"\n" for x in txt]
if not util.same_file(FILENAME, txt): if not util.same_file(FILENAME, txt):
file = open(FILENAME,'w') file = open(FILENAME,'w')
file.writelines(txt) file.writelines(txt)

44
src/irpf90.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -26,7 +26,7 @@
import vim from . import vim
import os,sys import os,sys
try: try:
wd = os.path.abspath(os.path.dirname(__file__)) wd = os.path.abspath(os.path.dirname(__file__))
@ -35,7 +35,7 @@ except:
pass pass
sys.setcheckinterval(1000) sys.setcheckinterval(1000)
from command_line import command_line from .command_line import command_line
def main(): def main():
@ -45,33 +45,33 @@ def main():
command_line.usage() command_line.usage()
if command_line.do_version: if command_line.do_version:
from version import version from .version import version
print version print(version)
from init import init from .init import init
if command_line.do_init: if command_line.do_init:
init() init()
if command_line.do_preprocess: if command_line.do_preprocess:
init() init()
from preprocessed_text import preprocessed_text from .preprocessed_text import preprocessed_text
for filename,text in preprocessed_text: for filename,text in preprocessed_text:
if filename in command_line.preprocessed: if filename in command_line.preprocessed:
for line in text: for line in text:
print line.text print(line.text)
if command_line.do_touch: if command_line.do_touch:
from variables import variables from .variables import variables
for var in command_line.touched: for var in command_line.touched:
if var not in variables: if var not in variables:
print "%s is not an IRP entity"%(var,) print("%s is not an IRP entity"%(var,))
else: else:
print "Touching %s invalidates the following entities:"%(var,) print("Touching %s invalidates the following entities:"%(var,))
parents = variables[var].parents parents = variables[var].parents
parents.sort() parents.sort()
for x in parents: for x in parents:
print "- %s"%(x,) print("- %s"%(x,))
if not command_line.do_run: if not command_line.do_run:
@ -79,39 +79,39 @@ def main():
init() init()
import irp_stack from . import irp_stack
irp_stack.create() irp_stack.create()
import makefile from . import makefile
makefile.create() makefile.create()
if command_line.do_codelet: if command_line.do_codelet:
import profile from . import profile
profile.build_rdtsc() profile.build_rdtsc()
import codelet from . import codelet
codelet.run() codelet.run()
from modules import modules, write_module from .modules import modules, write_module
for m in modules.keys(): for m in list(modules.keys()):
write_module(modules[m]) write_module(modules[m])
makefile.run() makefile.run()
import touches from . import touches
touches.create() touches.create()
# import checkpoint # import checkpoint
# checkpoint.create() # checkpoint.create()
import create_man from . import create_man
create_man.run() create_man.run()
if command_line.do_profile: if command_line.do_profile:
import profile from . import profile
profile.run() profile.run()
if command_line.do_openmp: if command_line.do_openmp:
import locks from . import locks
locks.create() locks.create()
if __name__ == '__main__': if __name__ == '__main__':

44
src/irpf90_indent.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -169,21 +169,21 @@ class indent(object):
line = self.format_continuation(line,k) line = self.format_continuation(line,k)
if grep.continuation(prevline): if grep.continuation(prevline):
print k+2*tab+self.format_continuation(line,k+2*tab) print(k+2*tab+self.format_continuation(line,k+2*tab))
continue continue
if grep.begin_subroutine(line): if grep.begin_subroutine(line):
print line print(line)
k = indent0+tab k = indent0+tab
continue continue
if grep.begin_function(line): if grep.begin_function(line):
print line print(line)
k = indent0+tab k = indent0+tab
continue continue
if grep.begin_program(line): if grep.begin_program(line):
print line print(line)
k = indent0+tab k = indent0+tab
continue continue
@ -191,76 +191,76 @@ class indent(object):
if line[0] != '&': if line[0] != '&':
k = indent0+tab k = indent0+tab
if grep.begin_provider(self.text[i+1].strip()): if grep.begin_provider(self.text[i+1].strip()):
print " "+line print(" "+line)
else: else:
print line print(line)
else: else:
print line print(line)
continue continue
if grep.declaration(line): if grep.declaration(line):
print k+self.format_declaration(line,30) print(k+self.format_declaration(line,30))
continue continue
if grep.begin_do(line): if grep.begin_do(line):
print k+line print(k+line)
k += tab k += tab
continue continue
if grep.begin_if(line): if grep.begin_if(line):
print k+line print(k+line)
k += tab k += tab
continue continue
if grep.xelse(line): if grep.xelse(line):
print k[:-tabn]+line print(k[:-tabn]+line)
continue continue
if grep.begin_select(line): if grep.begin_select(line):
print k+line print(k+line)
k += 2*tab k += 2*tab
continue continue
if grep.case(line): if grep.case(line):
print k[:-tabn]+line print(k[:-tabn]+line)
continue continue
if grep.end_do(line): if grep.end_do(line):
k = k[:-tabn] k = k[:-tabn]
print k+line print(k+line)
continue continue
if grep.end_if(line): if grep.end_if(line):
k = k[:-tabn] k = k[:-tabn]
print k+line print(k+line)
continue continue
if grep.end_select(line): if grep.end_select(line):
k = k[:-2*tabn] k = k[:-2*tabn]
print k+line print(k+line)
continue continue
if grep.end_subroutine(line): if grep.end_subroutine(line):
print line print(line)
k = indent0 k = indent0
continue continue
if grep.end_function(line): if grep.end_function(line):
print line print(line)
k = indent0 k = indent0
continue continue
if grep.end_provider(line): if grep.end_provider(line):
print line print(line)
k = indent0 k = indent0
continue continue
if grep.end_program(line): if grep.end_program(line):
print line print(line)
k = indent0 k = indent0
continue continue
print k+line print(k+line)
def main(): def main():

2
src/irpf90_python.exe
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA

8
src/irpf90_t.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -387,15 +387,15 @@ class Provide_all (Line):
def create_irpf90_files(): def create_irpf90_files():
result = [] result = []
from command_line import command_line from .command_line import command_line
import os import os
def is_irpf90_file(filename): def is_irpf90_file(filename):
return filename.endswith(".irp.f") and not filename.startswith('.') return filename.endswith(".irp.f") and not filename.startswith('.')
result = filter ( is_irpf90_file, os.listdir(os.getcwd()) ) result = list(filter ( is_irpf90_file, os.listdir(os.getcwd()) ))
for dir in command_line.include_dir: for dir in command_line.include_dir:
try: try:
os.stat(dir) os.stat(dir)
result += map(lambda x: dir+x, filter ( is_irpf90_file, os.listdir(dir) ) ) result += [dir+x for x in list(filter ( is_irpf90_file, os.listdir(dir) ))]
except: except:
continue continue
if command_line.do_codelet: if command_line.do_codelet:

6
src/irpman.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -29,10 +29,10 @@ import os
import sys import sys
wd = os.path.abspath(os.path.dirname(__file__)) wd = os.path.abspath(os.path.dirname(__file__))
from irpf90_t import mandir from .irpf90_t import mandir
filename = sys.argv[1].lower()+".l" filename = sys.argv[1].lower()+".l"
if filename not in os.listdir(mandir): if filename not in os.listdir(mandir):
print "%s does not exist"%(sys.argv[1]) print("%s does not exist"%(sys.argv[1]))
sys.exit(-1) sys.exit(-1)
os.system("man ./"+mandir+sys.argv[1].lower()+".l") os.system("man ./"+mandir+sys.argv[1].lower()+".l")

14
src/locks.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,16 +25,16 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from command_line import command_line from .command_line import command_line
from irpf90_t import * from .irpf90_t import *
from util import * from .util import *
from variables import variables from .variables import variables
FILENAME=irpdir+'irp_locks.irp.F90' FILENAME=irpdir+'irp_locks.irp.F90'
def create(): def create():
out = [] out = []
l = variables.keys() l = list(variables.keys())
l.sort l.sort
for v in l: for v in l:
var = variables[v] var = variables[v]
@ -47,7 +47,7 @@ def create():
out += [ " call irp_lock_%s(.True.)"%v ] out += [ " call irp_lock_%s(.True.)"%v ]
out += [ " call irp_lock_%s(.False.)"%v ] out += [ " call irp_lock_%s(.False.)"%v ]
out += [ "end subroutine" ] out += [ "end subroutine" ]
out = map(lambda x: "%s\n"%(x),out) out = ["%s\n"%(x) for x in out]
if not same_file(FILENAME,out): if not same_file(FILENAME,out):
file = open(FILENAME,'w') file = open(FILENAME,'w')
file.writelines(out) file.writelines(out)

108
src/makefile.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -26,8 +26,8 @@
import os,sys import os,sys
import irpf90_t from . import irpf90_t
from command_line import command_line from .command_line import command_line
irpdir = irpf90_t.irpdir irpdir = irpf90_t.irpdir
mandir = irpf90_t.mandir mandir = irpf90_t.mandir
@ -82,14 +82,14 @@ def create_gitignore():
###################################################################### ######################################################################
def run_ninja(): def run_ninja():
import ninja from . import ninja
ninja.run() ninja.run()
###################################################################### ######################################################################
def run_make(): def run_make():
from modules import modules from .modules import modules
mod = [] mod = []
for m in modules.values(): for m in list(modules.values()):
mod.append(m) mod.append(m)
file = open(IRPF90_MAKE,'w') file = open(IRPF90_MAKE,'w')
@ -108,41 +108,41 @@ def run_make():
for m in mod: for m in mod:
result += " %s%s.irp.F90"%(irpdir,m.filename) result += " %s%s.irp.F90"%(irpdir,m.filename)
result += " %s%s.irp.module.F90"%(irpdir,m.filename) result += " %s%s.irp.module.F90"%(irpdir,m.filename)
print >>file, result print(result, file=file)
result = "OBJ_IRP = %sirp_stack.irp.o "%(irpdir) result = "OBJ_IRP = %sirp_stack.irp.o "%(irpdir)
for m in mod: for m in mod:
if not m.is_main: if not m.is_main:
result += " %s%s.irp.o"%(irpdir,m.filename) result += " %s%s.irp.o"%(irpdir,m.filename)
result += " %s%s.irp.module.o"%(irpdir,m.filename) result += " %s%s.irp.module.o"%(irpdir,m.filename)
print >>file, result print(result, file=file)
print >>file, "OBJ1 = $(OBJ_IRP) $(OBJ) %sirp_touches.irp.o "%(irpdir), print("OBJ1 = $(OBJ_IRP) $(OBJ) %sirp_touches.irp.o "%(irpdir), end=' ', file=file)
# print >>file, " %sirp_checkpoint.irp.o"%(irpdir), # print >>file, " %sirp_checkpoint.irp.o"%(irpdir),
if command_line.do_profile: if command_line.do_profile:
print >>file, " %sirp_profile.irp.o"%(irpdir), " irp_rdtsc.o", print(" %sirp_profile.irp.o"%(irpdir), " irp_rdtsc.o", end=' ', file=file)
if command_line.do_codelet: if command_line.do_codelet:
print >>file, " irp_rdtsc.o", print(" irp_rdtsc.o", end=' ', file=file)
if command_line.do_openmp: if command_line.do_openmp:
print >>file, " %sirp_locks.irp.o"%(irpdir) print(" %sirp_locks.irp.o"%(irpdir), file=file)
else: else:
print >>file, "" print("", file=file)
all = filter(lambda x: modules[x].is_main, modules) all = [x for x in modules if modules[x].is_main]
all = map(lambda x: x[:-6], all) all = [x[:-6] for x in all]
all_o = map(lambda x: "%s.irp.module.o %s.irp.o"%(x,x), all) all_o = ["%s.irp.module.o %s.irp.o"%(x,x) for x in all]
print >>file, "ALL = %s"%(" ".join(all)) print("ALL = %s"%(" ".join(all)), file=file)
print >>file, "ALL_OBJ = %s"%(" ".join(all_o)) print("ALL_OBJ = %s"%(" ".join(all_o)), file=file)
print >>file, "ALL_OBJ1 = $(patsubst %%, %s%%,$(notdir $(ALL_OBJ)))"%(irpdir) print("ALL_OBJ1 = $(patsubst %%, %s%%,$(notdir $(ALL_OBJ)))"%(irpdir), file=file)
print >>file, "all:$(ALL)" print("all:$(ALL)", file=file)
print >>file, "\t@$(MAKE) -s move" print("\t@$(MAKE) -s move", file=file)
# print >>file, "ifdef USE_IRPF90_A" # print >>file, "ifdef USE_IRPF90_A"
for m in mod: for m in mod:
if m.is_main: if m.is_main:
exe = m.filename exe = m.filename
print >>file, "%s: %s%s.irp.o %s%s.irp.module.o IRPF90_temp/irpf90.a"%(exe,irpdir,exe,irpdir,exe) print("%s: %s%s.irp.o %s%s.irp.module.o IRPF90_temp/irpf90.a"%(exe,irpdir,exe,irpdir,exe), file=file)
print >>file, "\t$(FC) -o $@ %s$@.irp.o %s$@.irp.module.o IRPF90_temp/irpf90.a $(LIB)"%(irpdir,irpdir) print("\t$(FC) -o $@ %s$@.irp.o %s$@.irp.module.o IRPF90_temp/irpf90.a $(LIB)"%(irpdir,irpdir), file=file)
print >>file, "\t@$(MAKE) -s move" print("\t@$(MAKE) -s move", file=file)
# print >>file, "else" # print >>file, "else"
# for m in mod: # for m in mod:
# if m.is_main: # if m.is_main:
@ -155,43 +155,43 @@ def run_make():
buffer = "" buffer = ""
for m in mod: for m in mod:
filename = "%s%s.irp.o: $(OBJ) %s%s.irp.module.o"%(irpdir,m.filename,irpdir,m.filename) filename = "%s%s.irp.o: $(OBJ) %s%s.irp.module.o"%(irpdir,m.filename,irpdir,m.filename)
needed_modules = filter( lambda x: modules[x].name in m.needed_modules, modules ) needed_modules = [x for x in modules if modules[x].name in m.needed_modules]
needed_files = map(lambda x: modules[x].filename, needed_modules) needed_files = [modules[x].filename for x in needed_modules]
mds = map (lambda x: " %s%s.irp.module.o"%(irpdir,x),needed_files) mds = [" %s%s.irp.module.o"%(irpdir,x) for x in needed_files]
print >>file, filename," ".join(mds)," ".join(m.includes) print(filename," ".join(mds)," ".join(m.includes), file=file)
if not m.is_main: if not m.is_main:
buffer += "\t - @echo '"+filename+" ".join(mds)+"' >> %sdist_Makefile\n"%(irpdir) buffer += "\t - @echo '"+filename+" ".join(mds)+"' >> %sdist_Makefile\n"%(irpdir)
# print >>file, "%sirp_touches.irp.o %sirp_checkpoint.irp.o: $(OBJ) "%(irpdir,irpdir), # print >>file, "%sirp_touches.irp.o %sirp_checkpoint.irp.o: $(OBJ) "%(irpdir,irpdir),
print >>file, "%sirp_touches.irp.o: $(OBJ) "%(irpdir), print("%sirp_touches.irp.o: $(OBJ) "%(irpdir), end=' ', file=file)
mds = filter(lambda x: not x.is_main,mod) mds = [x for x in mod if not x.is_main]
mds = map(lambda x: " %s%s.irp.o %s%s.irp.o"%(irpdir,x.filename,irpdir,x.filename),mds) mds = [" %s%s.irp.o %s%s.irp.o"%(irpdir,x.filename,irpdir,x.filename) for x in mds]
print >>file," ".join(mds) print(" ".join(mds), file=file)
if command_line.do_profile: if command_line.do_profile:
print >>file, "%sirp_profile.irp.o:"%(irpdir), print("%sirp_profile.irp.o:"%(irpdir), end=' ', file=file)
print >>file," ".join(mds) print(" ".join(mds), file=file)
if command_line.do_openmp: if command_line.do_openmp:
print >>file, "%sirp_locks.irp.o:"%(irpdir), print("%sirp_locks.irp.o:"%(irpdir), end=' ', file=file)
print >>file," ".join(mds) print(" ".join(mds), file=file)
for dir in [ irpdir ] + map(lambda x: irpdir+x, command_line.include_dir): for dir in [ irpdir ] + [irpdir+x for x in command_line.include_dir]:
print >>file, dir+"%.irp.module.o: $(OBJ) "+dir+"%.irp.module.F90" print(dir+"%.irp.module.o: $(OBJ) "+dir+"%.irp.module.F90", file=file)
print >>file, "\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.module.F90 -o "+dir+"$*.irp.module.o" print("\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.module.F90 -o "+dir+"$*.irp.module.o", file=file)
print >>file, dir+"%.irp.o: $(OBJ) "+dir+"%.irp.module.o "+dir+"%.irp.F90" print(dir+"%.irp.o: $(OBJ) "+dir+"%.irp.module.o "+dir+"%.irp.F90", file=file)
print >>file, "\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o" print("\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o", file=file)
print >>file, dir+"%.irp.o: $(OBJ) "+dir+"%.irp.F90" print(dir+"%.irp.o: $(OBJ) "+dir+"%.irp.F90", file=file)
print >>file, "\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o" print("\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o", file=file)
print >>file, dir+"%.o: %.F90" print(dir+"%.o: %.F90", file=file)
print >>file, "\t$(FC) $(FCFLAGS) -c $*.F90 -o "+dir+"$*.o" print("\t$(FC) $(FCFLAGS) -c $*.F90 -o "+dir+"$*.o", file=file)
print >>file, dir+"%.o: %.f90\n\t$(FC) $(FCFLAGS) -c $*.f90 -o "+dir+"$*.o" print(dir+"%.o: %.f90\n\t$(FC) $(FCFLAGS) -c $*.f90 -o "+dir+"$*.o", file=file)
print >>file, dir+"%.o: %.f\n\t$(FC) $(FCFLAGS) -c $*.f -o "+dir+"$*.o" print(dir+"%.o: %.f\n\t$(FC) $(FCFLAGS) -c $*.f -o "+dir+"$*.o", file=file)
print >>file, dir+"%.o: %.F\n\t$(FC) $(FCFLAGS) -c $*.F -o "+dir+"$*.o" print(dir+"%.o: %.F\n\t$(FC) $(FCFLAGS) -c $*.F -o "+dir+"$*.o", file=file)
print >>file, dir+"%.irp.F90: "+IRPF90_MAKE+"\n" print(dir+"%.irp.F90: "+IRPF90_MAKE+"\n", file=file)
print >>file, "move:\n\t@mv -f *.mod IRPF90_temp/ 2> /dev/null | DO_NOTHING=\n" print("move:\n\t@mv -f *.mod IRPF90_temp/ 2> /dev/null | DO_NOTHING=\n", file=file)
print >>file, "IRPF90_temp/irpf90.a: $(OBJ) $(OBJ1)\n\t$(AR) crf IRPF90_temp/irpf90.a $(OBJ1)\n" print("IRPF90_temp/irpf90.a: $(OBJ) $(OBJ1)\n\t$(AR) crf IRPF90_temp/irpf90.a $(OBJ1)\n", file=file)
print >>file, "clean:\n\trm -rf $(EXE) $(OBJ1) IRPF90_temp/irpf90.a $(ALL_OBJ1) $(ALL)\n" print("clean:\n\trm -rf $(EXE) $(OBJ1) IRPF90_temp/irpf90.a $(ALL_OBJ1) $(ALL)\n", file=file)
print >>file, "veryclean:\n\t- $(MAKE) clean\n" print("veryclean:\n\t- $(MAKE) clean\n", file=file)
print >>file, "\t- rm -rf "+irpdir+" "+mandir+" "+IRPF90_MAKE+" irpf90_entities dist tags\n" print("\t- rm -rf "+irpdir+" "+mandir+" "+IRPF90_MAKE+" irpf90_entities dist tags\n", file=file)
file.close() file.close()

53
src/module.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,12 +25,12 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from irpf90_t import * from .irpf90_t import *
from variable import * from .variable import *
from variables import variables from .variables import variables
from command_line import command_line from .command_line import command_line
import preprocessed_text from . import preprocessed_text
from util import * from .util import *
class Fmodule(object): class Fmodule(object):
@ -57,7 +57,7 @@ class Fmodule(object):
def prog_name(self): def prog_name(self):
if '_prog_name' not in self.__dict__: if '_prog_name' not in self.__dict__:
buffer = filter(lambda x: type(x[1]) == Program,self.text) buffer = [x for x in self.text if type(x[1]) == Program]
if buffer == []: if buffer == []:
self._prog_name = None self._prog_name = None
else: else:
@ -67,9 +67,9 @@ class Fmodule(object):
def variables(self): def variables(self):
if '_variables' not in self.__dict__: if '_variables' not in self.__dict__:
from variables import variables from .variables import variables
name = self.name name = self.name
self._variables = filter(lambda x: variables[x].fmodule == name, variables) self._variables = [x for x in variables if variables[x].fmodule == name]
return self._variables return self._variables
variables = property(variables) variables = property(variables)
@ -79,7 +79,7 @@ class Fmodule(object):
result = [ "module %s"%(self.name) ] result = [ "module %s"%(self.name) ]
result += self.use result += self.use
result += self.dec result += self.dec
result += flatten( map(lambda x: variables[x].header,self.variables) ) result += flatten( [variables[x].header for x in self.variables] )
result.append( "end module %s"%(self.name) ) result.append( "end module %s"%(self.name) )
self._head = result self._head = result
return self._head return self._head
@ -87,7 +87,7 @@ class Fmodule(object):
def needed_vars(self): def needed_vars(self):
if '_needed_vars' not in self.__dict__: if '_needed_vars' not in self.__dict__:
result = map(lambda x: variables[x].needs,self.variables) result = [variables[x].needs for x in self.variables]
result = make_single ( flatten(result) ) result = make_single ( flatten(result) )
self._needed_vars = result self._needed_vars = result
return self._needed_vars return self._needed_vars
@ -119,8 +119,8 @@ class Fmodule(object):
def residual_text(self): def residual_text(self):
if '_residual_text' not in self.__dict__: if '_residual_text' not in self.__dict__:
from variables import build_use, call_provides from .variables import build_use, call_provides
from parsed_text import move_to_top from .parsed_text import move_to_top
def remove_providers(text): def remove_providers(text):
result = [] result = []
inside = False inside = False
@ -140,7 +140,7 @@ class Fmodule(object):
if type(line) in [ Subroutine, Function ]: if type(line) in [ Subroutine, Function ]:
variable_list = list(vars) variable_list = list(vars)
elif type(line) == End: elif type(line) == End:
result += map(lambda x: ([],Use(line.i,x,line.filename)), build_use(variable_list)) result += [([],Use(line.i,x,line.filename)) for x in build_use(variable_list)]
else: else:
variable_list += vars variable_list += vars
result.append( (vars,line) ) result.append( (vars,line) )
@ -169,21 +169,21 @@ class Fmodule(object):
result = [] result = []
for vars,line in text: for vars,line in text:
result.append( ([],line) ) result.append( ([],line) )
result += map(lambda x: ([],Simple_line(line.i,x,line.filename)), call_provides(vars)) result += [([],Simple_line(line.i,x,line.filename)) for x in call_provides(vars)]
return result return result
result = remove_providers(self.text) result = remove_providers(self.text)
result = modify_functions(result) result = modify_functions(result)
use,dec,result = extract_use_dec_text(result) use,dec,result = extract_use_dec_text(result)
self._use = make_single(map(lambda x: " "+x[1].text, use)) self._use = make_single([" "+x[1].text for x in use])
self._dec = map(lambda x: " "+x[1].text, dec) self._dec = [" "+x[1].text for x in dec]
# self._dec = make_single(map(lambda x: " "+x[1].text, dec)) # self._dec = make_single(map(lambda x: " "+x[1].text, dec))
result = provide_variables(result) result = provide_variables(result)
result = move_to_top(result,Declaration) result = move_to_top(result,Declaration)
result = move_to_top(result,Implicit) result = move_to_top(result,Implicit)
result = move_to_top(result,Use) result = move_to_top(result,Use)
result = map(lambda x: x[1], result) result = [x[1] for x in result]
result = map(lambda x: x.text, result) result = [x.text for x in result]
self._residual_text = result self._residual_text = result
return self._residual_text return self._residual_text
residual_text = property(residual_text) residual_text = property(residual_text)
@ -203,10 +203,9 @@ class Fmodule(object):
def needed_modules(self): def needed_modules(self):
if '_needed_modules' not in self.__dict__: if '_needed_modules' not in self.__dict__:
buffer = filter(lambda x: x.lstrip().startswith("use "), \ buffer = [x for x in self.generated_text+self.head+self.residual_text if x.lstrip().startswith("use ")]
self.generated_text+self.head+self.residual_text) buffer = [x.split()[1] for x in buffer]
buffer = map(lambda x: x.split()[1], buffer) buffer = [x for x in buffer if x.endswith("_mod")]
buffer = filter(lambda x: x.endswith("_mod"),buffer )
self._needed_modules = make_single(buffer) self._needed_modules = make_single(buffer)
if self.name in self._needed_modules: if self.name in self._needed_modules:
self._needed_modules.remove(self.name) self._needed_modules.remove(self.name)
@ -216,12 +215,12 @@ class Fmodule(object):
###################################################################### ######################################################################
if __name__ == '__main__': if __name__ == '__main__':
from parsed_text import parsed_text from .parsed_text import parsed_text
for filename, text in parsed_text: for filename, text in parsed_text:
if filename == 'vmc_step.irp.f': if filename == 'vmc_step.irp.f':
x = Fmodule(text,filename) x = Fmodule(text,filename)
break break
for line in x.head: for line in x.head:
print line print(line)
print x.includes print(x.includes)

14
src/modules.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,10 +25,10 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from irpf90_t import * from .irpf90_t import *
from parsed_text import parsed_text from .parsed_text import parsed_text
from module import Fmodule from .module import Fmodule
from util import * from .util import *
###################################################################### ######################################################################
def create_modules(): def create_modules():
@ -44,7 +44,7 @@ def write_module(m):
# Module data # Module data
filename = irpdir+m.filename+".irp.module.F90" filename = irpdir+m.filename+".irp.module.F90"
text = m.header + m.head text = m.header + m.head
text = map(lambda x: "%s\n"%(x),text) text = ["%s\n"%(x) for x in text]
if not same_file(filename,text): if not same_file(filename,text):
# print filename # print filename
file = open(filename,"w") file = open(filename,"w")
@ -54,7 +54,7 @@ def write_module(m):
# Subroutines # Subroutines
filename = irpdir+m.filename+".irp.F90" filename = irpdir+m.filename+".irp.F90"
text = m.header + m.generated_text + m.residual_text text = m.header + m.generated_text + m.residual_text
text = map(lambda x: "%s\n"%(x),text) text = ["%s\n"%(x) for x in text]
if not same_file(filename,text): if not same_file(filename,text):
# print filename # print filename
file = open(filename,"w") file = open(filename,"w")

24
src/ninja.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -26,9 +26,9 @@
import os,sys import os,sys
import irpf90_t from . import irpf90_t
from command_line import command_line from .command_line import command_line
from modules import modules from .modules import modules
irpdir = irpf90_t.irpdir irpdir = irpf90_t.irpdir
mandir = irpf90_t.mandir mandir = irpf90_t.mandir
irp_id = irpf90_t.irp_id irp_id = irpf90_t.irp_id
@ -64,7 +64,7 @@ def create_build_touches(list_of_other_o):
needed_modules = [ "%s.irp.module.o"%(modules[x].filename) for x in modules ] needed_modules = [ "%s.irp.module.o"%(modules[x].filename) for x in modules ]
list_of_modules = map(dress, needed_modules) + list_of_other_o list_of_modules = list(map(dress, needed_modules)) + list_of_other_o
list_of_modules = ' '.join(list_of_modules) list_of_modules = ' '.join(list_of_modules)
result = '\n'.join( result = '\n'.join(
@ -113,10 +113,10 @@ def create_build_target(t,list_of_other_o):
list_of_o = [ target_o, target_module_o, irp_lib ] list_of_o = [ target_o, target_module_o, irp_lib ]
list_of_o = ' '.join(list_of_o) list_of_o = ' '.join(list_of_o)
list_of_modules = map(dress, needed_modules) + list_of_other_o list_of_modules = list(map(dress, needed_modules)) + list_of_other_o
list_of_modules = ' '.join(list_of_modules) list_of_modules = ' '.join(list_of_modules)
list_of_includes = ' '.join(map(lambda x: dress(x,in_root=True), t.includes)) list_of_includes = ' '.join([dress(x,in_root=True) for x in t.includes])
result = '\n'.join( result = '\n'.join(
[ "build {target}: link_{id} {list_of_o}", [ "build {target}: link_{id} {list_of_o}",
@ -170,10 +170,10 @@ def create_build_non_target(t,list_of_other_o):
needed_modules = [ "%s.irp.module.o"%(modules[x].filename) for x in modules \ needed_modules = [ "%s.irp.module.o"%(modules[x].filename) for x in modules \
if modules[x].name in t.needed_modules ] + [ target_module_o ] if modules[x].name in t.needed_modules ] + [ target_module_o ]
list_of_modules = map(dress, needed_modules) list_of_modules = list(map(dress, needed_modules))
list_of_modules = ' '.join(list_of_modules) list_of_modules = ' '.join(list_of_modules)
list_of_externals = ' '.join([ dress(x,in_root=True) for x in list_of_other_o ]) list_of_externals = ' '.join([ dress(x,in_root=True) for x in list_of_other_o ])
list_of_includes = ' '.join(map(lambda x: dress(x,in_root=True), t.includes)) list_of_includes = ' '.join([dress(x,in_root=True) for x in t.includes])
result = '\n'.join( result = '\n'.join(
[ [
@ -257,7 +257,7 @@ veryclean: clean
""".format(irpdir, targets) """.format(irpdir, targets)
import makefile from . import makefile
with open(makefile.IRPF90_MAKE,'w') as file: with open(makefile.IRPF90_MAKE,'w') as file:
file.write(result) file.write(result)
@ -372,8 +372,8 @@ def run():
l_common_o += [ "irp_profile.irp.o", "irp_rdtsc.o" ] l_common_o += [ "irp_profile.irp.o", "irp_rdtsc.o" ]
l_common_s += [ "irp_profile.irp.F90", "irp_rdtsc.c" ] l_common_s += [ "irp_profile.irp.F90", "irp_rdtsc.c" ]
l_common_o = map(dress,l_common_o) + map(lambda x: dress(x,in_root=True), OBJ) l_common_o = list(map(dress,l_common_o)) + [dress(x,in_root=True) for x in OBJ]
l_common_s = map(dress,l_common_s) + map(lambda x: dress(x,in_root=True), SRC) l_common_s = list(map(dress,l_common_s)) + [dress(x,in_root=True) for x in SRC]
# IRP_touches # IRP_touches

80
src/parsed_text.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,17 +25,17 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from util import * from .util import *
from irpf90_t import * from .irpf90_t import *
from variables import variables from .variables import variables
from preprocessed_text import preprocessed_text from .preprocessed_text import preprocessed_text
from subroutines import subroutines from .subroutines import subroutines
import regexps, re import regexps, re
import error from . import error
vtuple = map(lambda v: (v, variables[v].same_as, variables[v].regexp), variables.keys()) vtuple = [(v, variables[v].same_as, variables[v].regexp) for v in list(variables.keys())]
stuple = map(lambda s: (s, subroutines[s].regexp), subroutines.keys()) stuple = [(s, subroutines[s].regexp) for s in list(subroutines.keys())]
stuple = filter(lambda s: subroutines[s[0]].is_function, stuple) stuple = [s for s in stuple if subroutines[s[0]].is_function]
re_string_sub = regexps.re_string.sub re_string_sub = regexps.re_string.sub
regexps_re_string_sub = regexps.re_string.sub regexps_re_string_sub = regexps.re_string.sub
@ -79,20 +79,20 @@ def check_touch(line,vars,main_vars):
error.fail(line,"Variable %s unknown"%(main_var,)) error.fail(line,"Variable %s unknown"%(main_var,))
x = variables[main_var] x = variables[main_var]
return [main_var]+x.others return [main_var]+x.others
all_others = make_single(flatten( map(fun,main_vars) )) all_others = make_single(flatten( list(map(fun,main_vars)) ))
all_others.sort() all_others.sort()
vars.sort() vars.sort()
for x,y in zip(vars,all_others): for x,y in zip(vars,all_others):
if x != y: if x != y:
message = "The following entities should be touched:\n" message = "The following entities should be touched:\n"
message = "\n".join([message]+map(lambda x: "- %s"%(x,),all_others)) message = "\n".join([message]+["- %s"%(x,) for x in all_others])
error.fail(line,message) error.fail(line,message)
################################################################################ ################################################################################
def update_variables(): def update_variables():
for filename,text in preprocessed_text: for filename,text in preprocessed_text:
for line in filter(lambda x: type(x) in [ Touch, SoftTouch ], text): for line in [x for x in text if type(x) in [ Touch, SoftTouch ]]:
vars = line.lower.split() vars = line.lower.split()
if len(vars) < 2: if len(vars) < 2:
error.fail(line,"Syntax error") error.fail(line,"Syntax error")
@ -101,7 +101,7 @@ def update_variables():
error.fail(line,"Variable %s unknown"%(v,)) error.fail(line,"Variable %s unknown"%(v,))
variables[v]._is_touched = True variables[v]._is_touched = True
for line in filter(lambda x: type(x) == Free,text): for line in [x for x in text if type(x) == Free]:
vars = line.lower.split() vars = line.lower.split()
if len(vars) < 2: if len(vars) < 2:
error.fail(line,"Syntax error") error.fail(line,"Syntax error")
@ -110,10 +110,10 @@ def update_variables():
error.fail(line,"Variable %s unknown"%(v,)) error.fail(line,"Variable %s unknown"%(v,))
variables[v].is_freed = True variables[v].is_freed = True
for line in filter(lambda x: type(x) == Irp_read,text): for line in [x for x in text if type(x) == Irp_read]:
variables[line.filename]._is_read = True variables[line.filename]._is_read = True
for line in filter(lambda x: type (x) == Irp_write,text): for line in [x for x in text if type (x) == Irp_write]:
variables[line.filename]._is_written = True variables[line.filename]._is_written = True
################################################################################ ################################################################################
@ -148,7 +148,7 @@ def get_parsed_text():
elif type(line) in [ Begin_provider, Cont_provider ]: elif type(line) in [ Begin_provider, Cont_provider ]:
if type(line) == Begin_provider: if type(line) == Begin_provider:
varlist = [] varlist = []
buffer = map(strip,line.lower.replace(']','').split(',')) buffer = list(map(strip,line.lower.replace(']','').split(',')))
assert len(buffer) > 1 assert len(buffer) > 1
v = buffer[1] v = buffer[1]
varlist.append(v) varlist.append(v)
@ -156,7 +156,7 @@ def get_parsed_text():
try: try:
variable_list.remove(variables[v].same_as) variable_list.remove(variables[v].same_as)
except ValueError: except ValueError:
print v, variables[v].same_as print(v, variables[v].same_as)
raise raise
append( (variable_list,line) ) append( (variable_list,line) )
elif type(line) == End_provider: elif type(line) == End_provider:
@ -164,7 +164,7 @@ def get_parsed_text():
append( ([],line) ) append( ([],line) )
elif type(line) == Provide: elif type(line) == Provide:
l = line.lower.split()[1:] l = line.lower.split()[1:]
l = filter(lambda x: x not in varlist, l) l = [x for x in l if x not in varlist]
for v in l: for v in l:
if v not in variables: if v not in variables:
error.fail(line,"Variable %s is unknown"%(v)) error.fail(line,"Variable %s is unknown"%(v))
@ -175,7 +175,7 @@ def get_parsed_text():
for v in l: for v in l:
if v not in variables: if v not in variables:
error.fail(line,"Variable %s is unknown"%(v)) error.fail(line,"Variable %s is unknown"%(v))
l = map(lambda x: "-%s"%(x), l) l = ["-%s"%(x) for x in l]
append( (l,Simple_line(line.i,"!%s"%(line.text),line.filename)) ) append( (l,Simple_line(line.i,"!%s"%(line.text),line.filename)) )
elif type(line) in [ Touch, SoftTouch ]: elif type(line) in [ Touch, SoftTouch ]:
vars = line.lower.split() vars = line.lower.split()
@ -185,7 +185,7 @@ def get_parsed_text():
def fun(x): def fun(x):
main = variables[x].same_as main = variables[x].same_as
return main return main
main_vars = make_single( map(fun, vars) ) main_vars = make_single( list(map(fun, vars)) )
check_touch(line,vars,main_vars) check_touch(line,vars,main_vars)
txt = " ".join(vars) txt = " ".join(vars)
append ( (vars,Simple_line(line.i,"!",line.filename)) ) append ( (vars,Simple_line(line.i,"!",line.filename)) )
@ -195,19 +195,19 @@ def get_parsed_text():
error.fail(line,"Variable %s unknown"%(x,)) error.fail(line,"Variable %s unknown"%(x,))
return [ ([],Simple_line(line.i," call touch_%s"%(x,),line.filename)), return [ ([],Simple_line(line.i," call touch_%s"%(x,),line.filename)),
([],Use(line.i," use %s"%(variables[x].fmodule), line.filename)) ] ([],Use(line.i," use %s"%(variables[x].fmodule), line.filename)) ]
result += flatten(map( fun, main_vars )) result += flatten(list(map( fun, main_vars )))
def fun(x): def fun(x):
if x not in variables: if x not in variables:
error.fail(line,"Variable %s unknown"%(x,)) error.fail(line,"Variable %s unknown"%(x,))
return ([],Simple_line(line.i," %s_is_built = .True."%(x,),line.filename)) return ([],Simple_line(line.i," %s_is_built = .True."%(x,),line.filename))
result += map( fun, main_vars[:-1] ) result += list(map( fun, main_vars[:-1] ))
if type(line) == SoftTouch: if type(line) == SoftTouch:
append ( ([],Simple_line(line.i,"! <<< END TOUCH (Soft)",line.filename)) ) append ( ([],Simple_line(line.i,"! <<< END TOUCH (Soft)",line.filename)) )
else: else:
append ( ([],Provide_all(line.i,"! <<< END TOUCH",line.filename)) ) append ( ([],Provide_all(line.i,"! <<< END TOUCH",line.filename)) )
elif type(line) == Call: elif type(line) == Call:
l = find_variables_in_line(line) l = find_variables_in_line(line)
l = filter(lambda x: x not in varlist, l) l = [x for x in l if x not in varlist]
sub = find_subroutine_in_line(line) sub = find_subroutine_in_line(line)
if sub not in subroutines: if sub not in subroutines:
t = Simple_line t = Simple_line
@ -220,12 +220,10 @@ def get_parsed_text():
vars = line.lower.split() vars = line.lower.split()
vars = vars[1:] vars = vars[1:]
append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) ) append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
use = map(lambda x: " use %s"%(variables[x].fmodule),vars) use = [" use %s"%(variables[x].fmodule) for x in vars]
for var in vars: for var in vars:
result += map(lambda x: ([],Use(line.i,x,line.filename)), result += [([],Use(line.i,x,line.filename)) for x in make_single(use)]
make_single(use)) result += [([],Simple_line(line.i,x,line.filename)) for x in variables[var].free]
result += map(lambda x: ([],Simple_line(line.i,x,line.filename)),
variables[var].free)
elif type(line) == Irp_read: elif type(line) == Irp_read:
append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) ) append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) )
elif type(line) == Irp_write: elif type(line) == Irp_write:
@ -234,7 +232,7 @@ def get_parsed_text():
pass pass
else: else:
l = find_variables_in_line(line) l = find_variables_in_line(line)
l = filter(lambda x: x not in varlist, l) l = [x for x in l if x not in varlist]
append( (l,line) ) append( (l,line) )
return result return result
@ -365,7 +363,7 @@ def move_variables():
elif type(line) in [ If, Select ]: elif type(line) in [ If, Select ]:
ifvars += list(varlist) ifvars += list(varlist)
append( (varlist,line) ) append( (varlist,line) )
vars += filter(lambda x: x in elsevars, ifvars) vars += [x for x in ifvars if x in elsevars]
ifvars = old_ifvars.pop() ifvars = old_ifvars.pop()
elsevars = old_elsevars.pop() elsevars = old_elsevars.pop()
varlist = old_varlist.pop() + vars varlist = old_varlist.pop() + vars
@ -401,13 +399,13 @@ def move_variables():
varlist = list(vars) varlist = list(vars)
elif type(line) in [ If, Select ]: elif type(line) in [ If, Select ]:
old_varlist.append(varlist) old_varlist.append(varlist)
vars = filter(lambda x: x not in varlist,vars) vars = [x for x in vars if x not in varlist]
varlist = make_single(varlist + vars) varlist = make_single(varlist + vars)
assert old_varlist is not varlist assert old_varlist is not varlist
elif type(line) in [ Elseif, Else, Case ]: elif type(line) in [ Elseif, Else, Case ]:
varlist = old_varlist.pop() varlist = old_varlist.pop()
old_varlist.append(varlist) old_varlist.append(varlist)
vars = filter(lambda x: x not in varlist,vars) vars = [x for x in vars if x not in varlist]
varlist = make_single(varlist + vars) varlist = make_single(varlist + vars)
assert old_varlist is not varlist assert old_varlist is not varlist
elif type(line) in [ Endif, End_select ]: elif type(line) in [ Endif, End_select ]:
@ -441,7 +439,7 @@ def build_needs():
var = None var = None
for vars,line in text: for vars,line in text:
if type(line) == Begin_provider: if type(line) == Begin_provider:
buffer = map(strip,line.lower.replace(']',',').split(',')) buffer = list(map(strip,line.lower.replace(']',',').split(',')))
var = variables[buffer[1]] var = variables[buffer[1]]
var.needs = [] var.needs = []
var.to_provide = vars var.to_provide = vars
@ -499,7 +497,7 @@ parsed_text = result
###################################################################### ######################################################################
from command_line import command_line from .command_line import command_line
def check_opt(): def check_opt():
if not command_line.do_checkopt: if not command_line.do_checkopt:
@ -510,9 +508,9 @@ def check_opt():
for vars,line in text: for vars,line in text:
if not type(line) == Provide_all: if not type(line) == Provide_all:
if do_level > 0 and vars != []: if do_level > 0 and vars != []:
print "Optimization: %s line %d"%(line.filename,line.i) print("Optimization: %s line %d"%(line.filename,line.i))
for v in vars: for v in vars:
print " PROVIDE ",v print(" PROVIDE ",v)
if type(line) == Do: if type(line) == Do:
do_level += 1 do_level += 1
elif type(line) == Enddo: elif type(line) == Enddo:
@ -527,7 +525,7 @@ def perform_loop_substitutions():
append = result.append append = result.append
for vars,line in text: for vars,line in text:
if type(line) in [ Do, If, Elseif ] : if type(line) in [ Do, If, Elseif ] :
for k,v in command_line.substituted.items(): for k,v in list(command_line.substituted.items()):
reg = v[1] reg = v[1]
while reg.search(line.text) is not None: while reg.search(line.text) is not None:
line.text = re.sub(reg,r'\1%s\3', line.text,count=1)%v[0] line.text = re.sub(reg,r'\1%s\3', line.text,count=1)%v[0]
@ -541,9 +539,9 @@ parsed_text = perform_loop_substitutions()
if __name__ == '__main__': if __name__ == '__main__':
for i in range(len(parsed_text)): for i in range(len(parsed_text)):
if parsed_text[i][0] == sys.argv[1]: if parsed_text[i][0] == sys.argv[1]:
print '!-------- %s -----------'%(parsed_text[i][0]) print('!-------- %s -----------'%(parsed_text[i][0]))
for line in parsed_text[i][1]: for line in parsed_text[i][1]:
print line[1] print(line[1])
print line[0], line[1].filename print(line[0], line[1].filename)
#for i in subroutines: #for i in subroutines:
# print i, subroutines[i].needs, subroutines[i].to_provide # print i, subroutines[i].needs, subroutines[i].to_provide

30
src/preprocessed_text.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -24,11 +24,11 @@
# 31062 Toulouse Cedex 4 # 31062 Toulouse Cedex 4
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from irpf90_t import * from .irpf90_t import *
from regexps import * from .regexps import *
import error from . import error
from command_line import command_line from .command_line import command_line
from util import * from .util import *
# Local regular expressions # Local regular expressions
re_endif = re.compile("end\s+if") re_endif = re.compile("end\s+if")
@ -263,7 +263,7 @@ def execute_templates(text):
fail(line,"Subst","Syntax error") fail(line,"Subst","Syntax error")
buffer = buffer[1].replace(']','') buffer = buffer[1].replace(']','')
buffer = buffer.split(',') buffer = buffer.split(',')
return map(lambda x: '$%s'%(x.strip()), buffer) return ['$%s'%(x.strip()) for x in buffer]
TEMPLATE = 1 TEMPLATE = 1
SUBST = 2 SUBST = 2
@ -301,7 +301,7 @@ def execute_templates(text):
if subst[-2:] == ';;': if subst[-2:] == ';;':
subst = subst[:-2] subst = subst[:-2]
for s in subst.split(';;'): for s in subst.split(';;'):
buffer = map(lambda x: x.strip(), s.split(';')) buffer = [x.strip() for x in s.split(';')]
if len(buffer) != len(variables): if len(buffer) != len(variables):
fail(line,"subst","%d variables defined, and %d substitutions"%(len(variables),len(buffer))) fail(line,"subst","%d variables defined, and %d substitutions"%(len(variables),len(buffer)))
script += "v.append( { \\\n" script += "v.append( { \\\n"
@ -323,7 +323,7 @@ def execute_templates(text):
file.close() file.close()
# Execute shell # Execute shell
import os import os
pipe = os.popen("python2 < %s"%(scriptname),'r') pipe = os.popen("python < %s"%(scriptname),'r')
lines = pipe.readlines() lines = pipe.readlines()
pipe.close() pipe.close()
result += get_text(lines,scriptname) result += get_text(lines,scriptname)
@ -689,7 +689,7 @@ def change_includes(text):
if type(line) == Include: if type(line) == Include:
txt = line.text.replace('"',"'").split("'") txt = line.text.replace('"',"'").split("'")
if len(txt) != 3: if len(txt) != 3:
print txt print(txt)
error.fail(line,"Error in include statement") error.fail(line,"Error in include statement")
directory = (("./"+line.filename).rsplit('/',1)[0]+'/')[2:] directory = (("./"+line.filename).rsplit('/',1)[0]+'/')[2:]
if directory == "": if directory == "":
@ -793,7 +793,7 @@ def check_begin_end(text):
filter_line = lambda line: type(line) in [ Do, Enddo, If, Endif, \ filter_line = lambda line: type(line) in [ Do, Enddo, If, Endif, \
Program, Begin_provider, End_provider, \ Program, Begin_provider, End_provider, \
Subroutine, Function, End, Begin_doc, End_doc ] Subroutine, Function, End, Begin_doc, End_doc ]
text = filter(filter_line, text) text = list(filter(filter_line, text))
d = { 'do' : Do, 'enddo': Enddo, d = { 'do' : Do, 'enddo': Enddo,
'if' : If, 'endif': Endif, 'if' : If, 'endif': Endif,
@ -911,16 +911,16 @@ def create_preprocessed_text(filename):
###################################################################### ######################################################################
preprocessed_text = parallel_loop( lambda x,y: create_preprocessed_text(x), \ preprocessed_text = parallel_loop( lambda x,y: create_preprocessed_text(x), \
map(lambda x: (x,None), irpf90_files ) ) [(x,None) for x in irpf90_files] )
###################################################################### ######################################################################
def debug(): def debug():
for filename, txt in preprocessed_text: for filename, txt in preprocessed_text:
if filename == 'invert.irp.f': if filename == 'invert.irp.f':
print "=== "+filename+" ===" print("=== "+filename+" ===")
for line in txt: for line in txt:
print line print(line)
print irpf90_files print(irpf90_files)
if __name__ == '__main__': if __name__ == '__main__':
debug() debug()

6
src/profile.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -45,7 +45,7 @@ import subprocess
import tempfile import tempfile
import os import os
import threading import threading
from irpf90_t import irpdir from .irpf90_t import irpdir
def build_rdtsc(): def build_rdtsc():
filename = irpdir+"irp_rdtsc.c" filename = irpdir+"irp_rdtsc.c"
@ -60,7 +60,7 @@ def build_rdtsc():
threading.Thread(target=t).start() threading.Thread(target=t).start()
def build_module(): def build_module():
from variables import variables from .variables import variables
data = """ data = """
module irp_timer module irp_timer
double precision :: irp_profile(3,%(n)d) double precision :: irp_profile(3,%(n)d)

2
src/regexps.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA

32
src/subroutine.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,9 +25,9 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from irpf90_t import * from .irpf90_t import *
from util import * from .util import *
import error from . import error
class Sub(object): class Sub(object):
@ -58,8 +58,8 @@ class Sub(object):
def doc(self): def doc(self):
if '_doc' not in self.__dict__: if '_doc' not in self.__dict__:
def f(l): return def f(l): return
buffer = filter(lambda l:type(l) == Doc, self.text) buffer = [l for l in self.text if type(l) == Doc]
self._doc = map(lambda l: l.text.lstrip()[1:], buffer) self._doc = [l.text.lstrip()[1:] for l in buffer]
if buffer == []: if buffer == []:
error.warn(None,"Subroutine %s is not documented"%(self.name)) error.warn(None,"Subroutine %s is not documented"%(self.name))
return self._doc return self._doc
@ -75,9 +75,9 @@ class Sub(object):
############################################################ ############################################################
def touches(self): def touches(self):
if '_touches' not in self.__dict__: if '_touches' not in self.__dict__:
from subroutines import subroutines from .subroutines import subroutines
self._touches = [] self._touches = []
for line in filter(lambda x: type(x) in [Touch, SoftTouch],self.text): for line in [x for x in self.text if type(x) in [Touch, SoftTouch]]:
self._touches += line.text.split()[1:] self._touches += line.text.split()[1:]
for sub in self.calls: for sub in self.calls:
if sub in subroutines: if sub in subroutines:
@ -89,7 +89,7 @@ class Sub(object):
############################################################ ############################################################
def needs(self): def needs(self):
if '_needs' not in self.__dict__: if '_needs' not in self.__dict__:
import parsed_text from . import parsed_text
self._needs = make_single(self._needs) self._needs = make_single(self._needs)
return self._needs return self._needs
needs = property(needs) needs = property(needs)
@ -97,7 +97,7 @@ class Sub(object):
############################################################ ############################################################
def to_provide(self): def to_provide(self):
if '_to_provide' not in self.__dict__: if '_to_provide' not in self.__dict__:
import parsed_text from . import parsed_text
return self._to_provide return self._to_provide
to_provide = property(to_provide) to_provide = property(to_provide)
@ -113,7 +113,7 @@ class Sub(object):
############################################################ ############################################################
def calls(self): def calls(self):
if '_calls' not in self.__dict__: if '_calls' not in self.__dict__:
buffer = filter(lambda x: type(x) == Call,self.text) buffer = [x for x in self.text if type(x) == Call]
self._calls = [] self._calls = []
for line in buffer: for line in buffer:
sub = line.text.split('(',1)[0].split()[1].lower() sub = line.text.split('(',1)[0].split()[1].lower()
@ -124,8 +124,8 @@ class Sub(object):
###################################################################### ######################################################################
if __name__ == '__main__': if __name__ == '__main__':
from preprocessed_text import preprocessed_text from .preprocessed_text import preprocessed_text
from variables import variables from .variables import variables
from subroutines import subroutines from .subroutines import subroutines
print map(lambda x: variables[x].needs, subroutines['full_ci'].needs) print([variables[x].needs for x in subroutines['full_ci'].needs])
print subroutines['full_ci'].calls print(subroutines['full_ci'].calls)

22
src/subroutines.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,14 +25,14 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from util import * from .util import *
from subroutine import * from .subroutine import *
from variables import variables from .variables import variables
from variable import Variable from .variable import Variable
from irpf90_t import * from .irpf90_t import *
def create_subroutines(): def create_subroutines():
from preprocessed_text import preprocessed_text from .preprocessed_text import preprocessed_text
result = {} result = {}
for filename, text in preprocessed_text: for filename, text in preprocessed_text:
buffer = [] buffer = []
@ -51,7 +51,7 @@ def create_subroutines():
return result return result
def create_called_by(subs,vars): def create_called_by(subs,vars):
for s in subs.values() + vars.values(): for s in list(subs.values()) + list(vars.values()):
if type(s) == Variable and s.same_as != s.name: if type(s) == Variable and s.same_as != s.name:
continue continue
for x in s.calls: for x in s.calls:
@ -60,7 +60,7 @@ def create_called_by(subs,vars):
except KeyError: except KeyError:
pass pass
for s in subs.values(): for s in list(subs.values()):
s.called_by = make_single(s.called_by) s.called_by = make_single(s.called_by)
s.called_by.sort() s.called_by.sort()
@ -68,5 +68,5 @@ subroutines = create_subroutines()
create_called_by(subroutines,variables) create_called_by(subroutines,variables)
if __name__ == '__main__': if __name__ == '__main__':
for v in subroutines.keys(): for v in list(subroutines.keys()):
print v print(v)

18
src/touches.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,20 +25,20 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from irpf90_t import * from .irpf90_t import *
from util import * from .util import *
from variables import variables from .variables import variables
from modules import modules from .modules import modules
FILENAME=irpdir+'irp_touches.irp.F90' FILENAME=irpdir+'irp_touches.irp.F90'
def create(): def create():
out = [] out = []
l = variables.keys() l = list(variables.keys())
l.sort l.sort
main_modules = filter(lambda x: modules[x].is_main, modules) main_modules = [x for x in modules if modules[x].is_main]
finalize = "subroutine irp_finalize_%s\n"%(irp_id) finalize = "subroutine irp_finalize_%s\n"%(irp_id)
for m in filter(lambda x: not modules[x].is_main, modules): for m in [x for x in modules if not modules[x].is_main]:
finalize += " use %s\n"%(modules[m].name) finalize += " use %s\n"%(modules[m].name)
for v in l: for v in l:
var = variables[v] var = variables[v]
@ -59,7 +59,7 @@ def create():
if out != []: if out != []:
out = map(lambda x: "%s\n"%(x),out) out = ["%s\n"%(x) for x in out]
out += finalize out += finalize

38
src/util.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -64,11 +64,11 @@ def build_dim_colons(v):
if d == []: if d == []:
return "" return ""
else: else:
x = map(lambda x: ":", d) x = [":" for x in d]
return "(%s)"%(','.join(x)) return "(%s)"%(','.join(x))
import error from . import error
def find_subname(line): def find_subname(line):
buffer = line.lower buffer = line.lower
if not buffer.endswith(')'): if not buffer.endswith(')'):
@ -83,7 +83,7 @@ def make_single(l):
d = {} d = {}
for x in l: for x in l:
d[x] = True d[x] = True
return d.keys() return list(d.keys())
def flatten(l): def flatten(l):
if type(l) == list: if type(l) == list:
@ -119,7 +119,7 @@ def put_info(text,filename):
assert type(text) == list assert type(text) == list
if len(text) > 0: if len(text) > 0:
assert type(text[0]) == tuple assert type(text[0]) == tuple
from irpf90_t import Line from .irpf90_t import Line
assert type(text[0][0]) == list assert type(text[0][0]) == list
assert isinstance(text[0][1], Line) assert isinstance(text[0][1], Line)
lenmax = 80 - len(filename) lenmax = 80 - len(filename)
@ -128,17 +128,17 @@ def put_info(text,filename):
line.text = format%(line.text.ljust(lenmax),line.filename,str(line.i)) line.text = format%(line.text.ljust(lenmax),line.filename,str(line.i))
return text return text
import cPickle as pickle import pickle as pickle
import os, sys import os, sys
def parallel_loop(f,source): def parallel_loop(f,source):
pidlist = range(NTHREADS) pidlist = list(range(NTHREADS))
src = [ [] for i in xrange(NTHREADS) ] src = [ [] for i in range(NTHREADS) ]
index = 0 index = 0
try: try:
source = map( lambda x: (len(x[1]),(x[0], x[1])), source ) source = [(len(x[1]),(x[0], x[1])) for x in source]
source.sort() source.sort()
source = map( lambda x: x[1], source ) source = [x[1] for x in source]
except: except:
pass pass
for i in source: for i in source:
@ -149,8 +149,8 @@ def parallel_loop(f,source):
thread_id = 0 thread_id = 0
fork = 1 fork = 1
r = range(0,NTHREADS) r = list(range(0,NTHREADS))
for thread_id in xrange(1,NTHREADS): for thread_id in range(1,NTHREADS):
r[thread_id], w = os.pipe() r[thread_id], w = os.pipe()
fork = os.fork() fork = os.fork()
if fork == 0: if fork == 0:
@ -173,7 +173,7 @@ def parallel_loop(f,source):
w.close() w.close()
os._exit(0) os._exit(0)
for i in xrange(1,NTHREADS): for i in range(1,NTHREADS):
result += pickle.load(r[i]) result += pickle.load(r[i])
r[i].close() r[i].close()
os.waitpid(pidlist[i],0)[1] os.waitpid(pidlist[i],0)[1]
@ -183,10 +183,10 @@ def parallel_loop(f,source):
if __name__ == '__main__': if __name__ == '__main__':
print "10",dimsize("10") #-> "10" print("10",dimsize("10")) #-> "10"
print "0:10",dimsize("0:10") # -> "11" print("0:10",dimsize("0:10")) # -> "11"
print "0:x",dimsize("0:x") # -> "x+1" print("0:x",dimsize("0:x")) # -> "x+1"
print "-3:x",dimsize("-3:x") # -> "x+1" print("-3:x",dimsize("-3:x")) # -> "x+1"
print "x:y",dimsize("x:y") # -> "y-x+1" print("x:y",dimsize("x:y")) # -> "y-x+1"
print "x:5",dimsize("x:5") # -> "y-x+1" print("x:5",dimsize("x:5")) # -> "y-x+1"

98
src/variable.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,10 +25,10 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from irpf90_t import * from .irpf90_t import *
from util import * from .util import *
import error from . import error
from command_line import command_line from .command_line import command_line
class Variable(object): class Variable(object):
@ -45,7 +45,7 @@ class Variable(object):
############################################################ ############################################################
def is_touched(self): def is_touched(self):
if '_is_touched' not in self.__dict__: if '_is_touched' not in self.__dict__:
from variables import variables from .variables import variables
result = self.is_read result = self.is_read
for i in self.children: for i in self.children:
if variables[i].is_touched: if variables[i].is_touched:
@ -66,7 +66,7 @@ class Variable(object):
############################################################ ############################################################
def is_written(self): def is_written(self):
if '_is_written' not in self.__dict__: if '_is_written' not in self.__dict__:
from variables import variables from .variables import variables
result = False result = False
for i in self.parents: for i in self.parents:
if variables[i].is_written: if variables[i].is_written:
@ -79,7 +79,7 @@ class Variable(object):
############################################################ ############################################################
def is_read(self): def is_read(self):
if '_is_read' not in self.__dict__: if '_is_read' not in self.__dict__:
from variables import variables from .variables import variables
result = False result = False
for i in self.parents: for i in self.parents:
if variables[i].is_read: if variables[i].is_read:
@ -118,8 +118,8 @@ dimension.
def doc(self): def doc(self):
if '_doc' not in self.__dict__: if '_doc' not in self.__dict__:
text = self.text text = self.text
buffer = filter(lambda l:type(l) == Doc, text) buffer = [l for l in text if type(l) == Doc]
self._doc = map(lambda l: l.text.lstrip()[1:], buffer) self._doc = [l.text.lstrip()[1:] for l in buffer]
if buffer == []: if buffer == []:
error.warn(None,"Variable %s is not documented"%(self.name)) error.warn(None,"Variable %s is not documented"%(self.name))
return self._doc return self._doc
@ -137,7 +137,7 @@ dimension.
if '_includes' not in self.__dict__: if '_includes' not in self.__dict__:
self._includes = [] self._includes = []
text = self.text text = self.text
for line in filter(lambda x: type(x) == Include,text): for line in [x for x in text if type(x) == Include]:
self._includes.append(line.filename) self._includes.append(line.filename)
make_single(self._includes) make_single(self._includes)
return self._includes return self._includes
@ -148,7 +148,7 @@ dimension.
if '_calls' not in self.__dict__: if '_calls' not in self.__dict__:
self._calls = [] self._calls = []
text = self.text text = self.text
for line in filter(lambda x: type(x) == Call,text): for line in [x for x in text if type(x) == Call]:
sub = line.text.split('(',1)[0].split()[1].lower() sub = line.text.split('(',1)[0].split()[1].lower()
self._calls.append(sub) self._calls.append(sub)
make_single(self._calls) make_single(self._calls)
@ -162,7 +162,7 @@ dimension.
append = result.append append = result.append
f = lambda l: type(l) in [Begin_provider, Cont_provider] f = lambda l: type(l) in [Begin_provider, Cont_provider]
text = self.text text = self.text
lines = filter(f, text) lines = list(filter(f, text))
for line in lines: for line in lines:
append(line.filename[1]) append(line.filename[1])
result.remove(self.name) result.remove(self.name)
@ -187,10 +187,10 @@ dimension.
if not self.is_main: if not self.is_main:
self._allocate = [] self._allocate = []
else: else:
from variables import variables from .variables import variables
def f(var): def f(var):
return variables[var].dim != [] return variables[var].dim != []
self._allocate = filter ( f, self.others + [self.name] ) self._allocate = list(filter ( f, self.others + [self.name] ))
return self._allocate return self._allocate
allocate = property(allocate) allocate = property(allocate)
@ -203,7 +203,7 @@ dimension.
self._dim = [] self._dim = []
else: else:
buffer = buffer[2].strip()[1:-1].split(',') buffer = buffer[2].strip()[1:-1].split(',')
self._dim = map(strip,buffer) self._dim = list(map(strip,buffer))
return self._dim return self._dim
dim = property(dim) dim = property(dim)
@ -243,7 +243,7 @@ dimension.
if '_line' not in self.__dict__: if '_line' not in self.__dict__:
f = lambda l: type(l) in [Begin_provider, Cont_provider] f = lambda l: type(l) in [Begin_provider, Cont_provider]
text = self.text text = self.text
lines = filter(f, text) lines = list(filter(f, text))
for line in lines: for line in lines:
buffer = line.filename[1] buffer = line.filename[1]
if self._name == buffer: if self._name == buffer:
@ -276,24 +276,24 @@ dimension.
if not self.is_main: if not self.is_main:
self._toucher = [] self._toucher = []
else: else:
from modules import modules from .modules import modules
from variables import variables from .variables import variables
if '_needed_by' not in self.__dict__: if '_needed_by' not in self.__dict__:
import parsed_text from . import parsed_text
parents = self.parents parents = self.parents
parents.sort() parents.sort()
mods = map(lambda x: variables[x].fmodule, parents) mods = [variables[x].fmodule for x in parents]
mods = make_single(mods)+[self.fmodule] mods = make_single(mods)+[self.fmodule]
name = self.name name = self.name
result = [ "subroutine touch_%s"%(name) ] result = [ "subroutine touch_%s"%(name) ]
result += map(lambda x: " Use %s"%(x),mods) result += [" Use %s"%(x) for x in mods]
result.append(" implicit none") result.append(" implicit none")
if command_line.do_debug: if command_line.do_debug:
length = str(len("touch_%s"%(name))) length = str(len("touch_%s"%(name)))
result += [ " character*(%s) :: irp_here = 'touch_%s'"%(length,name) ] result += [ " character*(%s) :: irp_here = 'touch_%s'"%(length,name) ]
if command_line.do_debug: if command_line.do_debug:
result += [ " call irp_enter(irp_here)" ] result += [ " call irp_enter(irp_here)" ]
result += map( lambda x: " %s_is_built = .False."%(x), parents) result += [" %s_is_built = .False."%(x) for x in parents]
result.append(" %s_is_built = .True."%(name)) result.append(" %s_is_built = .True."%(name))
if command_line.do_debug: if command_line.do_debug:
result.append(" call irp_leave(irp_here)") result.append(" call irp_leave(irp_here)")
@ -309,8 +309,8 @@ dimension.
if not command_line.do_openmp: if not command_line.do_openmp:
self._locker = [] self._locker = []
else: else:
from modules import modules from .modules import modules
from variables import variables from .variables import variables
name = self.name name = self.name
result = [ "subroutine irp_lock_%s(set)"%(name) ] result = [ "subroutine irp_lock_%s(set)"%(name) ]
result += [ " use omp_lib", result += [ " use omp_lib",
@ -348,8 +348,8 @@ dimension.
self._reader = [] self._reader = []
else: else:
if '_needs' not in self.__dict__: if '_needs' not in self.__dict__:
import parsed_text from . import parsed_text
from variables import variables from .variables import variables
name = self.name name = self.name
result = [ \ result = [ \
"subroutine reader_%s(irp_num)"%(name), "subroutine reader_%s(irp_num)"%(name),
@ -363,7 +363,7 @@ dimension.
result += [\ result += [\
" character*(%d) :: irp_here = 'reader_%s'"%(length,name), " character*(%d) :: irp_here = 'reader_%s'"%(length,name),
" call irp_enter(irp_here)" ] " call irp_enter(irp_here)" ]
result += map(lambda x: " call reader_%s(irp_num)"%(x),self.needs) result += [" call reader_%s(irp_num)"%(x) for x in self.needs]
result += [ \ result += [ \
" irp_is_open = .True.", " irp_is_open = .True.",
" irp_iunit = 9", " irp_iunit = 9",
@ -393,9 +393,9 @@ dimension.
if not self.is_main: if not self.is_main:
self._writer = [] self._writer = []
else: else:
from variables import variables from .variables import variables
if '_needs' not in self.__dict__: if '_needs' not in self.__dict__:
import parsed_text from . import parsed_text
name = self.name name = self.name
result = [ \ result = [ \
"subroutine writer_%s(irp_num)"%(name), "subroutine writer_%s(irp_num)"%(name),
@ -413,7 +413,7 @@ dimension.
" if (.not.%s_is_built) then"%(self.same_as), " if (.not.%s_is_built) then"%(self.same_as),
" call provide_%s"%(self.same_as), " call provide_%s"%(self.same_as),
" endif" ] " endif" ]
result += map(lambda x: " call writer_%s(irp_num)"%(x),self.needs) result += [" call writer_%s(irp_num)"%(x) for x in self.needs]
result += [ \ result += [ \
" irp_is_open = .True.", " irp_is_open = .True.",
" irp_iunit = 9", " irp_iunit = 9",
@ -464,8 +464,8 @@ dimension.
self._provider = [] self._provider = []
else: else:
if '_to_provide' not in self.__dict__: if '_to_provide' not in self.__dict__:
import parsed_text from . import parsed_text
from variables import variables, build_use, call_provides from .variables import variables, build_use, call_provides
name = self.name name = self.name
same_as = self.same_as same_as = self.same_as
@ -480,7 +480,7 @@ dimension.
return result+")'" return result+")'"
def check_dimensions(): def check_dimensions():
result = map(lambda x: "(%s>0)"%(dimsize(x)), self.dim) result = ["(%s>0)"%(dimsize(x)) for x in self.dim]
result = ".and.".join(result) result = ".and.".join(result)
result = " if (%s) then"%(result) result = " if (%s) then"%(result)
return result return result
@ -555,7 +555,7 @@ dimension.
if command_line.do_debug: if command_line.do_debug:
result.append(" call irp_enter(irp_here)") result.append(" call irp_enter(irp_here)")
result += call_provides(self.to_provide) result += call_provides(self.to_provide)
result += flatten( map(build_alloc,[self.same_as]+self.others) ) result += flatten( list(map(build_alloc,[self.same_as]+self.others)) )
result += [ " if (.not.%s_is_built) then"%(same_as), result += [ " if (.not.%s_is_built) then"%(same_as),
" call bld_%s"%(same_as), " call bld_%s"%(same_as),
" %s_is_built = .True."%(same_as), "" ] " %s_is_built = .True."%(same_as), "" ]
@ -576,8 +576,8 @@ dimension.
if not self.is_main: if not self.is_main:
self._builder = [] self._builder = []
else: else:
import parsed_text from . import parsed_text
from variables import build_use, call_provides from .variables import build_use, call_provides
for filename,buffer in parsed_text.parsed_text: for filename,buffer in parsed_text.parsed_text:
if self.line.filename[0].startswith(filename): if self.line.filename[0].startswith(filename):
break break
@ -591,7 +591,7 @@ dimension.
vars = [] vars = []
if inside: if inside:
text.append( (vars,line) ) text.append( (vars,line) )
text += map( lambda x: ([],Simple_line(line.i,x,line.filename)), call_provides(vars) ) text += [([],Simple_line(line.i,x,line.filename)) for x in call_provides(vars)]
if command_line.do_profile and type(line) == Begin_provider: if command_line.do_profile and type(line) == Begin_provider:
text.append( ( [], Declaration(line.i," double precision :: irp_rdtsc, irp_rdtsc1, irp_rdtsc2",line.filename) ) ) text.append( ( [], Declaration(line.i," double precision :: irp_rdtsc, irp_rdtsc1, irp_rdtsc2",line.filename) ) )
text.append( ( [], Simple_line(line.i," irp_rdtsc1 = irp_rdtsc()",line.filename) ) ) text.append( ( [], Simple_line(line.i," irp_rdtsc1 = irp_rdtsc()",line.filename) ) )
@ -602,9 +602,9 @@ dimension.
text = parsed_text.move_to_top(text,Declaration) text = parsed_text.move_to_top(text,Declaration)
text = parsed_text.move_to_top(text,Implicit) text = parsed_text.move_to_top(text,Implicit)
text = parsed_text.move_to_top(text,Use) text = parsed_text.move_to_top(text,Use)
text = map(lambda x: x[1], text) text = [x[1] for x in text]
# inside_omp = False # inside_omp = False
for line in filter(lambda x: type(x) not in [ Begin_doc, End_doc, Doc], text): for line in [x for x in text if type(x) not in [ Begin_doc, End_doc, Doc]]:
if type(line) == Begin_provider: if type(line) == Begin_provider:
result = [] result = []
if command_line.directives and command_line.inline in ["all","builders"]: if command_line.directives and command_line.inline in ["all","builders"]:
@ -642,9 +642,9 @@ dimension.
if '_children' not in self.__dict__: if '_children' not in self.__dict__:
if not self.is_main: if not self.is_main:
self._children = [] self._children = []
from variables import variables from .variables import variables
if '_needs' not in self.__dict__: if '_needs' not in self.__dict__:
import parsed_text from . import parsed_text
result = [] result = []
for x in self.needs: for x in self.needs:
result.append(x) result.append(x)
@ -664,9 +664,9 @@ dimension.
if not self.is_main: if not self.is_main:
self._parents = [] self._parents = []
else: else:
from variables import variables from .variables import variables
if '_needed_by' not in self.__dict__: if '_needed_by' not in self.__dict__:
import parsed_text from . import parsed_text
result = [] result = []
for x in self.needed_by: for x in self.needed_by:
result.append(x) result.append(x)
@ -682,8 +682,8 @@ dimension.
###################################################################### ######################################################################
if __name__ == '__main__': if __name__ == '__main__':
from preprocessed_text import preprocessed_text from .preprocessed_text import preprocessed_text
from variables import variables from .variables import variables
#for v in variables.keys(): #for v in variables.keys():
# print v # print v
def print_dot(x,done): def print_dot(x,done):
@ -692,11 +692,11 @@ if __name__ == '__main__':
for i in x.needs: for i in x.needs:
pair = (x.name, i) pair = (x.name, i)
if pair not in done: if pair not in done:
print "%s -> %s"%( x.name, i ) print("%s -> %s"%( x.name, i ))
done[pair] = None done[pair] = None
print_dot(variables[i],done) print_dot(variables[i],done)
print "digraph G { " print("digraph G { ")
# print_dot(variables['e_loc'], {}) # print_dot(variables['e_loc'], {})
print_dot(variables['psi_value'], {}) print_dot(variables['psi_value'], {})
print "}" print("}")

42
src/variables.py
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA
@ -25,14 +25,14 @@
# scemama@irsamc.ups-tlse.fr # scemama@irsamc.ups-tlse.fr
from variable import * from .variable import *
from irpf90_t import * from .irpf90_t import *
from command_line import command_line from .command_line import command_line
from util import * from .util import *
###################################################################### ######################################################################
def create_variables(): def create_variables():
from preprocessed_text import preprocessed_text from .preprocessed_text import preprocessed_text
result = {} result = {}
icount = 0 icount = 0
for filename, text in preprocessed_text: for filename, text in preprocessed_text:
@ -48,17 +48,17 @@ def create_variables():
icount += 1 icount += 1
v = Variable(buffer,icount) v = Variable(buffer,icount)
if v.name in result: if v.name in result:
print "Warning: Duplicate provider for %s in"%(v.name) print("Warning: Duplicate provider for %s in"%(v.name))
print "- ", v.line.filename[0], " line ", v.line.i print("- ", v.line.filename[0], " line ", v.line.i)
print "- ", result[v.name].line.filename[0], " line ", result[v.name].line.i print("- ", result[v.name].line.filename[0], " line ", result[v.name].line.i)
print "Choosing first version" print("Choosing first version")
result[v.name] = v result[v.name] = v
for other in v.others: for other in v.others:
if other in result: if other in result:
print "Warning: Duplicate provider for %s in"%(other) print("Warning: Duplicate provider for %s in"%(other))
print "- ", v.line.filename[0], " line ", v.line.i print("- ", v.line.filename[0], " line ", v.line.i)
print "- ", result[other].line.filename[0], " line ", result[other].line.i print("- ", result[other].line.filename[0], " line ", result[other].line.i)
print "Choosing first version" print("Choosing first version")
result[other] = Variable(buffer,icount,other) result[other] = Variable(buffer,icount,other)
buffer = [] buffer = []
return result return result
@ -67,16 +67,16 @@ variables = create_variables()
###################################################################### ######################################################################
def build_use(vars): def build_use(vars):
result = map(lambda x: " use %s"%(variables[x].fmodule), vars) result = [" use %s"%(variables[x].fmodule) for x in vars]
result = make_single(result) result = make_single(result)
return result return result
###################################################################### ######################################################################
def call_provides(vars,opt=False): def call_provides(vars,opt=False):
vars = make_single( map(lambda x: variables[x].same_as, vars) ) vars = make_single( [variables[x].same_as for x in vars] )
if opt: if opt:
all_children = flatten( map(lambda x: variables[x].children, vars )) all_children = flatten( [variables[x].children for x in vars])
vars = filter(lambda x: x not in all_children,vars) vars = [x for x in vars if x not in all_children]
def fun(x): def fun(x):
result = [] result = []
result += [ \ result += [ \
@ -87,10 +87,10 @@ def call_provides(vars,opt=False):
" endif" ] " endif" ]
return result return result
result = flatten ( map (fun, vars) ) result = flatten ( list(map (fun, vars)) )
return result return result
###################################################################### ######################################################################
if __name__ == '__main__': if __name__ == '__main__':
for v in variables.keys(): for v in list(variables.keys()):
print v print(v)

2
src/version.py
View File

@ -1 +1 @@
version = "1.7.6" version = "2.0.0"

2
src/vim.py
View File

@ -1,4 +1,4 @@
#/usr/bin/env python2 #/usr/bin/env python3
# IRPF90 is a Fortran90 preprocessor written in Python for programming using # IRPF90 is a Fortran90 preprocessor written in Python for programming using
# the Implicit Reference to Parameters (IRP) method. # the Implicit Reference to Parameters (IRP) method.
# Copyright (C) 2009 Anthony SCEMAMA # Copyright (C) 2009 Anthony SCEMAMA

2
tools/commit-msg
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
import os,sys import os,sys
ROOT = os.path.dirname(__file__)+'/../../' ROOT = os.path.dirname(__file__)+'/../../'

2
tools/post-commit
View File

@ -1,4 +1,4 @@
#!/usr/bin/env python2 #!/usr/bin/env python3
import os import os
ROOT = os.path.dirname(__file__)+'/../../' ROOT = os.path.dirname(__file__)+'/../../'