diff --git a/bin/irpf90_indent b/bin/irpf90_indent index 391d438..c190a00 100755 --- a/bin/irpf90_indent +++ b/bin/irpf90_indent @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA diff --git a/bin/irpman b/bin/irpman index ff21bc7..b83f060 100755 --- a/bin/irpman +++ b/bin/irpman @@ -37,7 +37,7 @@ case "$0" in echo "source " $0 fi else - exec python2 $(dirname $0)/../src/irpman.py $1 + exec python3 $(dirname $0)/../src/irpman.py $1 fi ;; diff --git a/bin/profile b/bin/profile index 94ebc71..5488b39 100755 --- a/bin/profile +++ b/bin/profile @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA diff --git a/example/Makefile b/example/Makefile index 3c4a2a1..754eba9 100644 --- a/example/Makefile +++ b/example/Makefile @@ -1,4 +1,4 @@ -IRPF90 = python2 ../src/irpf90.py -I input +IRPF90 = python3 ../src/irpf90.py -I input FC = ifort FCFLAGS= -O2 NINJA = diff --git a/packages/make_version.py b/packages/make_version.py index a979085..94b7e54 100755 --- a/packages/make_version.py +++ b/packages/make_version.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 import sys, os wd = os.path.abspath(os.path.dirname(__file__)) diff --git a/pip/irpman b/pip/irpman index da437cf..2860e65 100755 --- a/pip/irpman +++ b/pip/irpman @@ -28,7 +28,7 @@ function run () { -cat << EOF | exec python2 - $@ +cat << EOF | exec python3 - $@ import sys, os from irpf90_libs.irpf90_t import mandir diff --git a/src/checkpoint.py b/src/checkpoint.py index 7da4e9a..71dc6b9 100644 --- a/src/checkpoint.py +++ b/src/checkpoint.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,10 +25,10 @@ # scemama@irsamc.ups-tlse.fr -from irpf90_t import * -from util import * -from variables import variables -from modules import modules +from .irpf90_t import * +from .util import * +from .variables import variables +from .modules import modules CHECKPOINT_UNIT_NUMBER=63 @@ -36,10 +36,10 @@ FILENAME=irpdir+'irp_checkpoint.irp.F90' def create(): out_write = [ "subroutine irp_checkpoint_write" ] - l = variables.keys() + l = list(variables.keys()) l.sort - main_modules = filter(lambda x: modules[x].is_main, modules) - for m in filter(lambda x: not modules[x].is_main, modules): + main_modules = [x for x in modules if modules[x].is_main] + for m in [x for x in modules if not modules[x].is_main]: out_write += [ " use %s"%(modules[m].name) ] out_write += [ " implicit none" ] out_write += [ " integer, parameter :: iunit = %d"%(CHECKPOINT_UNIT_NUMBER) ] diff --git a/src/codelet.py b/src/codelet.py index 73f58fc..6216d45 100644 --- a/src/codelet.py +++ b/src/codelet.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -24,8 +24,8 @@ # 31062 Toulouse Cedex 4 # scemama@irsamc.ups-tlse.fr -from command_line import command_line -import irpf90_t +from .command_line import command_line +from . import irpf90_t def run(): template = """ diff --git a/src/command_line.py b/src/command_line.py index 5853297..db8ccbc 100644 --- a/src/command_line.py +++ b/src/command_line.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -26,7 +26,7 @@ import getopt, sys -from version import version +from .version import version import re description = "IRPF90 Fortran preprocessor." @@ -76,7 +76,7 @@ class CommandLine(object): for o,a in self.opts: if o in [ "-I", '--'+options['I'][0] ]: if len(a) < 1: - print "Error: -I option needs a directory" + print("Error: -I option needs a directory") if a[-1] != '/': a = a+'/' self._include_dir.append(a) @@ -116,12 +116,12 @@ class CommandLine(object): elif len(buffer) == 3: self._codelet = [buffer[0], int(buffer[2]), buffer[1], filename] else: - print """ + print(""" Error in codelet definition. Use: --codelet=provider:NMAX or --codelet=provider:precondition:NMAX -""" +""") sys.exit(1) return self._codelet codelet = property(fget=codelet) @@ -209,11 +209,11 @@ Options: """ t = t.replace("$EXE",self.executable_name) t = t.replace("$DESCR",description) - print t + print(t) print_options() - print "" - print "Version : ", version - print "" + print("") + print("Version : ", version) + print("") def opts(self): if self._opts is None: @@ -228,10 +228,10 @@ Options: try: 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: 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) return self._opts @@ -250,7 +250,7 @@ do_$LONG = property(fget=do_$LONG) """ for short in options: 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): if '_do_run' not in self.__dict__: @@ -267,7 +267,7 @@ do_$LONG = property(fget=do_$LONG) command_line = CommandLine() def print_options(): - keys = options.keys() + keys = list(options.keys()) keys.sort() import subprocess for k in keys: @@ -275,8 +275,8 @@ def print_options(): p1 = subprocess.Popen(["fold", "-s", "-w", "40"],stdout=subprocess.PIPE,stdin=subprocess.PIPE) description = p1.communicate(description)[0] description = description.replace('\n','\n'.ljust(27)) - print ("-%s, --%s"%(k,options[k][0])).ljust(25), description+'\n' - print "\n" + print(("-%s, --%s"%(k,options[k][0])).ljust(25), description+'\n') + print("\n") if __name__ == '__main__': print_options() diff --git a/src/create_man.py b/src/create_man.py index 6026018..5d2102c 100644 --- a/src/create_man.py +++ b/src/create_man.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,22 +25,22 @@ # scemama@irsamc.ups-tlse.fr -from variable import Variable -from variables import variables -from subroutine import Sub -from subroutines import subroutines -from irpf90_t import * -from util import * +from .variable import Variable +from .variables import variables +from .subroutine import Sub +from .subroutines import subroutines +from .irpf90_t import * +from .util import * def do_print_short(file,var): """Makes a short print, as in irpf90_entities""" assert type(var) == Variable - print >>file, "%s : %s :: %s %s"%( \ + print("%s : %s :: %s %s"%( \ var.line.filename[0].ljust(35), var.type.ljust(30), var.name.ljust(25), - build_dim(var.dim) ) + build_dim(var.dim) ), file=file) ###################################################################### def process_doc(file,line): @@ -48,13 +48,13 @@ def process_doc(file,line): line = line.strip() if line == "": line = ".br" - print >>file, line + print(line, file=file) ###################################################################### def process_deps(file,l): assert type(l) == list for v in l: - print >>file, "%s\n.br"%(v,) + print("%s\n.br"%(v,), file=file) ###################################################################### def process_types(file,var): @@ -65,7 +65,7 @@ def process_types(file,var): var = variables[var] Type = var.type 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): @@ -73,32 +73,32 @@ def do_print(var): filename = var.line.filename[0] name = var.name 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: var = variables[var.same_as] - print >>file, ".SH Declaration" - print >>file, ".nf" + print(".SH Declaration", file=file) + print(".nf", file=file) process_types(file,var) - print >>file, ".ni" + print(".ni", file=file) if var.doc != []: - print >>file, ".SH Description" + print(".SH Description", file=file) for l in var.doc: process_doc(file,l) - print >>file, ".SH File\n.P" - print >>file, filename + print(".SH File\n.P", file=file) + print(filename, file=file) if var.needs != []: var.needs.sort() - print >>file, ".SH Needs" + print(".SH Needs", file=file) process_deps(file,var.needs) if var.needed_by != []: var.needed_by.sort() - print >>file, ".SH Needed by" + print(".SH Needed by", file=file) process_deps(file,var.needed_by) - print >>file, ".SH Instability factor" + print(".SH Instability factor", file=file) fo = len(var.children) fi = len(var.parents) - print >>file, "%5.1f %%"%(100.* (fi / (fi+fo+.000001) )) - print >>file, ".br" + print("%5.1f %%"%(100.* (fi / (fi+fo+.000001) )), file=file) + print(".br", file=file) file.close() ###################################################################### @@ -108,12 +108,12 @@ def do_print_rst(var): filename = var.line.filename[0] name = var.name file = open("%s%s.rst"%(mandir,var.name), "w") - print >>file, ".. c:var:: %s\n"%(var.name.lower()) - print >>file, "" - print >>file, " File : :file:`"+filename+"`" - print >>file, "" - print >>file, " .. code:: fortran" - print >>file, "" + print(".. c:var:: %s\n"%(var.name.lower()), file=file) + print("", file=file) + print(" File : :file:`"+filename+"`", file=file) + print("", file=file) + print(" .. code:: fortran", file=file) + print("", file=file) if var.same_as != var.name: var = variables[var.same_as] for v in [var.name] + var.others: @@ -121,9 +121,9 @@ def do_print_rst(var): v = variables[v] Type = v.type dim = build_dim(v.dim) - print >>file, " %s\t:: %s\t%s"%(Type,name,dim) - print >>file, "" - print >>file, "" + print(" %s\t:: %s\t%s"%(Type,name,dim), file=file) + print("", file=file) + print("", file=file) if var.doc != []: d = [] @@ -146,33 +146,33 @@ def do_print_rst(var): if loop: d = [ l[1:] for l in d ] for line in d: - print >>file, " "+line - print >>file, "" + print(" "+line, file=file) + print("", file=file) if var.needs != []: var.needs.sort() - print >>file, " Needs:" - print >>file, "" - print >>file, " .. hlist::" - print >>file, " :columns: 3" - print >>file, "" + print(" Needs:", file=file) + print("", file=file) + print(" .. hlist::", file=file) + print(" :columns: 3", file=file) + print("", file=file) for v in var.needs: - print >>file, " * :c:data:`%s`"%(variables[v].same_as.lower(),) - print >>file, "" + print(" * :c:data:`%s`"%(variables[v].same_as.lower(),), file=file) + print("", file=file) if var.needed_by != []: var.needed_by.sort() - print >>file, " Needed by:" - print >>file, "" - print >>file, " .. hlist::" - print >>file, " :columns: 3" - print >>file, "" + print(" Needed by:", file=file) + print("", file=file) + print(" .. hlist::", file=file) + print(" :columns: 3", file=file) + print("", file=file) for v in var.needed_by: - print >>file, " * :c:data:`%s`"%(variables[v].same_as.lower(),) - print >>file, "" + print(" * :c:data:`%s`"%(variables[v].same_as.lower(),), file=file) + print("", file=file) file.close() ###################################################################### 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: ###################################################################### @@ -181,38 +181,38 @@ def do_print_subroutines(sub): filename = sub.line.filename name = sub.name file = open("%s%s.l"%(mandir,sub.name), "w") - print >>file, '.TH "IRPF90 entities" l %s "IRPF90 entities" %s'%(name,name) - print >>file, ".SH Declaration" - print >>file, ".nf" + print('.TH "IRPF90 entities" l %s "IRPF90 entities" %s'%(name,name), file=file) + print(".SH Declaration", file=file) + print(".nf", file=file) process_declaration_subroutine(file,sub) - print >>file, ".ni" + print(".ni", file=file) if sub.doc != []: - print >>file, ".SH Description" + print(".SH Description", file=file) for l in sub.doc: process_doc(file,l) - print >>file, ".SH File\n.P" - print >>file, filename + print(".SH File\n.P", file=file) + print(filename, file=file) if sub.needs != []: sub.needs.sort() - print >>file, ".SH Needs" + print(".SH Needs", file=file) process_deps(file,sub.needs) if sub.called_by != []: sub.called_by.sort() - print >>file, ".SH Called by" + print(".SH Called by", file=file) process_deps(file,sub.called_by) if sub.calls != []: sub.calls.sort() - print >>file, ".SH Calls" + print(".SH Calls", file=file) process_deps(file,sub.calls) if sub.touches != []: sub.touches.sort() - print >>file, ".SH Touches" + print(".SH Touches", file=file) 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) fi = len(sub.called_by) - print >>file, "%5.1f %%"%(100.* (fi / (fi+fo+.000001) )) - print >>file, ".br" + print("%5.1f %%"%(100.* (fi / (fi+fo+.000001) )), file=file) + print(".br", file=file) file.close() ###################################################################### @@ -222,15 +222,15 @@ def do_print_subroutines_rst(sub): filename = sub.line.filename name = sub.name file = open("%s%s.rst"%(mandir,sub.name), "w") - print >>file, ".. c:function:: %s:\n"%(sub.name.lower()) - print >>file, "" - print >>file, " File : :file:`"+filename+"`" - print >>file, "" - print >>file, " .. code:: fortran" - print >>file, "" - print >>file, " "+sub.line.text.split('!')[0].strip() - print >>file, "" - print >>file, "" + print(".. c:function:: %s:\n"%(sub.name.lower()), file=file) + print("", file=file) + print(" File : :file:`"+filename+"`", file=file) + print("", file=file) + print(" .. code:: fortran", file=file) + print("", file=file) + print(" "+sub.line.text.split('!')[0].strip(), file=file) + print("", file=file) + print("", file=file) if sub.doc != []: d = list(sub.doc) loop = True @@ -246,63 +246,63 @@ def do_print_subroutines_rst(sub): if loop: d = [ l[1:] for l in d ] for l in d: - print >>file, " "+l - print >>file, "" + print(" "+l, file=file) + print("", file=file) if sub.needs != []: sub.needs.sort() - print >>file, " Needs:" - print >>file, "" - print >>file, " .. hlist::" - print >>file, " :columns: 3" - print >>file, "" + print(" Needs:", file=file) + print("", file=file) + print(" .. hlist::", file=file) + print(" :columns: 3", file=file) + print("", file=file) for v in sub.needs: - print >>file, " * :c:data:`%s`"%(variables[v].same_as.lower(),) - print >>file, "" + print(" * :c:data:`%s`"%(variables[v].same_as.lower(),), file=file) + print("", file=file) if sub.called_by != []: sub.called_by.sort() - print >>file, " Called by:" - print >>file, "" - print >>file, " .. hlist::" - print >>file, " :columns: 3" - print >>file, "" + print(" Called by:", file=file) + print("", file=file) + print(" .. hlist::", file=file) + print(" :columns: 3", file=file) + print("", file=file) for v in sub.called_by: if v in subroutines: - print >>file, " * :c:func:`%s`"%(v.lower(),) + print(" * :c:func:`%s`"%(v.lower(),), file=file) elif v in variables: - print >>file, " * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),) - print >>file, "" + print(" * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),), file=file) + print("", file=file) if sub.calls != []: sub.calls.sort() - print >>file, " Calls:" - print >>file, "" - print >>file, " .. hlist::" - print >>file, " :columns: 3" - print >>file, "" + print(" Calls:", file=file) + print("", file=file) + print(" .. hlist::", file=file) + print(" :columns: 3", file=file) + print("", file=file) for v in sub.calls: - print >>file, " * :c:func:`%s`"%(v.lower(),) - print >>file, "" + print(" * :c:func:`%s`"%(v.lower(),), file=file) + print("", file=file) if sub.touches != []: sub.touches.sort() - print >>file, " Touches:" - print >>file, "" - print >>file, " .. hlist::" - print >>file, " :columns: 3" - print >>file, "" + print(" Touches:", file=file) + print("", file=file) + print(" .. hlist::", file=file) + print(" :columns: 3", file=file) + print("", file=file) for v in sub.touches: - print >>file, " * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),) - print >>file, "" + print(" * :c:data:`%s`"%(variables[v.lower()].same_as.lower(),), file=file) + print("", file=file) file.close() ###################################################################### def run(): - import parsed_text + from . import parsed_text import os,sys pid1 = os.fork() if pid1 == 0: - for v in variables.values(): + for v in list(variables.values()): do_print(v) do_print_rst(v) - for s in subroutines.values(): + for s in list(subroutines.values()): do_print_subroutines(s) do_print_subroutines_rst(s) sys.exit(0) @@ -310,7 +310,7 @@ def run(): pid2 = os.fork() if pid2 == 0: tags = [] - l = variables.keys() + l = list(variables.keys()) file = open("irpf90_entities","w") l.sort() for v in l: @@ -318,7 +318,7 @@ def run(): line = variables[v].line tags.append( '%s\t%s\t%d\n'%(v,line.filename[0],line.i) ) file.close() - l = subroutines.keys() + l = list(subroutines.keys()) for v in l: line = subroutines[v].line tags.append('%s\t%s\t%d\n'%(v,line.filename,line.i)) diff --git a/src/error.py b/src/error.py index 00c70c1..907b34b 100644 --- a/src/error.py +++ b/src/error.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -26,20 +26,20 @@ import sys -from irpf90_t import * -from command_line import command_line +from .irpf90_t import * +from .command_line import command_line do_warnings = command_line.do_warnings ###################################################################### def fail(line,message): - print """ + print(""" Error: ----- -""" - print message, '\n' +""") + print(message, '\n') if line is not None: 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) @@ -49,14 +49,14 @@ def warn(line,message): return if line is not None: assert isinstance(line,Line) - print """ + print(""" Warning: ------- -""" - print message, '\n' - print "file %s, line %d:\n %s"%(line.filename,line.i,line.text) +""") + print(message, '\n') + print("file %s, line %d:\n %s"%(line.filename,line.i,line.text)) else: - print "Warning: %s"%(message) + print("Warning: %s"%(message)) ###################################################################### diff --git a/src/init.py b/src/init.py index b667057..df50e02 100644 --- a/src/init.py +++ b/src/init.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -27,10 +27,10 @@ import os -import util -import makefile -import irpf90_t -from command_line import command_line +from . import util +from . import makefile +from . import irpf90_t +from .command_line import command_line initialized = False @@ -67,7 +67,7 @@ def init(): try: os.stat(dir) except: - print dir,'not in dir' + print(dir,'not in dir') continue for filename in os.listdir(dir): filename = dir+filename @@ -76,7 +76,7 @@ def init(): file = open(filename,"r") except IOError: if command_line.do_warnings: - print "Warning : Unable to read file %s."%(filename) + print("Warning : Unable to read file %s."%(filename)) else: buffer = file.read() file.close() diff --git a/src/irp_stack.py b/src/irp_stack.py index ee08f88..00bb755 100644 --- a/src/irp_stack.py +++ b/src/irp_stack.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,14 +25,14 @@ # scemama@irsamc.ups-tlse.fr -import util -from command_line import command_line +from . import util +from .command_line import command_line do_debug = command_line.do_debug do_openmp = command_line.do_openmp do_memory = command_line.do_memory -import irpf90_t +from . import irpf90_t FILENAME = irpf90_t.irpdir+"irp_stack.irp.F90" @@ -149,7 +149,7 @@ end subroutine """ 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): file = open(FILENAME,'w') file.writelines(txt) diff --git a/src/irpf90.py b/src/irpf90.py index 2fee5b8..eefe779 100644 --- a/src/irpf90.py +++ b/src/irpf90.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -26,7 +26,7 @@ -import vim +from . import vim import os,sys try: wd = os.path.abspath(os.path.dirname(__file__)) @@ -35,7 +35,7 @@ except: pass sys.setcheckinterval(1000) -from command_line import command_line +from .command_line import command_line def main(): @@ -45,33 +45,33 @@ def main(): command_line.usage() if command_line.do_version: - from version import version - print version + from .version import version + print(version) - from init import init + from .init import init if command_line.do_init: init() if command_line.do_preprocess: init() - from preprocessed_text import preprocessed_text + from .preprocessed_text import preprocessed_text for filename,text in preprocessed_text: if filename in command_line.preprocessed: for line in text: - print line.text + print(line.text) if command_line.do_touch: - from variables import variables + from .variables import variables for var in command_line.touched: if var not in variables: - print "%s is not an IRP entity"%(var,) + print("%s is not an IRP entity"%(var,)) else: - print "Touching %s invalidates the following entities:"%(var,) + print("Touching %s invalidates the following entities:"%(var,)) parents = variables[var].parents parents.sort() for x in parents: - print "- %s"%(x,) + print("- %s"%(x,)) if not command_line.do_run: @@ -79,39 +79,39 @@ def main(): init() - import irp_stack + from . import irp_stack irp_stack.create() - import makefile + from . import makefile makefile.create() if command_line.do_codelet: - import profile + from . import profile profile.build_rdtsc() - import codelet + from . import codelet codelet.run() - from modules import modules, write_module - for m in modules.keys(): + from .modules import modules, write_module + for m in list(modules.keys()): write_module(modules[m]) makefile.run() - import touches + from . import touches touches.create() # import checkpoint # checkpoint.create() - import create_man + from . import create_man create_man.run() if command_line.do_profile: - import profile + from . import profile profile.run() if command_line.do_openmp: - import locks + from . import locks locks.create() if __name__ == '__main__': diff --git a/src/irpf90_indent.py b/src/irpf90_indent.py index 04b23cc..d8ab2c0 100755 --- a/src/irpf90_indent.py +++ b/src/irpf90_indent.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -169,21 +169,21 @@ class indent(object): line = self.format_continuation(line,k) 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 if grep.begin_subroutine(line): - print line + print(line) k = indent0+tab continue if grep.begin_function(line): - print line + print(line) k = indent0+tab continue if grep.begin_program(line): - print line + print(line) k = indent0+tab continue @@ -191,76 +191,76 @@ class indent(object): if line[0] != '&': k = indent0+tab if grep.begin_provider(self.text[i+1].strip()): - print " "+line + print(" "+line) else: - print line + print(line) else: - print line + print(line) continue if grep.declaration(line): - print k+self.format_declaration(line,30) + print(k+self.format_declaration(line,30)) continue if grep.begin_do(line): - print k+line + print(k+line) k += tab continue if grep.begin_if(line): - print k+line + print(k+line) k += tab continue if grep.xelse(line): - print k[:-tabn]+line + print(k[:-tabn]+line) continue if grep.begin_select(line): - print k+line + print(k+line) k += 2*tab continue if grep.case(line): - print k[:-tabn]+line + print(k[:-tabn]+line) continue if grep.end_do(line): k = k[:-tabn] - print k+line + print(k+line) continue if grep.end_if(line): k = k[:-tabn] - print k+line + print(k+line) continue if grep.end_select(line): k = k[:-2*tabn] - print k+line + print(k+line) continue if grep.end_subroutine(line): - print line + print(line) k = indent0 continue if grep.end_function(line): - print line + print(line) k = indent0 continue if grep.end_provider(line): - print line + print(line) k = indent0 continue if grep.end_program(line): - print line + print(line) k = indent0 continue - print k+line + print(k+line) def main(): diff --git a/src/irpf90_python.exe b/src/irpf90_python.exe index c613031..2d0e12f 100755 --- a/src/irpf90_python.exe +++ b/src/irpf90_python.exe @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA diff --git a/src/irpf90_t.py b/src/irpf90_t.py index 77a67be..c372d72 100644 --- a/src/irpf90_t.py +++ b/src/irpf90_t.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -387,15 +387,15 @@ class Provide_all (Line): def create_irpf90_files(): result = [] - from command_line import command_line + from .command_line import command_line import os def is_irpf90_file(filename): 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: try: 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: continue if command_line.do_codelet: diff --git a/src/irpman.py b/src/irpman.py index 0002896..06cbfd9 100755 --- a/src/irpman.py +++ b/src/irpman.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -29,10 +29,10 @@ import os import sys wd = os.path.abspath(os.path.dirname(__file__)) -from irpf90_t import mandir +from .irpf90_t import mandir filename = sys.argv[1].lower()+".l" 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) os.system("man ./"+mandir+sys.argv[1].lower()+".l") diff --git a/src/locks.py b/src/locks.py index 346907d..b7c57bf 100644 --- a/src/locks.py +++ b/src/locks.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,16 +25,16 @@ # scemama@irsamc.ups-tlse.fr -from command_line import command_line +from .command_line import command_line -from irpf90_t import * -from util import * -from variables import variables +from .irpf90_t import * +from .util import * +from .variables import variables FILENAME=irpdir+'irp_locks.irp.F90' def create(): out = [] - l = variables.keys() + l = list(variables.keys()) l.sort for v in l: var = variables[v] @@ -47,7 +47,7 @@ def create(): out += [ " call irp_lock_%s(.True.)"%v ] out += [ " call irp_lock_%s(.False.)"%v ] 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): file = open(FILENAME,'w') file.writelines(out) diff --git a/src/makefile.py b/src/makefile.py index 2b69a0f..d9c83ca 100644 --- a/src/makefile.py +++ b/src/makefile.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -26,8 +26,8 @@ import os,sys -import irpf90_t -from command_line import command_line +from . import irpf90_t +from .command_line import command_line irpdir = irpf90_t.irpdir mandir = irpf90_t.mandir @@ -82,14 +82,14 @@ def create_gitignore(): ###################################################################### def run_ninja(): - import ninja + from . import ninja ninja.run() ###################################################################### def run_make(): - from modules import modules + from .modules import modules mod = [] - for m in modules.values(): + for m in list(modules.values()): mod.append(m) file = open(IRPF90_MAKE,'w') @@ -108,41 +108,41 @@ def run_make(): for m in mod: result += " %s%s.irp.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) for m in mod: if not m.is_main: result += " %s%s.irp.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), 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: - print >>file, " irp_rdtsc.o", + print(" irp_rdtsc.o", end=' ', file=file) if command_line.do_openmp: - print >>file, " %sirp_locks.irp.o"%(irpdir) + print(" %sirp_locks.irp.o"%(irpdir), file=file) else: - print >>file, "" + print("", file=file) - all = filter(lambda x: modules[x].is_main, modules) - all = map(lambda x: x[:-6], all) - all_o = map(lambda x: "%s.irp.module.o %s.irp.o"%(x,x), all) - print >>file, "ALL = %s"%(" ".join(all)) - print >>file, "ALL_OBJ = %s"%(" ".join(all_o)) - print >>file, "ALL_OBJ1 = $(patsubst %%, %s%%,$(notdir $(ALL_OBJ)))"%(irpdir) - print >>file, "all:$(ALL)" - print >>file, "\t@$(MAKE) -s move" + all = [x for x in modules if modules[x].is_main] + all = [x[:-6] for x in all] + all_o = ["%s.irp.module.o %s.irp.o"%(x,x) for x in all] + print("ALL = %s"%(" ".join(all)), file=file) + print("ALL_OBJ = %s"%(" ".join(all_o)), file=file) + print("ALL_OBJ1 = $(patsubst %%, %s%%,$(notdir $(ALL_OBJ)))"%(irpdir), file=file) + print("all:$(ALL)", file=file) + print("\t@$(MAKE) -s move", file=file) # print >>file, "ifdef USE_IRPF90_A" for m in mod: if m.is_main: 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 >>file, "\t$(FC) -o $@ %s$@.irp.o %s$@.irp.module.o IRPF90_temp/irpf90.a $(LIB)"%(irpdir,irpdir) - print >>file, "\t@$(MAKE) -s move" + print("%s: %s%s.irp.o %s%s.irp.module.o IRPF90_temp/irpf90.a"%(exe,irpdir,exe,irpdir,exe), file=file) + print("\t$(FC) -o $@ %s$@.irp.o %s$@.irp.module.o IRPF90_temp/irpf90.a $(LIB)"%(irpdir,irpdir), file=file) + print("\t@$(MAKE) -s move", file=file) # print >>file, "else" # for m in mod: # if m.is_main: @@ -155,43 +155,43 @@ def run_make(): buffer = "" for m in mod: 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_files = map(lambda x: modules[x].filename, needed_modules) - mds = map (lambda x: " %s%s.irp.module.o"%(irpdir,x),needed_files) - print >>file, filename," ".join(mds)," ".join(m.includes) + needed_modules = [x for x in modules if modules[x].name in m.needed_modules] + needed_files = [modules[x].filename for x in needed_modules] + mds = [" %s%s.irp.module.o"%(irpdir,x) for x in needed_files] + print(filename," ".join(mds)," ".join(m.includes), file=file) if not m.is_main: 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: $(OBJ) "%(irpdir), - mds = filter(lambda x: not x.is_main,mod) - mds = map(lambda x: " %s%s.irp.o %s%s.irp.o"%(irpdir,x.filename,irpdir,x.filename),mds) - print >>file," ".join(mds) + print("%sirp_touches.irp.o: $(OBJ) "%(irpdir), end=' ', file=file) + mds = [x for x in mod if not x.is_main] + mds = [" %s%s.irp.o %s%s.irp.o"%(irpdir,x.filename,irpdir,x.filename) for x in mds] + print(" ".join(mds), file=file) if command_line.do_profile: - print >>file, "%sirp_profile.irp.o:"%(irpdir), - print >>file," ".join(mds) + print("%sirp_profile.irp.o:"%(irpdir), end=' ', file=file) + print(" ".join(mds), file=file) if command_line.do_openmp: - print >>file, "%sirp_locks.irp.o:"%(irpdir), - print >>file," ".join(mds) + print("%sirp_locks.irp.o:"%(irpdir), end=' ', file=file) + print(" ".join(mds), file=file) - for dir in [ irpdir ] + map(lambda x: irpdir+x, command_line.include_dir): - print >>file, dir+"%.irp.module.o: $(OBJ) "+dir+"%.irp.module.F90" - print >>file, "\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.module.F90 -o "+dir+"$*.irp.module.o" - print >>file, dir+"%.irp.o: $(OBJ) "+dir+"%.irp.module.o "+dir+"%.irp.F90" - print >>file, "\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o" - print >>file, dir+"%.irp.o: $(OBJ) "+dir+"%.irp.F90" - print >>file, "\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o" - print >>file, dir+"%.o: %.F90" - print >>file, "\t$(FC) $(FCFLAGS) -c $*.F90 -o "+dir+"$*.o" - print >>file, dir+"%.o: %.f90\n\t$(FC) $(FCFLAGS) -c $*.f90 -o "+dir+"$*.o" - print >>file, dir+"%.o: %.f\n\t$(FC) $(FCFLAGS) -c $*.f -o "+dir+"$*.o" - print >>file, dir+"%.o: %.F\n\t$(FC) $(FCFLAGS) -c $*.F -o "+dir+"$*.o" - print >>file, dir+"%.irp.F90: "+IRPF90_MAKE+"\n" - print >>file, "move:\n\t@mv -f *.mod IRPF90_temp/ 2> /dev/null | DO_NOTHING=\n" - print >>file, "IRPF90_temp/irpf90.a: $(OBJ) $(OBJ1)\n\t$(AR) crf IRPF90_temp/irpf90.a $(OBJ1)\n" - print >>file, "clean:\n\trm -rf $(EXE) $(OBJ1) IRPF90_temp/irpf90.a $(ALL_OBJ1) $(ALL)\n" - print >>file, "veryclean:\n\t- $(MAKE) clean\n" - print >>file, "\t- rm -rf "+irpdir+" "+mandir+" "+IRPF90_MAKE+" irpf90_entities dist tags\n" + for dir in [ irpdir ] + [irpdir+x for x in command_line.include_dir]: + print(dir+"%.irp.module.o: $(OBJ) "+dir+"%.irp.module.F90", file=file) + print("\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.module.F90 -o "+dir+"$*.irp.module.o", file=file) + print(dir+"%.irp.o: $(OBJ) "+dir+"%.irp.module.o "+dir+"%.irp.F90", file=file) + print("\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o", file=file) + print(dir+"%.irp.o: $(OBJ) "+dir+"%.irp.F90", file=file) + print("\t$(FC) $(FCFLAGS) -c "+dir+"$*.irp.F90 -o "+dir+"$*.irp.o", file=file) + print(dir+"%.o: %.F90", file=file) + print("\t$(FC) $(FCFLAGS) -c $*.F90 -o "+dir+"$*.o", file=file) + print(dir+"%.o: %.f90\n\t$(FC) $(FCFLAGS) -c $*.f90 -o "+dir+"$*.o", file=file) + print(dir+"%.o: %.f\n\t$(FC) $(FCFLAGS) -c $*.f -o "+dir+"$*.o", file=file) + print(dir+"%.o: %.F\n\t$(FC) $(FCFLAGS) -c $*.F -o "+dir+"$*.o", file=file) + print(dir+"%.irp.F90: "+IRPF90_MAKE+"\n", file=file) + print("move:\n\t@mv -f *.mod IRPF90_temp/ 2> /dev/null | DO_NOTHING=\n", file=file) + print("IRPF90_temp/irpf90.a: $(OBJ) $(OBJ1)\n\t$(AR) crf IRPF90_temp/irpf90.a $(OBJ1)\n", file=file) + print("clean:\n\trm -rf $(EXE) $(OBJ1) IRPF90_temp/irpf90.a $(ALL_OBJ1) $(ALL)\n", file=file) + print("veryclean:\n\t- $(MAKE) clean\n", file=file) + print("\t- rm -rf "+irpdir+" "+mandir+" "+IRPF90_MAKE+" irpf90_entities dist tags\n", file=file) file.close() diff --git a/src/module.py b/src/module.py index 3a76f96..55f7d85 100644 --- a/src/module.py +++ b/src/module.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,12 +25,12 @@ # scemama@irsamc.ups-tlse.fr -from irpf90_t import * -from variable import * -from variables import variables -from command_line import command_line -import preprocessed_text -from util import * +from .irpf90_t import * +from .variable import * +from .variables import variables +from .command_line import command_line +from . import preprocessed_text +from .util import * class Fmodule(object): @@ -57,7 +57,7 @@ class Fmodule(object): def prog_name(self): 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 == []: self._prog_name = None else: @@ -67,9 +67,9 @@ class Fmodule(object): def variables(self): if '_variables' not in self.__dict__: - from variables import variables + from .variables import variables 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 variables = property(variables) @@ -79,7 +79,7 @@ class Fmodule(object): result = [ "module %s"%(self.name) ] result += self.use 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) ) self._head = result return self._head @@ -87,7 +87,7 @@ class Fmodule(object): def needed_vars(self): 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) ) self._needed_vars = result return self._needed_vars @@ -119,8 +119,8 @@ class Fmodule(object): def residual_text(self): if '_residual_text' not in self.__dict__: - from variables import build_use, call_provides - from parsed_text import move_to_top + from .variables import build_use, call_provides + from .parsed_text import move_to_top def remove_providers(text): result = [] inside = False @@ -140,7 +140,7 @@ class Fmodule(object): if type(line) in [ Subroutine, Function ]: variable_list = list(vars) 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: variable_list += vars result.append( (vars,line) ) @@ -169,21 +169,21 @@ class Fmodule(object): result = [] for vars,line in text: 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 result = remove_providers(self.text) result = modify_functions(result) use,dec,result = extract_use_dec_text(result) - self._use = make_single(map(lambda x: " "+x[1].text, use)) - self._dec = map(lambda x: " "+x[1].text, dec) + self._use = make_single([" "+x[1].text for x in use]) + self._dec = [" "+x[1].text for x in dec] # self._dec = make_single(map(lambda x: " "+x[1].text, dec)) result = provide_variables(result) result = move_to_top(result,Declaration) result = move_to_top(result,Implicit) result = move_to_top(result,Use) - result = map(lambda x: x[1], result) - result = map(lambda x: x.text, result) + result = [x[1] for x in result] + result = [x.text for x in result] self._residual_text = result return self._residual_text residual_text = property(residual_text) @@ -203,10 +203,9 @@ class Fmodule(object): def needed_modules(self): if '_needed_modules' not in self.__dict__: - buffer = filter(lambda x: x.lstrip().startswith("use "), \ - self.generated_text+self.head+self.residual_text) - buffer = map(lambda x: x.split()[1], buffer) - buffer = filter(lambda x: x.endswith("_mod"),buffer ) + buffer = [x for x in self.generated_text+self.head+self.residual_text if x.lstrip().startswith("use ")] + buffer = [x.split()[1] for x in buffer] + buffer = [x for x in buffer if x.endswith("_mod")] self._needed_modules = make_single(buffer) if self.name in self._needed_modules: self._needed_modules.remove(self.name) @@ -216,12 +215,12 @@ class Fmodule(object): ###################################################################### if __name__ == '__main__': - from parsed_text import parsed_text + from .parsed_text import parsed_text for filename, text in parsed_text: if filename == 'vmc_step.irp.f': x = Fmodule(text,filename) break for line in x.head: - print line - print x.includes + print(line) + print(x.includes) diff --git a/src/modules.py b/src/modules.py index 3e30c02..9971a67 100644 --- a/src/modules.py +++ b/src/modules.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,10 +25,10 @@ # scemama@irsamc.ups-tlse.fr -from irpf90_t import * -from parsed_text import parsed_text -from module import Fmodule -from util import * +from .irpf90_t import * +from .parsed_text import parsed_text +from .module import Fmodule +from .util import * ###################################################################### def create_modules(): @@ -44,7 +44,7 @@ def write_module(m): # Module data filename = irpdir+m.filename+".irp.module.F90" 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): # print filename file = open(filename,"w") @@ -54,7 +54,7 @@ def write_module(m): # Subroutines filename = irpdir+m.filename+".irp.F90" 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): # print filename file = open(filename,"w") diff --git a/src/ninja.py b/src/ninja.py index d309162..3e08e47 100644 --- a/src/ninja.py +++ b/src/ninja.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -26,9 +26,9 @@ import os,sys -import irpf90_t -from command_line import command_line -from modules import modules +from . import irpf90_t +from .command_line import command_line +from .modules import modules irpdir = irpf90_t.irpdir mandir = irpf90_t.mandir 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 ] - 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) 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 = ' '.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_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( [ "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 \ 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_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( [ @@ -257,7 +257,7 @@ veryclean: clean """.format(irpdir, targets) - import makefile + from . import makefile with open(makefile.IRPF90_MAKE,'w') as file: file.write(result) @@ -372,8 +372,8 @@ def run(): l_common_o += [ "irp_profile.irp.o", "irp_rdtsc.o" ] 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_s = map(dress,l_common_s) + map(lambda x: dress(x,in_root=True), SRC) + l_common_o = list(map(dress,l_common_o)) + [dress(x,in_root=True) for x in OBJ] + l_common_s = list(map(dress,l_common_s)) + [dress(x,in_root=True) for x in SRC] # IRP_touches diff --git a/src/parsed_text.py b/src/parsed_text.py index 03a1444..6a41f18 100644 --- a/src/parsed_text.py +++ b/src/parsed_text.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,17 +25,17 @@ # scemama@irsamc.ups-tlse.fr -from util import * -from irpf90_t import * -from variables import variables -from preprocessed_text import preprocessed_text -from subroutines import subroutines +from .util import * +from .irpf90_t import * +from .variables import variables +from .preprocessed_text import preprocessed_text +from .subroutines import subroutines import regexps, re -import error +from . import error -vtuple = map(lambda v: (v, variables[v].same_as, variables[v].regexp), variables.keys()) -stuple = map(lambda s: (s, subroutines[s].regexp), subroutines.keys()) -stuple = filter(lambda s: subroutines[s[0]].is_function, stuple) +vtuple = [(v, variables[v].same_as, variables[v].regexp) for v in list(variables.keys())] +stuple = [(s, subroutines[s].regexp) for s in list(subroutines.keys())] +stuple = [s for s in stuple if subroutines[s[0]].is_function] 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,)) x = variables[main_var] 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() vars.sort() for x,y in zip(vars,all_others): if x != y: 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) ################################################################################ def update_variables(): 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() if len(vars) < 2: error.fail(line,"Syntax error") @@ -101,7 +101,7 @@ def update_variables(): error.fail(line,"Variable %s unknown"%(v,)) 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() if len(vars) < 2: error.fail(line,"Syntax error") @@ -110,10 +110,10 @@ def update_variables(): error.fail(line,"Variable %s unknown"%(v,)) 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 - 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 ################################################################################ @@ -148,7 +148,7 @@ def get_parsed_text(): elif type(line) in [ Begin_provider, Cont_provider ]: if type(line) == Begin_provider: varlist = [] - buffer = map(strip,line.lower.replace(']','').split(',')) + buffer = list(map(strip,line.lower.replace(']','').split(','))) assert len(buffer) > 1 v = buffer[1] varlist.append(v) @@ -156,7 +156,7 @@ def get_parsed_text(): try: variable_list.remove(variables[v].same_as) except ValueError: - print v, variables[v].same_as + print(v, variables[v].same_as) raise append( (variable_list,line) ) elif type(line) == End_provider: @@ -164,7 +164,7 @@ def get_parsed_text(): append( ([],line) ) elif type(line) == Provide: 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: if v not in variables: error.fail(line,"Variable %s is unknown"%(v)) @@ -175,7 +175,7 @@ def get_parsed_text(): for v in l: if v not in variables: 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)) ) elif type(line) in [ Touch, SoftTouch ]: vars = line.lower.split() @@ -185,7 +185,7 @@ def get_parsed_text(): def fun(x): main = variables[x].same_as return main - main_vars = make_single( map(fun, vars) ) + main_vars = make_single( list(map(fun, vars)) ) check_touch(line,vars,main_vars) txt = " ".join(vars) append ( (vars,Simple_line(line.i,"!",line.filename)) ) @@ -195,19 +195,19 @@ def get_parsed_text(): error.fail(line,"Variable %s unknown"%(x,)) return [ ([],Simple_line(line.i," call touch_%s"%(x,),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): if x not in variables: error.fail(line,"Variable %s unknown"%(x,)) 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: append ( ([],Simple_line(line.i,"! <<< END TOUCH (Soft)",line.filename)) ) else: append ( ([],Provide_all(line.i,"! <<< END TOUCH",line.filename)) ) elif type(line) == Call: 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) if sub not in subroutines: t = Simple_line @@ -220,12 +220,10 @@ def get_parsed_text(): vars = line.lower.split() vars = vars[1:] 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: - result += map(lambda x: ([],Use(line.i,x,line.filename)), - make_single(use)) - result += map(lambda x: ([],Simple_line(line.i,x,line.filename)), - variables[var].free) + result += [([],Use(line.i,x,line.filename)) for x in make_single(use)] + result += [([],Simple_line(line.i,x,line.filename)) for x in variables[var].free] elif type(line) == Irp_read: append( ([],Simple_line(line.i,"!%s"%(line.text),line.filename)) ) elif type(line) == Irp_write: @@ -234,7 +232,7 @@ def get_parsed_text(): pass else: 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) ) return result @@ -365,7 +363,7 @@ def move_variables(): elif type(line) in [ If, Select ]: ifvars += list(varlist) 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() elsevars = old_elsevars.pop() varlist = old_varlist.pop() + vars @@ -401,13 +399,13 @@ def move_variables(): varlist = list(vars) elif type(line) in [ If, Select ]: 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) assert old_varlist is not varlist elif type(line) in [ Elseif, Else, Case ]: varlist = old_varlist.pop() 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) assert old_varlist is not varlist elif type(line) in [ Endif, End_select ]: @@ -441,7 +439,7 @@ def build_needs(): var = None for vars,line in text: 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.needs = [] 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(): if not command_line.do_checkopt: @@ -510,9 +508,9 @@ def check_opt(): for vars,line in text: if not type(line) == Provide_all: 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: - print " PROVIDE ",v + print(" PROVIDE ",v) if type(line) == Do: do_level += 1 elif type(line) == Enddo: @@ -527,7 +525,7 @@ def perform_loop_substitutions(): append = result.append for vars,line in text: 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] while reg.search(line.text) is not None: 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__': for i in range(len(parsed_text)): 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]: - print line[1] - print line[0], line[1].filename + print(line[1]) + print(line[0], line[1].filename) #for i in subroutines: # print i, subroutines[i].needs, subroutines[i].to_provide diff --git a/src/preprocessed_text.py b/src/preprocessed_text.py index 21af15c..5a71320 100644 --- a/src/preprocessed_text.py +++ b/src/preprocessed_text.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -24,11 +24,11 @@ # 31062 Toulouse Cedex 4 # scemama@irsamc.ups-tlse.fr -from irpf90_t import * -from regexps import * -import error -from command_line import command_line -from util import * +from .irpf90_t import * +from .regexps import * +from . import error +from .command_line import command_line +from .util import * # Local regular expressions re_endif = re.compile("end\s+if") @@ -263,7 +263,7 @@ def execute_templates(text): fail(line,"Subst","Syntax error") buffer = buffer[1].replace(']','') buffer = buffer.split(',') - return map(lambda x: '$%s'%(x.strip()), buffer) + return ['$%s'%(x.strip()) for x in buffer] TEMPLATE = 1 SUBST = 2 @@ -301,7 +301,7 @@ def execute_templates(text): if subst[-2:] == ';;': subst = subst[:-2] 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): fail(line,"subst","%d variables defined, and %d substitutions"%(len(variables),len(buffer))) script += "v.append( { \\\n" @@ -323,7 +323,7 @@ def execute_templates(text): file.close() # Execute shell import os - pipe = os.popen("python2 < %s"%(scriptname),'r') + pipe = os.popen("python < %s"%(scriptname),'r') lines = pipe.readlines() pipe.close() result += get_text(lines,scriptname) @@ -689,7 +689,7 @@ def change_includes(text): if type(line) == Include: txt = line.text.replace('"',"'").split("'") if len(txt) != 3: - print txt + print(txt) error.fail(line,"Error in include statement") directory = (("./"+line.filename).rsplit('/',1)[0]+'/')[2:] if directory == "": @@ -793,7 +793,7 @@ def check_begin_end(text): filter_line = lambda line: type(line) in [ Do, Enddo, If, Endif, \ Program, Begin_provider, End_provider, \ Subroutine, Function, End, Begin_doc, End_doc ] - text = filter(filter_line, text) + text = list(filter(filter_line, text)) d = { 'do' : Do, 'enddo': Enddo, 'if' : If, 'endif': Endif, @@ -911,16 +911,16 @@ def create_preprocessed_text(filename): ###################################################################### 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(): for filename, txt in preprocessed_text: if filename == 'invert.irp.f': - print "=== "+filename+" ===" + print("=== "+filename+" ===") for line in txt: - print line - print irpf90_files + print(line) + print(irpf90_files) if __name__ == '__main__': debug() diff --git a/src/profile.py b/src/profile.py index a40692d..3b583b6 100644 --- a/src/profile.py +++ b/src/profile.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -45,7 +45,7 @@ import subprocess import tempfile import os import threading -from irpf90_t import irpdir +from .irpf90_t import irpdir def build_rdtsc(): filename = irpdir+"irp_rdtsc.c" @@ -60,7 +60,7 @@ def build_rdtsc(): threading.Thread(target=t).start() def build_module(): - from variables import variables + from .variables import variables data = """ module irp_timer double precision :: irp_profile(3,%(n)d) diff --git a/src/regexps.py b/src/regexps.py index 9020d82..3bcfe7d 100644 --- a/src/regexps.py +++ b/src/regexps.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA diff --git a/src/subroutine.py b/src/subroutine.py index dddd280..218145d 100644 --- a/src/subroutine.py +++ b/src/subroutine.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,9 +25,9 @@ # scemama@irsamc.ups-tlse.fr -from irpf90_t import * -from util import * -import error +from .irpf90_t import * +from .util import * +from . import error class Sub(object): @@ -58,8 +58,8 @@ class Sub(object): def doc(self): if '_doc' not in self.__dict__: def f(l): return - buffer = filter(lambda l:type(l) == Doc, self.text) - self._doc = map(lambda l: l.text.lstrip()[1:], buffer) + buffer = [l for l in self.text if type(l) == Doc] + self._doc = [l.text.lstrip()[1:] for l in buffer] if buffer == []: error.warn(None,"Subroutine %s is not documented"%(self.name)) return self._doc @@ -75,9 +75,9 @@ class Sub(object): ############################################################ def touches(self): if '_touches' not in self.__dict__: - from subroutines import subroutines + from .subroutines import subroutines 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:] for sub in self.calls: if sub in subroutines: @@ -89,7 +89,7 @@ class Sub(object): ############################################################ def needs(self): if '_needs' not in self.__dict__: - import parsed_text + from . import parsed_text self._needs = make_single(self._needs) return self._needs needs = property(needs) @@ -97,7 +97,7 @@ class Sub(object): ############################################################ def to_provide(self): if '_to_provide' not in self.__dict__: - import parsed_text + from . import parsed_text return self._to_provide to_provide = property(to_provide) @@ -113,7 +113,7 @@ class Sub(object): ############################################################ def calls(self): 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 = [] for line in buffer: sub = line.text.split('(',1)[0].split()[1].lower() @@ -124,8 +124,8 @@ class Sub(object): ###################################################################### if __name__ == '__main__': - from preprocessed_text import preprocessed_text - from variables import variables - from subroutines import subroutines - print map(lambda x: variables[x].needs, subroutines['full_ci'].needs) - print subroutines['full_ci'].calls + from .preprocessed_text import preprocessed_text + from .variables import variables + from .subroutines import subroutines + print([variables[x].needs for x in subroutines['full_ci'].needs]) + print(subroutines['full_ci'].calls) diff --git a/src/subroutines.py b/src/subroutines.py index 2f1cff8..aa141f6 100644 --- a/src/subroutines.py +++ b/src/subroutines.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,14 +25,14 @@ # scemama@irsamc.ups-tlse.fr -from util import * -from subroutine import * -from variables import variables -from variable import Variable -from irpf90_t import * +from .util import * +from .subroutine import * +from .variables import variables +from .variable import Variable +from .irpf90_t import * def create_subroutines(): - from preprocessed_text import preprocessed_text + from .preprocessed_text import preprocessed_text result = {} for filename, text in preprocessed_text: buffer = [] @@ -51,7 +51,7 @@ def create_subroutines(): return result 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: continue for x in s.calls: @@ -60,7 +60,7 @@ def create_called_by(subs,vars): except KeyError: pass - for s in subs.values(): + for s in list(subs.values()): s.called_by = make_single(s.called_by) s.called_by.sort() @@ -68,5 +68,5 @@ subroutines = create_subroutines() create_called_by(subroutines,variables) if __name__ == '__main__': - for v in subroutines.keys(): - print v + for v in list(subroutines.keys()): + print(v) diff --git a/src/touches.py b/src/touches.py index ca91d76..8f91e02 100644 --- a/src/touches.py +++ b/src/touches.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,20 +25,20 @@ # scemama@irsamc.ups-tlse.fr -from irpf90_t import * -from util import * -from variables import variables -from modules import modules +from .irpf90_t import * +from .util import * +from .variables import variables +from .modules import modules FILENAME=irpdir+'irp_touches.irp.F90' def create(): out = [] - l = variables.keys() + l = list(variables.keys()) 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) - 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) for v in l: var = variables[v] @@ -59,7 +59,7 @@ def create(): if out != []: - out = map(lambda x: "%s\n"%(x),out) + out = ["%s\n"%(x) for x in out] out += finalize diff --git a/src/util.py b/src/util.py index 27d8fea..c1faf4c 100644 --- a/src/util.py +++ b/src/util.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -64,11 +64,11 @@ def build_dim_colons(v): if d == []: return "" else: - x = map(lambda x: ":", d) + x = [":" for x in d] return "(%s)"%(','.join(x)) -import error +from . import error def find_subname(line): buffer = line.lower if not buffer.endswith(')'): @@ -83,7 +83,7 @@ def make_single(l): d = {} for x in l: d[x] = True - return d.keys() + return list(d.keys()) def flatten(l): if type(l) == list: @@ -119,7 +119,7 @@ def put_info(text,filename): assert type(text) == list if len(text) > 0: assert type(text[0]) == tuple - from irpf90_t import Line + from .irpf90_t import Line assert type(text[0][0]) == list assert isinstance(text[0][1], Line) 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)) return text -import cPickle as pickle +import pickle as pickle import os, sys 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 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 = map( lambda x: x[1], source ) + source = [x[1] for x in source] except: pass for i in source: @@ -149,8 +149,8 @@ def parallel_loop(f,source): thread_id = 0 fork = 1 - r = range(0,NTHREADS) - for thread_id in xrange(1,NTHREADS): + r = list(range(0,NTHREADS)) + for thread_id in range(1,NTHREADS): r[thread_id], w = os.pipe() fork = os.fork() if fork == 0: @@ -173,7 +173,7 @@ def parallel_loop(f,source): w.close() os._exit(0) - for i in xrange(1,NTHREADS): + for i in range(1,NTHREADS): result += pickle.load(r[i]) r[i].close() os.waitpid(pidlist[i],0)[1] @@ -183,10 +183,10 @@ def parallel_loop(f,source): if __name__ == '__main__': - print "10",dimsize("10") #-> "10" - print "0:10",dimsize("0:10") # -> "11" - print "0:x",dimsize("0:x") # -> "x+1" - print "-3:x",dimsize("-3:x") # -> "x+1" - print "x:y",dimsize("x:y") # -> "y-x+1" - print "x:5",dimsize("x:5") # -> "y-x+1" + print("10",dimsize("10")) #-> "10" + print("0:10",dimsize("0:10")) # -> "11" + print("0:x",dimsize("0:x")) # -> "x+1" + print("-3:x",dimsize("-3:x")) # -> "x+1" + print("x:y",dimsize("x:y")) # -> "y-x+1" + print("x:5",dimsize("x:5")) # -> "y-x+1" diff --git a/src/variable.py b/src/variable.py index 1409fc3..cb1853f 100644 --- a/src/variable.py +++ b/src/variable.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,10 +25,10 @@ # scemama@irsamc.ups-tlse.fr -from irpf90_t import * -from util import * -import error -from command_line import command_line +from .irpf90_t import * +from .util import * +from . import error +from .command_line import command_line class Variable(object): @@ -45,7 +45,7 @@ class Variable(object): ############################################################ def is_touched(self): if '_is_touched' not in self.__dict__: - from variables import variables + from .variables import variables result = self.is_read for i in self.children: if variables[i].is_touched: @@ -66,7 +66,7 @@ class Variable(object): ############################################################ def is_written(self): if '_is_written' not in self.__dict__: - from variables import variables + from .variables import variables result = False for i in self.parents: if variables[i].is_written: @@ -79,7 +79,7 @@ class Variable(object): ############################################################ def is_read(self): if '_is_read' not in self.__dict__: - from variables import variables + from .variables import variables result = False for i in self.parents: if variables[i].is_read: @@ -118,8 +118,8 @@ dimension. def doc(self): if '_doc' not in self.__dict__: text = self.text - buffer = filter(lambda l:type(l) == Doc, text) - self._doc = map(lambda l: l.text.lstrip()[1:], buffer) + buffer = [l for l in text if type(l) == Doc] + self._doc = [l.text.lstrip()[1:] for l in buffer] if buffer == []: error.warn(None,"Variable %s is not documented"%(self.name)) return self._doc @@ -137,7 +137,7 @@ dimension. if '_includes' not in self.__dict__: self._includes = [] 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) make_single(self._includes) return self._includes @@ -148,7 +148,7 @@ dimension. if '_calls' not in self.__dict__: self._calls = [] 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() self._calls.append(sub) make_single(self._calls) @@ -162,7 +162,7 @@ dimension. append = result.append f = lambda l: type(l) in [Begin_provider, Cont_provider] text = self.text - lines = filter(f, text) + lines = list(filter(f, text)) for line in lines: append(line.filename[1]) result.remove(self.name) @@ -187,10 +187,10 @@ dimension. if not self.is_main: self._allocate = [] else: - from variables import variables + from .variables import variables def f(var): return variables[var].dim != [] - self._allocate = filter ( f, self.others + [self.name] ) + self._allocate = list(filter ( f, self.others + [self.name] )) return self._allocate allocate = property(allocate) @@ -203,7 +203,7 @@ dimension. self._dim = [] else: buffer = buffer[2].strip()[1:-1].split(',') - self._dim = map(strip,buffer) + self._dim = list(map(strip,buffer)) return self._dim dim = property(dim) @@ -243,7 +243,7 @@ dimension. if '_line' not in self.__dict__: f = lambda l: type(l) in [Begin_provider, Cont_provider] text = self.text - lines = filter(f, text) + lines = list(filter(f, text)) for line in lines: buffer = line.filename[1] if self._name == buffer: @@ -276,24 +276,24 @@ dimension. if not self.is_main: self._toucher = [] else: - from modules import modules - from variables import variables + from .modules import modules + from .variables import variables if '_needed_by' not in self.__dict__: - import parsed_text + from . import parsed_text parents = self.parents parents.sort() - mods = map(lambda x: variables[x].fmodule, parents) + mods = [variables[x].fmodule for x in parents] mods = make_single(mods)+[self.fmodule] name = self.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") if command_line.do_debug: length = str(len("touch_%s"%(name))) result += [ " character*(%s) :: irp_here = 'touch_%s'"%(length,name) ] if command_line.do_debug: 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)) if command_line.do_debug: result.append(" call irp_leave(irp_here)") @@ -309,8 +309,8 @@ dimension. if not command_line.do_openmp: self._locker = [] else: - from modules import modules - from variables import variables + from .modules import modules + from .variables import variables name = self.name result = [ "subroutine irp_lock_%s(set)"%(name) ] result += [ " use omp_lib", @@ -348,8 +348,8 @@ dimension. self._reader = [] else: if '_needs' not in self.__dict__: - import parsed_text - from variables import variables + from . import parsed_text + from .variables import variables name = self.name result = [ \ "subroutine reader_%s(irp_num)"%(name), @@ -363,7 +363,7 @@ dimension. result += [\ " character*(%d) :: irp_here = 'reader_%s'"%(length,name), " 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 += [ \ " irp_is_open = .True.", " irp_iunit = 9", @@ -393,9 +393,9 @@ dimension. if not self.is_main: self._writer = [] else: - from variables import variables + from .variables import variables if '_needs' not in self.__dict__: - import parsed_text + from . import parsed_text name = self.name result = [ \ "subroutine writer_%s(irp_num)"%(name), @@ -413,7 +413,7 @@ dimension. " if (.not.%s_is_built) then"%(self.same_as), " call provide_%s"%(self.same_as), " 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 += [ \ " irp_is_open = .True.", " irp_iunit = 9", @@ -464,8 +464,8 @@ dimension. self._provider = [] else: if '_to_provide' not in self.__dict__: - import parsed_text - from variables import variables, build_use, call_provides + from . import parsed_text + from .variables import variables, build_use, call_provides name = self.name same_as = self.same_as @@ -480,7 +480,7 @@ dimension. return result+")'" 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 = " if (%s) then"%(result) return result @@ -555,7 +555,7 @@ dimension. if command_line.do_debug: result.append(" call irp_enter(irp_here)") 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), " call bld_%s"%(same_as), " %s_is_built = .True."%(same_as), "" ] @@ -576,8 +576,8 @@ dimension. if not self.is_main: self._builder = [] else: - import parsed_text - from variables import build_use, call_provides + from . import parsed_text + from .variables import build_use, call_provides for filename,buffer in parsed_text.parsed_text: if self.line.filename[0].startswith(filename): break @@ -591,7 +591,7 @@ dimension. vars = [] if inside: 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: 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) ) ) @@ -602,9 +602,9 @@ dimension. text = parsed_text.move_to_top(text,Declaration) text = parsed_text.move_to_top(text,Implicit) 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 - 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: result = [] if command_line.directives and command_line.inline in ["all","builders"]: @@ -642,9 +642,9 @@ dimension. if '_children' not in self.__dict__: if not self.is_main: self._children = [] - from variables import variables + from .variables import variables if '_needs' not in self.__dict__: - import parsed_text + from . import parsed_text result = [] for x in self.needs: result.append(x) @@ -664,9 +664,9 @@ dimension. if not self.is_main: self._parents = [] else: - from variables import variables + from .variables import variables if '_needed_by' not in self.__dict__: - import parsed_text + from . import parsed_text result = [] for x in self.needed_by: result.append(x) @@ -682,8 +682,8 @@ dimension. ###################################################################### if __name__ == '__main__': - from preprocessed_text import preprocessed_text - from variables import variables + from .preprocessed_text import preprocessed_text + from .variables import variables #for v in variables.keys(): # print v def print_dot(x,done): @@ -692,11 +692,11 @@ if __name__ == '__main__': for i in x.needs: pair = (x.name, i) if pair not in done: - print "%s -> %s"%( x.name, i ) + print("%s -> %s"%( x.name, i )) done[pair] = None print_dot(variables[i],done) - print "digraph G { " + print("digraph G { ") # print_dot(variables['e_loc'], {}) print_dot(variables['psi_value'], {}) - print "}" + print("}") diff --git a/src/variables.py b/src/variables.py index dfc7d29..7f6910c 100644 --- a/src/variables.py +++ b/src/variables.py @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA @@ -25,14 +25,14 @@ # scemama@irsamc.ups-tlse.fr -from variable import * -from irpf90_t import * -from command_line import command_line -from util import * +from .variable import * +from .irpf90_t import * +from .command_line import command_line +from .util import * ###################################################################### def create_variables(): - from preprocessed_text import preprocessed_text + from .preprocessed_text import preprocessed_text result = {} icount = 0 for filename, text in preprocessed_text: @@ -48,17 +48,17 @@ def create_variables(): icount += 1 v = Variable(buffer,icount) if v.name in result: - print "Warning: Duplicate provider for %s in"%(v.name) - print "- ", v.line.filename[0], " line ", v.line.i - print "- ", result[v.name].line.filename[0], " line ", result[v.name].line.i - print "Choosing first version" + print("Warning: Duplicate provider for %s in"%(v.name)) + print("- ", v.line.filename[0], " line ", v.line.i) + print("- ", result[v.name].line.filename[0], " line ", result[v.name].line.i) + print("Choosing first version") result[v.name] = v for other in v.others: if other in result: - print "Warning: Duplicate provider for %s in"%(other) - print "- ", v.line.filename[0], " line ", v.line.i - print "- ", result[other].line.filename[0], " line ", result[other].line.i - print "Choosing first version" + print("Warning: Duplicate provider for %s in"%(other)) + print("- ", v.line.filename[0], " line ", v.line.i) + print("- ", result[other].line.filename[0], " line ", result[other].line.i) + print("Choosing first version") result[other] = Variable(buffer,icount,other) buffer = [] return result @@ -67,16 +67,16 @@ variables = create_variables() ###################################################################### 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) return result ###################################################################### 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: - all_children = flatten( map(lambda x: variables[x].children, vars )) - vars = filter(lambda x: x not in all_children,vars) + all_children = flatten( [variables[x].children for x in vars]) + vars = [x for x in vars if x not in all_children] def fun(x): result = [] result += [ \ @@ -87,10 +87,10 @@ def call_provides(vars,opt=False): " endif" ] return result - result = flatten ( map (fun, vars) ) + result = flatten ( list(map (fun, vars)) ) return result ###################################################################### if __name__ == '__main__': - for v in variables.keys(): - print v + for v in list(variables.keys()): + print(v) diff --git a/src/version.py b/src/version.py index 72f4cc2..1b23640 100644 --- a/src/version.py +++ b/src/version.py @@ -1 +1 @@ -version = "1.7.6" +version = "2.0.0" diff --git a/src/vim.py b/src/vim.py index 185ac17..46942c5 100644 --- a/src/vim.py +++ b/src/vim.py @@ -1,4 +1,4 @@ -#/usr/bin/env python2 +#/usr/bin/env python3 # IRPF90 is a Fortran90 preprocessor written in Python for programming using # the Implicit Reference to Parameters (IRP) method. # Copyright (C) 2009 Anthony SCEMAMA diff --git a/tools/commit-msg b/tools/commit-msg index 5c37748..5fd195e 100755 --- a/tools/commit-msg +++ b/tools/commit-msg @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 import os,sys ROOT = os.path.dirname(__file__)+'/../../' diff --git a/tools/post-commit b/tools/post-commit index 4708a76..970ee44 100755 --- a/tools/post-commit +++ b/tools/post-commit @@ -1,4 +1,4 @@ -#!/usr/bin/env python2 +#!/usr/bin/env python3 import os ROOT = os.path.dirname(__file__)+'/../../'