graal-jvmci-8: mxtool/mx.py comparison

comparison mxtool/mx.py @ 11514:dc3c8df55905

added support for pylint and fixed errors/warnings it found

author	Doug Simon <doug.simon@oracle.com>
date	Tue, 03 Sep 2013 16:33:41 +0200
parents	3110bea9a6b0
children	723796685546

comparison

equal deleted inserted replaced

-:8d4e5e08d83f
+:dc3c8df55905
 "true" if the project is native.
 javaCompliance
 The minimum JDK version (format: x.y) to which the project's
 sources comply (required for non-native projects).
 workingSets
 A comma separated list of working set names. The project belongs
 to the given working sets, for which the eclipseinit command
 will generate Eclipse configurations.
 import shutil, re, xml.dom.minidom
 from collections import Callable
 from threading import Thread
 from argparse import ArgumentParser, REMAINDER
 from os.path import join, basename, dirname, exists, getmtime, isabs, expandvars, isdir, isfile
-DEFAULT_JAVA_ARGS = '-ea -Xss2m -Xmx1g'
 _projects = dict()
 _libs = dict()
 _dists = dict()
 _suites = dict()
 self.path = path.replace('/', os.sep)
 if not isabs(self.path):
 self.path = join(suite.dir, self.path)
 self.deps = deps
 self.update_listeners = set()
 def __str__(self):
 return self.name
 def add_update_listener(self, listener):
 self.update_listeners.add(listener)
 def notify_updated(self):
 for l in self.update_listeners:
 l(self)
 """
 A dependency is a library or project specified in a suite.
 """
 class Dependency:
 def __init__(self, suite, name):
 def __hash__(self):
 return hash(self.name)
 def isLibrary(self):
 return isinstance(self, Library)
 def isProject(self):
 return isinstance(self, Project)
 class Project(Dependency):
 def __init__(self, suite, name, srcDirs, deps, javaCompliance, workingSets, d):
 self.checkstyleProj = name
 self.javaCompliance = JavaCompliance(javaCompliance) if javaCompliance is not None else None
 self.native = False
 self.workingSets = workingSets
 self.dir = d
 # Create directories for projects that don't yet exist
 if not exists(d):
 os.mkdir(d)
 for s in self.source_dirs():
 if not exists(s):
 if not self in deps and includeSelf:
 deps.append(self)
 return deps
 def _compute_max_dep_distances(self, name, distances, dist):
-currentDist = distances.get(name);
+currentDist = distances.get(name)
 if currentDist is None or currentDist < dist:
 distances[name] = dist
 p = project(name, False)
 if p is not None:
 for dep in p.deps:
 via other dependencies).
 """
 distances = dict()
 result = set()
 self._compute_max_dep_distances(self.name, distances, 0)
-for n,d in distances.iteritems():
+for n, d in distances.iteritems():
 assert d > 0 or n == self.name
 if d == 1:
 result.add(n)
 if len(result) == len(self.deps) and frozenset(self.deps) == result:
 return self.deps
-return result;
+return result
 def max_depth(self):
 """
 Get the maximum canonical distance between this project and its most distant dependency.
 """
 distances = dict()
 self._compute_max_dep_distances(self.name, distances, 0)
 return max(distances.values())
 def source_dirs(self):
 """
 Get the directories in which the sources of this project are found.
 """
 pkg = match.group(1)
 if function(line.strip()):
 matchFound = True
 if pkg and matchFound:
 break
 if matchFound:
-basename = name[:-len('.java')]
+simpleClassName = name[:-len('.java')]
 assert pkg is not None
 if pkgRoot is None or pkg.startswith(pkgRoot):
 pkgOutputDir = join(outputDir, pkg.replace('.', os.path.sep))
 if exists(pkgOutputDir):
 for e in os.listdir(pkgOutputDir):
 if includeInnerClasses:
-if e.endswith('.class') and (e.startswith(basename) or e.startswith(basename + '$')):
+if e.endswith('.class') and (e.startswith(simpleClassName) or e.startswith(simpleClassName + '$')):
 className = pkg + '.' + e[:-len('.class')]
 result[className] = source
-elif e == basename + '.class':
+elif e == simpleClassName + '.class':
-className = pkg + '.' + basename
+className = pkg + '.' + simpleClassName
 result[className] = source
 return result
 def _init_packages_and_imports(self):
 if not hasattr(self, '_defined_java_packages'):
 packages = set()
 extendedPackages = set()
 depPackages = set()
 importRe = re.compile(r'import\s+(?:static\s+)?([^;]+);')
 for sourceDir in self.source_dirs():
 for root, _, files in os.walk(sourceDir):
 javaSources = [name for name in files if name.endswith('.java')]
 if len(javaSources) != 0:
-pkg = root[len(sourceDir) + 1:].replace(os.sep,'.')
+pkg = root[len(sourceDir) + 1:].replace(os.sep, '.')
 if not pkg in depPackages:
 packages.add(pkg)
 else:
 # A project extends a package already defined by one of it dependencies
 extendedPackages.add(pkg)
 imports.add(pkg)
 for n in javaSources:
 with open(join(root, n)) as fp:
 content = fp.read()
 imports.update(importRe.findall(content))
 self._defined_java_packages = frozenset(packages)
 self._extended_java_packages = frozenset(extendedPackages)
 importedPackages = set()
 for imp in imports:
 name = imp
 while not name in depPackages and len(name) > 0:
 lastDot = name.rfind('.')
 break
 name = name[0:lastDot]
 if name is not None:
 importedPackages.add(name)
 self._imported_java_packages = frozenset(importedPackages)
 def defined_java_packages(self):
 """Get the immutable set of Java packages defined by the Java sources of this project"""
 self._init_packages_and_imports()
 return self._defined_java_packages
 def extended_java_packages(self):
 """Get the immutable set of Java packages extended by the Java sources of this project"""
 self._init_packages_and_imports()
 return self._extended_java_packages
 if not hasattr(self, '_annotationProcessors'):
 ap = set()
 if hasattr(self, '_declaredAnnotationProcessors'):
 ap = set(self._declaredAnnotationProcessors)
 # find dependencies that auto-inject themselves as annotation processors to all dependents
 allDeps = self.all_deps([], includeLibs=False, includeSelf=False, includeAnnotationProcessors=False)
 for p in allDeps:
 if hasattr(p, 'annotationProcessorForDependents') and p.annotationProcessorForDependents.lower() == 'true':
 ap.add(p.name)
 self._annotationProcessors = list(ap)
 def get_path(self, resolve):
 path = self.path
 if not isabs(path):
 path = join(self.suite.dir, path)
 if resolve and self.mustExist and not exists(path):
-assert not len(self.urls) == 0, 'cannot find required library ' + self.name + ' ' + path;
+assert not len(self.urls) == 0, 'cannot find required library ' + self.name + ' ' + path
 print('Downloading ' + self.name + ' from ' + str(self.urls))
 download(path, self.urls)
 return path
 def get_source_path(self, resolve):
 def append_to_classpath(self, cp, resolve):
 path = self.get_path(resolve)
 if exists(path) or not resolve:
 cp.append(path)
 def all_deps(self, deps, includeLibs, includeSelf=True, includeAnnotationProcessors=False):
 if not includeLibs or not includeSelf:
 return deps
 deps.append(self)
 return deps
 self.primary = primary
 mxDir = join(d, 'mx')
 self._load_env(mxDir)
 self._load_commands(mxDir)
 self._load_includes(mxDir)
-self.name = d # re-initialized in _load_projects
+self.name = d  # re-initialized in _load_projects
 def __str__(self):
 return self.name
 def _load_projects(self, mxDir):
 libsMap = dict()
 projsMap = dict()
 distsMap = dict()
 projectsFile = join(mxDir, 'projects')
 for name, attrs in projsMap.iteritems():
 srcDirs = pop_list(attrs, 'sourceDirs')
 deps = pop_list(attrs, 'dependencies')
 ap = pop_list(attrs, 'annotationProcessors')
-#deps += ap
+# deps += ap
 javaCompliance = attrs.pop('javaCompliance', None)
 subDir = attrs.pop('subDir', None)
 if subDir is None:
 d = join(self.dir, name)
 else:
 path = attrs.pop('path')
 deps = pop_list(attrs, 'dependencies')
 d = Distribution(self, name, path, deps)
 d.__dict__.update(attrs)
 self.dists.append(d)
 if self.name is None:
 abort('Missing "suite=<name>" in ' + projectsFile)
 def _load_commands(self, mxDir):
-commands = join(mxDir, 'commands.py')
+commandsPath = join(mxDir, 'commands.py')
-if exists(commands):
+if exists(commandsPath):
 # temporarily extend the Python path
 sys.path.insert(0, mxDir)
 mod = __import__('commands')
 self.commands = sys.modules.pop('commands')
 sys.modules[join(mxDir, 'commands')] = self.commands
 # revert the Python path
 del sys.path[0]
 if not hasattr(mod, 'mx_init'):
-abort(commands + ' must define an mx_init(env) function')
+abort(commandsPath + ' must define an mx_init(env) function')
 if hasattr(mod, 'mx_post_parse_cmd_line'):
 self.mx_post_parse_cmd_line = mod.mx_post_parse_cmd_line
 mod.mx_init()
 self.commands = mod
 existing = _libs.get(l.name)
 if existing is not None:
 abort('cannot redefine library  ' + l.name)
 _libs[l.name] = l
 for d in self.dists:
-existing = _dists.get(l.name)
+existing = _dists.get(d.name)
 if existing is not None:
 abort('cannot redefine distribution  ' + d.name)
 _dists[d.name] = d
 if hasattr(self, 'mx_post_parse_cmd_line'):
 self.mx_post_parse_cmd_line(opts)
 class XMLElement(xml.dom.minidom.Element):
 def writexml(self, writer, indent="", addindent="", newl=""):
-writer.write(indent+"<" + self.tagName)
+writer.write(indent + "<" + self.tagName)
 attrs = self._get_attributes()
 a_names = attrs.keys()
 a_names.sort()
 if not self.ownerDocument.padTextNodeWithoutSiblings and len(self.childNodes) == 1 and isinstance(self.childNodes[0], xml.dom.minidom.Text):
 # if the only child of an Element node is a Text node, then the
 # text is printed without any indentation or new line padding
 writer.write(">")
 self.childNodes[0].writexml(writer)
-writer.write("</%s>%s" % (self.tagName,newl))
+writer.write("</%s>%s" % (self.tagName, newl))
 else:
-writer.write(">%s"%(newl))
+writer.write(">%s" % (newl))
 for node in self.childNodes:
-node.writexml(writer,indent+addindent,addindent,newl)
+node.writexml(writer, indent + addindent, addindent, newl)
-writer.write("%s</%s>%s" % (indent,self.tagName,newl))
+writer.write("%s</%s>%s" % (indent, self.tagName, newl))
 else:
-writer.write("/>%s"%(newl))
+writer.write("/>%s" % (newl))
 class XMLDoc(xml.dom.minidom.Document):
 def __init__(self):
 xml.dom.minidom.Document.__init__(self)
 return e
 def comment(self, txt):
 self.current.appendChild(self.createComment(txt))
-def open(self, tag, attributes={}, data=None):
+def open(self, tag, attributes=None, data=None):
+if attributes is None:
+attributes = {}
 element = self.createElement(tag)
 for key, value in attributes.items():
 element.setAttribute(key, value)
 self.current.appendChild(element)
 self.current = element
 assert self.current != self
 assert tag == self.current.tagName, str(tag) + ' != ' + self.current.tagName
 self.current = self.current.parentNode
 return self
-def element(self, tag, attributes={}, data=None):
+def element(self, tag, attributes=None, data=None):
+if attributes is None:
+attributes = {}
 return self.open(tag, attributes, data).close(tag)
 def xml(self, indent='', newl='', escape=False, standalone=None):
 assert self.current == self
 result = self.toprettyxml(indent, newl, encoding="UTF-8")
 return deps
 def _handle_missing_java_home():
 if not sys.stdout.isatty():
 abort('Could not find bootstrap JDK. Use --java-home option or ensure JAVA_HOME environment variable is set.')
 candidateJdks = []
 if get_os() == 'darwin':
 base = '/Library/Java/JavaVirtualMachines'
 candidateJdks = [join(base, n, 'Contents/Home') for n in os.listdir(base) if exists(join(base, n, 'Contents/Home'))]
 elif get_os() == 'linux':
 javaHome = None
 if len(candidateJdks) != 0:
 javaHome = select_items(candidateJdks + ['<other>'], allowMultiple=False)
 if javaHome == '<other>':
 javaHome = None
 while javaHome is None:
 javaHome = raw_input('Enter path of bootstrap JDK: ')
 rtJarPath = join(javaHome, 'jre', 'lib', 'rt.jar')
 if not exists(rtJarPath):
 log('Does not appear to be a valid JDK as ' + rtJarPath + ' does not exist')
 javaHome = None
 else:
 break
 envPath = join(_mainSuite.dir, 'mx', 'env')
 if ask_yes_no('Persist this setting by adding "JAVA_HOME=' + javaHome + '" to ' + envPath, 'y'):
 with open(envPath, 'a') as fp:
 print >> fp, 'JAVA_HOME=' + javaHome
 return javaHome
 class ArgParser(ArgumentParser):
 # Override parent to append the list of available commands
 self.add_argument('-V', action='store_true', dest='very_verbose', help='enable very verbose output')
 self.add_argument('--dbg', type=int, dest='java_dbg_port', help='make Java processes wait on <port> for a debugger', metavar='<port>')
 self.add_argument('-d', action='store_const', const=8000, dest='java_dbg_port', help='alias for "-dbg 8000"')
 self.add_argument('--cp-pfx', dest='cp_prefix', help='class path prefix', metavar='<arg>')
 self.add_argument('--cp-sfx', dest='cp_suffix', help='class path suffix', metavar='<arg>')
-self.add_argument('--J', dest='java_args', help='Java VM arguments (e.g. --J @-dsa)', metavar='@<args>', default=DEFAULT_JAVA_ARGS)
+self.add_argument('--J', dest='java_args', help='Java VM arguments (e.g. --J @-dsa)', metavar='@<args>', default='-ea -Xss2m -Xmx1g')
 self.add_argument('--Jp', action='append', dest='java_args_pfx', help='prefix Java VM arguments (e.g. --Jp @-dsa)', metavar='@<args>', default=[])
 self.add_argument('--Ja', action='append', dest='java_args_sfx', help='suffix Java VM arguments (e.g. --Ja @-dsa)', metavar='@<args>', default=[])
 self.add_argument('--user-home', help='users home directory', metavar='<path>', default=os.path.expanduser('~'))
 self.add_argument('--java-home', help='bootstrap JDK installation directory (must be JDK 6 or later)', metavar='<path>')
 self.add_argument('--ignore-project', action='append', dest='ignored_projects', help='name of project to ignore', metavar='<name>', default=[])
 commandAndArgs = opts.__dict__.pop('commandAndArgs')
 return opts, commandAndArgs
 def _format_commands():
 msg = '\navailable commands:\n\n'
-for cmd in sorted(commands.iterkeys()):
+for cmd in sorted(_commands.iterkeys()):
-c, _ = commands[cmd][:2]
+c, _ = _commands[cmd][:2]
 doc = c.__doc__
 if doc is None:
 doc = ''
 msg += ' {0:<20} {1}\n'.format(cmd, doc.split('\n', 1)[0])
 return msg + '\n'
 for arg in args:
 assert isinstance(arg, types.StringTypes), 'argument is not a string: ' + str(arg)
 if env is None:
 env = os.environ
 if _opts.verbose:
 if _opts.very_verbose:
 log('Environment variables:')
 for key in sorted(env.keys()):
 log('    ' + key + '=' + env[key])
 else:
 def redirect(stream, f):
 for line in iter(stream.readline, ''):
 f(line)
 stream.close()
-stdout=out if not callable(out) else subprocess.PIPE
+stdout = out if not callable(out) else subprocess.PIPE
-stderr=err if not callable(err) else subprocess.PIPE
+stderr = err if not callable(err) else subprocess.PIPE
 p = subprocess.Popen(args, cwd=cwd, stdout=stdout, stderr=stderr, preexec_fn=preexec_fn, creationflags=creationflags, env=env)
 _currentSubprocess = (p, args)
 if callable(out):
 t = Thread(target=redirect, args=(p.stdout, out))
-t.daemon = True # thread dies with the program
+t.daemon = True  # thread dies with the program
 t.start()
 if callable(err):
 t = Thread(target=redirect, args=(p.stderr, err))
-t.daemon = True # thread dies with the program
+t.daemon = True  # thread dies with the program
 t.start()
 if timeout is None or timeout == 0:
 retcode = waitOn(p)
 else:
 if get_os() == 'windows':
 if retcode and nonZeroIsFatal:
 if _opts.verbose:
 if _opts.very_verbose:
 raise subprocess.CalledProcessError(retcode, ' '.join(args))
 else:
-log('[exit code: ' + str(retcode)+ ']')
+log('[exit code: ' + str(retcode) + ']')
 abort(retcode)
 return retcode
 def exe_suffix(name):
 def add_lib_prefix(name):
 """
 Adds the platform specific library prefix to a name
 """
-os = get_os();
+os = get_os()
 if os == 'linux' or os == 'solaris' or os == 'darwin':
 return 'lib' + name
 return name
 def add_lib_suffix(name):
 """
 Adds the platform specific library suffix to a name
 """
-os = get_os();
+os = get_os()
 if os == 'windows':
 return name + '.dll'
 if os == 'linux' or os == 'solaris':
 return name + '.so'
 if os == 'darwin':
 """
 A JavaCompliance simplifies comparing Java compliance values extracted from a JDK version string.
 """
 class JavaCompliance:
 def __init__(self, ver):
-m = re.match('1\.(\d+).*', ver)
+m = re.match(r'1\.(\d+).*', ver)
 assert m is not None, 'not a recognized version string: ' + ver
 self.value = int(m.group(1))
 def __str__ (self):
 return '1.' + str(self.value)
 def __cmp__ (self, other):
 if isinstance(other, types.StringType):
 other = JavaCompliance(other)
 return cmp(self.value, other.value)
 """
 A Java version as defined in JSR-56
 """
 class JavaVersion:
 def __init__(self, versionString):
-validChar = '[\x21-\x25\x27-\x29\x2c\x2f-\x5e\x60-\x7f]'
+validChar = r'[\x21-\x25\x27-\x29\x2c\x2f-\x5e\x60-\x7f]'
-separator = '[.\-_]'
+separator = r'[.\-_]'
 m = re.match(validChar + '+(' + separator + validChar + '+)*', versionString)
 assert m is not None, 'not a recognized version string: ' + versionString
-self.versionString = versionString;
+self.versionString = versionString
 self.parts = [int(f) if f.isdigit() else f for f in re.split(separator, versionString)]
 def __str__(self):
 return self.versionString
 def __cmp__(self, other):
 return cmp(self.parts, other.parts)
 """
 A JavaConfig object encapsulates info on how Java commands are run.
 """
 class JavaConfig:
 def __init__(self, opts):
 self.jdk = opts.java_home
 self.debug_port = opts.java_dbg_port
-self.jar   = exe_suffix(join(self.jdk, 'bin', 'jar'))
+self.jar = exe_suffix(join(self.jdk, 'bin', 'jar'))
-self.java  = exe_suffix(join(self.jdk, 'bin', 'java'))
+self.java = exe_suffix(join(self.jdk, 'bin', 'java'))
 self.javac = exe_suffix(join(self.jdk, 'bin', 'javac'))
 self.javap = exe_suffix(join(self.jdk, 'bin', 'javap'))
 self.javadoc = exe_suffix(join(self.jdk, 'bin', 'javadoc'))
 self._bootclasspath = None
 return value
 def logv(msg=None):
 if _opts.verbose:
 log(msg)
 def log(msg=None):
 """
 Write a message to the console.
 All script output goes through this method thus allowing a subclass
 to redirect it.
 def gmake_cmd():
 for a in ['make', 'gmake', 'gnumake']:
 try:
 output = subprocess.check_output([a, '--version'])
 if 'GNU' in output:
-return a;
+return a
 except:
 pass
 abort('Could not find a GNU make executable on the current path.')
 def expandvars_in_property(value):
 result = expandvars(value)
 if '$' in result or '%' in result:
 abort('Property contains an undefined environment variable: ' + value)
 return result
 def abort(codeOrMessage):
 """
 Aborts the program with a SystemExit exception.
 If 'codeOrMessage' is a plain integer, it specifies the system exit status;
 if it is None, the exit status is zero; if it has another type (such as a string),
 the object's value is printed and the exit status is one.
 """
-#import traceback
+# import traceback
-#traceback.print_stack()
+# traceback.print_stack()
 currentSubprocess = _currentSubprocess
 if currentSubprocess is not None:
 p, _ = currentSubprocess
 if get_os() == 'windows':
 p.kill()
 else:
 _kill_process_group(p.pid)
 raise SystemExit(codeOrMessage)
 def download(path, urls, verbose=False):
 """
 Attempts to downloads content for each URL in a list, stopping after the first successful download.
 with open(path, 'wb') as f:
 f.write(content)
 log(('modified ' if existed else 'created ') + path)
-return True;
+return True
 except IOError as e:
-abort('Error while writing to ' + path + ': ' + str(e));
+abort('Error while writing to ' + path + ': ' + str(e))
 # Builtin commands
 def build(args, parser=None):
 """compile the Java and C sources, linking the latter
 if suppliedParser:
 parser.add_argument('remainder', nargs=REMAINDER, metavar='...')
 args = parser.parse_args(args)
 jdtJar = None
 if args.jdt is not None:
 if args.jdt.endswith('.jar'):
-jdtJar=args.jdt
+jdtJar = args.jdt
 if not exists(jdtJar) and os.path.abspath(jdtJar) == os.path.abspath(defaultEcjPath):
 # Silently ignore JDT if default location is used but not ecj.jar exists there
 jdtJar = None
 built = set()
 if args.only is not None:
 sortedProjects = [project(name) for name in args.only.split(',')]
 else:
 sortedProjects = sorted_deps(projects, includeAnnotationProcessors=True)
 for p in sortedProjects:
 if p.native:
 if args.native:
 log('Calling GNU make {0}...'.format(p.dir))
 built.add(p.name)
 continue
 else:
 if not args.java:
 continue
-if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project
+if exists(join(p.dir, 'plugin.xml')):  # eclipse plugin project
 continue
 # skip building this Java project if its Java compliance level is "higher" than the configured JDK
 if javaCompliance < p.javaCompliance:
 log('Excluding {0} from build (Java compliance level {1} required)'.format(p.name, p.javaCompliance))
 processorArgs = []
 ap = p.annotation_processors()
 if len(ap) > 0:
 processorPath = classpath(ap, resolve=True)
-genDir = p.source_gen_dir();
+genDir = p.source_gen_dir()
 if exists(genDir):
 shutil.rmtree(genDir)
 os.mkdir(genDir)
 processorArgs += ['-processorpath', join(processorPath), '-s', genDir]
 else:
 processorArgs += ['-proc:none']
 toBeDeleted = [argfileName]
 try:
 compliance = str(p.javaCompliance) if p.javaCompliance is not None else args.compliance
 if jdtJar is None:
 log('Compiling Java sources for {0} with javac...'.format(p.name))
 javacCmd = [java().javac, '-g', '-J-Xmx1g', '-source', compliance, '-classpath', cp, '-d', outputDir]
 if java().debug_port is not None:
 javacCmd += ['-J-Xdebug', '-J-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=' + str(java().debug_port)]
 javacCmd += processorArgs
 javacCmd += ['@' + argfile.name]
 if not args.warnAPI:
 javacCmd.append('-XDignore.symbol.file')
 run(javacCmd)
 else:
 log('Compiling Java sources for {0} with JDT...'.format(p.name))
 jdtArgs = [java().java, '-Xmx1g']
 if java().debug_port is not None:
 jdtArgs += ['-Xdebug', '-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=' + str(java().debug_port)]
 jdtArgs += [ '-jar', jdtJar,
 '-' + compliance,
 '-cp', cp, '-g', '-enableJavadoc',
 '-d', outputDir]
 jdtArgs += processorArgs
 jdtProperties = join(p.dir, '.settings', 'org.eclipse.jdt.core.prefs')
 rootJdtProperties = join(p.suite.dir, 'mx', 'eclipse-settings', 'org.eclipse.jdt.core.prefs')
 if not exists(jdtProperties) or os.path.getmtime(jdtProperties) < os.path.getmtime(rootJdtProperties):
 # Try to fix a missing properties file by running eclipseinit
 eclipseinit([], buildProcessorJars=False)
 toBeDeleted.append(jdtPropertiesTmp)
 jdtArgs += ['-properties', jdtPropertiesTmp]
 else:
 jdtArgs += ['-properties', jdtProperties]
 jdtArgs.append('@' + argfile.name)
 run(jdtArgs)
 finally:
 for n in toBeDeleted:
 os.remove(n)
 for dist in _dists.values():
 archive(['@' + dist.name])
 if suppliedParser:
 return args
 parser = ArgumentParser(prog='mx eclipseformat')
 parser.add_argument('-e', '--eclipse-exe', help='location of the Eclipse executable')
 parser.add_argument('-C', '--no-backup', action='store_false', dest='backup', help='do not save backup of modified files')
 parser.add_argument('--projects', action='store', help='comma separated projects to process (omit to process all projects)')
 args = parser.parse_args(args)
 if args.eclipse_exe is None:
 args.eclipse_exe = os.environ.get('ECLIPSE_EXE')
 if args.eclipse_exe is None:
 abort('Could not find Eclipse executable. Use -e option or ensure ECLIPSE_EXE environment variable is set.')
 # Maybe an Eclipse installation dir was specified - look for the executable in it
 if join(args.eclipse_exe, exe_suffix('eclipse')):
 args.eclipse_exe = join(args.eclipse_exe, exe_suffix('eclipse'))
 if not os.path.isfile(args.eclipse_exe) or not os.access(args.eclipse_exe, os.X_OK):
 abort('Not an executable file: ' + args.eclipse_exe)
 eclipseinit([], buildProcessorJars=False)
 class Batch:
 def __init__(self, settingsFile):
 self.path = settingsFile
 self.javafiles = list()
 def settings(self):
 with open(self.path) as fp:
 return fp.read()
 class FileInfo:
 content = fp.read()
 if self.content != content:
 self.content = content
 return True
 os.utime(self.path, self.times)
 modified = list()
-batches = dict() # all sources with the same formatting settings are formatted together
+batches = dict()  # all sources with the same formatting settings are formatted together
 for p in projects:
 if p.native:
 continue
 sourceDirs = p.source_dirs()
 batch = Batch(join(p.dir, '.settings', 'org.eclipse.jdt.core.prefs'))
 if not exists(batch.path):
 if _opts.verbose:
 log('[no Eclipse Code Formatter preferences at {0} - skipping]'.format(batch.path))
 for batch in batches.itervalues():
 run([args.eclipse_exe, '-nosplash', '-application', 'org.eclipse.jdt.core.JavaCodeFormatter', '-config', batch.path] + [f.path for f in batch.javafiles])
 for fi in batch.javafiles:
 if fi.update():
 modified.append(fi)
 log('{0} files were modified'.format(len(modified)))
 if len(modified) != 0:
 if args.backup:
 backup = os.path.abspath('eclipseformat.backup.zip')
 arcbase = _mainSuite.dir
 log('Wrote backup of {0} modified files to {1}'.format(len(modified), backup))
 return 1
 return 0
 def processorjars():
 projs = set()
 for p in sorted_deps():
 if _isAnnotationProcessorDependency(p):
 projs.add(p)
 if len(projs) < 0:
 return
 pnames = [p.name for p in projs]
 build(['--projects', ",".join(pnames)])
 archive(pnames)
 def archive(args):
 """create jar files for projects and distributions"""
-parser = ArgumentParser(prog='mx archive');
+parser = ArgumentParser(prog='mx archive')
 parser.add_argument('names', nargs=REMAINDER, metavar='[<project>|@<distribution>]...')
 args = parser.parse_args(args)
 for name in args.names:
 if name.startswith('@'):
 dname = name[1:]
 d = distribution(dname)
 fd, tmp = tempfile.mkstemp(suffix='', prefix=basename(d.path) + '.', dir=dirname(d.path))
 services = tempfile.mkdtemp(suffix='', prefix=basename(d.path) + '.', dir=dirname(d.path))
 def overwriteCheck(zf, arcname, source):
 if arcname in zf.namelist():
 log('warning: ' + d.path + ': overwriting ' + arcname + ' [source: ' + source + ']')
 try:
 zf = zipfile.ZipFile(tmp, 'w')
 for dep in sorted_deps(d.deps, includeLibs=True):
 if dep.isLibrary():
 l = dep
 p = dep
 # skip a  Java project if its Java compliance level is "higher" than the configured JDK
 if java().javaCompliance < p.javaCompliance:
 log('Excluding {0} from {2} (Java compliance level {1} required)'.format(p.name, p.javaCompliance, d.path))
 continue
 logv('[' + d.path + ': adding project ' + p.name + ']')
 outputDir = p.output_dir()
 for root, _, files in os.walk(outputDir):
 relpath = root[len(outputDir) + 1:]
 if relpath == join('META-INF', 'services'):
 zf.close()
 os.close(fd)
 shutil.rmtree(services)
 # Atomic on Unix
 shutil.move(tmp, d.path)
-#print time.time(), 'move:', tmp, '->', d.path
+# print time.time(), 'move:', tmp, '->', d.path
 d.notify_updated()
 finally:
 if exists(tmp):
 os.remove(tmp)
 if exists(services):
 m = pattern.match(line)
 if m is None:
 out.write(line + '\n')
 else:
 p = project(m.group(1))
 for pkg in p.defined_java_packages():
 if not pkg.startswith(p.name):
 abort('package in {0} does not have prefix matching project name: {1}'.format(p, pkg))
 ignoredDeps = set([name for name in p.deps if project(name, False) is not None])
 for pkg in p.imported_java_packages():
 for name in p.deps:
 dep = project(name, False)
 if dep is None:
 if pkg in dep.defined_java_packages():
 ignoredDeps.discard(name)
 if pkg in dep.extended_java_packages():
 ignoredDeps.discard(name)
 if len(ignoredDeps) != 0:
-candidates = set();
+candidates = set()
 # Compute dependencies based on projects required by p
 for d in sorted_deps():
 if not d.defined_java_packages().isdisjoint(p.imported_java_packages()):
 candidates.add(d)
 # Remove non-canonical candidates
 for c in list(candidates):
 candidates.difference_update(c.all_deps([], False, False))
 candidates = [d.name for d in candidates]
 abort('{0}:{1}: {2} does not use any packages defined in these projects: {3}\nComputed project dependencies: {4}'.format(
 projectsFile, lineNo, p, ', '.join(ignoredDeps), ','.join(candidates)))
 out.write('project@' + m.group(1) + '@dependencies=' + ','.join(p.canonical_deps()) + '\n')
 lineNo = lineNo + 1
 content = out.getvalue()
 if update_file(projectsFile, content):
 changedFiles += 1
-return changedFiles;
+return changedFiles
 def checkstyle(args):
 """run Checkstyle on the Java sources
 Run Checkstyle over the Java sources. Any errors or warnings
 parser = ArgumentParser(prog='mx checkstyle')
 parser.add_argument('-f', action='store_true', dest='force', help='force checking (disables timestamp checking)')
 args = parser.parse_args(args)
 totalErrors = 0
 for p in sorted_deps():
 if p.native:
 continue
 sourceDirs = p.source_dirs()
 dotCheckstyle = join(p.dir, '.checkstyle')
 if not exists(dotCheckstyle):
 continue
 # skip checking this Java project if its Java compliance level is "higher" than the configured JDK
 if java().javaCompliance < p.javaCompliance:
 log('Excluding {0} from checking (Java compliance level {1} required)'.format(p.name, p.javaCompliance))
 continue
 try:
 run_java(['-Xmx1g', '-jar', library('CHECKSTYLE').get_path(True), '-f', 'xml', '-c', config, '-o', auditfileName] + batch, nonZeroIsFatal=False)
 finally:
 if exists(auditfileName):
 errors = []
-source = None
+source = [None]
 def start_element(name, attrs):
 if name == 'file':
-global source
+source[0] = attrs['name']
-source = attrs['name']
 elif name == 'error':
-errors.append('{}:{}: {}'.format(source, attrs['line'], attrs['message']))
+errors.append('{}:{}: {}'.format(source[0], attrs['line'], attrs['message']))
 p = xml.parsers.expat.ParserCreate()
 p.StartElementHandler = start_element
 with open(auditfileName) as fp:
 p.ParseFile(fp)
 generated images.
 """
 suppliedParser = parser is not None
-parser = parser if suppliedParser else ArgumentParser(prog='mx build');
+parser = parser if suppliedParser else ArgumentParser(prog='mx build')
 parser.add_argument('--no-native', action='store_false', dest='native', help='do not clean native projects')
 parser.add_argument('--no-java', action='store_false', dest='java', help='do not clean Java projects')
 args = parser.parse_args(args)
 if p.native:
 if args.native:
 run([gmake_cmd(), '-C', p.dir, 'clean'])
 else:
 if args.java:
-genDir = p.source_gen_dir();
+genDir = p.source_gen_dir()
 if genDir != '' and exists(genDir):
 log('Clearing {0}...'.format(genDir))
 for f in os.listdir(genDir):
 shutil.rmtree(join(genDir, f))
 outputDir = p.output_dir()
 if outputDir != '' and exists(outputDir):
 log('Removing {0}...'.format(outputDir))
 shutil.rmtree(outputDir)
 if len(args) == 0:
 _argParser.print_help()
 return
 name = args[0]
-if not commands.has_key(name):
+if not _commands.has_key(name):
-hits = [c for c in commands.iterkeys() if c.startswith(name)]
+hits = [c for c in _commands.iterkeys() if c.startswith(name)]
 if len(hits) == 1:
 name = hits[0]
 elif len(hits) == 0:
 abort('mx: unknown command \'{0}\'\n{1}use "mx help" for more options'.format(name, _format_commands()))
 else:
 abort('mx: command \'{0}\' is ambiguous\n    {1}'.format(name, ' '.join(hits)))
-value = commands[name]
+value = _commands[name]
 (func, usage) = value[:2]
 doc = func.__doc__
 if len(value) > 2:
 docArgs = value[2:]
 fmtArgs = []
 slm.close('sourceContainers')
 slm.close('sourceLookupDirector')
 return slm
-def make_eclipse_attach(hostname, port, name=None, deps=[]):
+def make_eclipse_attach(hostname, port, name=None, deps=None):
 """
 Creates an Eclipse launch configuration file for attaching to a Java process.
 """
+if deps is None:
+deps = []
 slm = _source_locator_memento(deps)
 launch = XMLDoc()
 launch.open('launchConfiguration', {'type' : 'org.eclipse.jdt.launching.remoteJavaApplication'})
 launch.element('stringAttribute', {'key' : 'org.eclipse.debug.core.source_locator_id', 'value' : 'org.eclipse.jdt.launching.sourceLocator.JavaSourceLookupDirector'})
 launch.element('stringAttribute', {'key' : 'org.eclipse.debug.core.source_locator_memento', 'value' : '%s'})
 eclipseLaunches = join('mx', 'eclipse-launches')
 if not exists(eclipseLaunches):
 os.makedirs(eclipseLaunches)
 return update_file(join(eclipseLaunches, name + '.launch'), launch)
-def make_eclipse_launch(javaArgs, jre, name=None, deps=[]):
+def make_eclipse_launch(javaArgs, jre, name=None, deps=None):
 """
 Creates an Eclipse launch configuration file for running/debugging a Java command.
 """
+if deps is None:
+deps = []
 mainClass = None
 vmArgs = []
 appArgs = []
 cp = None
 argsCopy = list(reversed(javaArgs))
 def eclipseinit(args, suite=None, buildProcessorJars=True):
 """(re)generate Eclipse project configurations and working sets"""
 if suite is None:
 suite = _mainSuite
 if buildProcessorJars:
 processorjars()
 projToDist = dict()
 for dist in _dists.values():
 if not exists(srcDir):
 os.mkdir(srcDir)
 out.element('classpathentry', {'kind' : 'src', 'path' : src})
 if len(p.annotation_processors()) > 0:
-genDir = p.source_gen_dir();
+genDir = p.source_gen_dir()
 if not exists(genDir):
 os.mkdir(genDir)
 out.element('classpathentry', {'kind' : 'src', 'path' : 'src_gen'})
 # Every Java program depends on the JRE
 out.element('classpathentry', {'kind' : 'con', 'path' : 'org.eclipse.jdt.launching.JRE_CONTAINER'})
-if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project
+if exists(join(p.dir, 'plugin.xml')):  # eclipse plugin project
 out.element('classpathentry', {'kind' : 'con', 'path' : 'org.eclipse.pde.core.requiredPlugins'})
 for dep in p.all_deps([], True):
 if dep == p:
-continue;
+continue
 if dep.isLibrary():
 if hasattr(dep, 'eclipse.container'):
 out.element('classpathentry', {'exported' : 'true', 'kind' : 'con', 'path' : getattr(dep, 'eclipse.container')})
 elif hasattr(dep, 'eclipse.project'):
 if exists(csConfig):
 out.open('buildCommand')
 out.element('name', data='net.sf.eclipsecs.core.CheckstyleBuilder')
 out.element('arguments', data='')
 out.close('buildCommand')
-if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project
+if exists(join(p.dir, 'plugin.xml')):  # eclipse plugin project
 for buildCommand in ['org.eclipse.pde.ManifestBuilder', 'org.eclipse.pde.SchemaBuilder']:
 out.open('buildCommand')
 out.element('name', data=buildCommand)
 out.element('arguments', data='')
 out.close('buildCommand')
 if _isAnnotationProcessorDependency(p):
-_genEclipseBuilder(out, p, 'Jar.launch', 'archive ' + p.name, refresh = False, async = False, xmlIndent='', xmlStandalone='no')
+_genEclipseBuilder(out, p, 'Jar.launch', 'archive ' + p.name, refresh=False, async=False, xmlIndent='', xmlStandalone='no')
-_genEclipseBuilder(out, p, 'Refresh.launch', '', refresh = True, async = True)
+_genEclipseBuilder(out, p, 'Refresh.launch', '', refresh=True, async=True)
 if projToDist.has_key(p.name):
 dist, distDeps = projToDist[p.name]
 _genEclipseBuilder(out, p, 'Create' + dist.name + 'Dist.launch', 'archive @' + dist.name, refresh=False, async=True)
 out.close('buildSpec')
 out.open('natures')
 out.element('nature', data='org.eclipse.jdt.core.javanature')
 if exists(csConfig):
 out.element('nature', data='net.sf.eclipsecs.core.CheckstyleNature')
-if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project
+if exists(join(p.dir, 'plugin.xml')):  # eclipse plugin project
 out.element('nature', data='org.eclipse.pde.PluginNature')
 out.close('natures')
 out.close('projectDescription')
 update_file(join(p.dir, '.project'), out.xml(indent='\t', newl='\n'))
 content = f.read()
 content = content.replace('${javaCompliance}', str(p.javaCompliance))
 if len(p.annotation_processors()) > 0:
 content = content.replace('org.eclipse.jdt.core.compiler.processAnnotations=disabled', 'org.eclipse.jdt.core.compiler.processAnnotations=enabled')
 update_file(join(settingsDir, name), content)
 if len(p.annotation_processors()) > 0:
 out = XMLDoc()
 out.open('factorypath')
 out.element('factorypathentry', {'kind' : 'PLUGIN', 'id' : 'org.eclipse.jst.ws.annotations.core', 'enabled' : 'true', 'runInBatchMode' : 'false'})
 for ap in p.annotation_processors():
 Determines if a given project is part of an annotation processor.
 """
 return p in sorted_deps(annotation_processors())
 def _genEclipseBuilder(dotProjectDoc, p, name, mxCommand, refresh=True, async=False, logToConsole=False, xmlIndent='\t', xmlStandalone=None):
-launchOut = XMLDoc();
+launchOut = XMLDoc()
 consoleOn = 'true' if logToConsole else 'false'
 launchOut.open('launchConfiguration', {'type' : 'org.eclipse.ui.externaltools.ProgramBuilderLaunchConfigurationType'})
-launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.core.capture_output',                'value': consoleOn})
+launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.core.capture_output', 'value': consoleOn})
 launchOut.open('mapAttribute', {'key' : 'org.eclipse.debug.core.environmentVariables'})
-launchOut.element('mapEntry', {'key' : 'JAVA_HOME',	'value' : java().jdk})
+launchOut.element('mapEntry', {'key' : 'JAVA_HOME', 	'value' : java().jdk})
 launchOut.close('mapAttribute')
 if refresh:
-launchOut.element('stringAttribute',  {'key' : 'org.eclipse.debug.core.ATTR_REFRESH_SCOPE',            'value': '${project}'})
+launchOut.element('stringAttribute', {'key' : 'org.eclipse.debug.core.ATTR_REFRESH_SCOPE', 'value': '${project}'})
-launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.ui.ATTR_CONSOLE_OUTPUT_ON',          'value': consoleOn})
+launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.ui.ATTR_CONSOLE_OUTPUT_ON', 'value': consoleOn})
-launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND',       'value': 'true' if async else 'false'})
+launchOut.element('booleanAttribute', {'key' : 'org.eclipse.debug.ui.ATTR_LAUNCH_IN_BACKGROUND', 'value': 'true' if async else 'false'})
 baseDir = dirname(dirname(os.path.abspath(__file__)))
 cmd = 'mx.sh'
 if get_os() == 'windows':
 cmd = 'mx.cmd'
-launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_LOCATION',           'value': join(baseDir, cmd) })
+launchOut.element('stringAttribute', {'key' : 'org.eclipse.ui.externaltools.ATTR_LOCATION', 'value': join(baseDir, cmd) })
-launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS',    'value': 'auto,full,incremental'})
+launchOut.element('stringAttribute', {'key' : 'org.eclipse.ui.externaltools.ATTR_RUN_BUILD_KINDS', 'value': 'auto,full,incremental'})
-launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS',     'value': mxCommand})
+launchOut.element('stringAttribute', {'key' : 'org.eclipse.ui.externaltools.ATTR_TOOL_ARGUMENTS', 'value': mxCommand})
-launchOut.element('booleanAttribute', {'key' : 'org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED','value': 'true'})
+launchOut.element('booleanAttribute', {'key' : 'org.eclipse.ui.externaltools.ATTR_TRIGGERS_CONFIGURED', 'value': 'true'})
-launchOut.element('stringAttribute',  {'key' : 'org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY',  'value': p.suite.dir})
+launchOut.element('stringAttribute', {'key' : 'org.eclipse.ui.externaltools.ATTR_WORKING_DIRECTORY', 'value': p.suite.dir})
 launchOut.close('launchConfiguration')
 externalToolDir = join(p.dir, '.externalToolBuilders')
 if not exists(externalToolDir):
 os.makedirs(externalToolDir)
 update_file(join(externalToolDir, name), launchOut.xml(indent=xmlIndent, standalone=xmlStandalone, newl='\n'))
 dotProjectDoc.open('buildCommand')
 dotProjectDoc.element('name', data='org.eclipse.ui.externaltools.ExternalToolBuilder')
 dotProjectDoc.element('triggers', data='auto,full,incremental,')
 dotProjectDoc.open('arguments')
 dotProjectDoc.open('dictionary')
-dotProjectDoc.element('key', data = 'LaunchConfigHandle')
+dotProjectDoc.element('key', data='LaunchConfigHandle')
-dotProjectDoc.element('value', data = '<project>/.externalToolBuilders/' + name)
+dotProjectDoc.element('value', data='<project>/.externalToolBuilders/' + name)
 dotProjectDoc.close('dictionary')
 dotProjectDoc.open('dictionary')
-dotProjectDoc.element('key', data = 'incclean')
+dotProjectDoc.element('key', data='incclean')
-dotProjectDoc.element('value', data = 'true')
+dotProjectDoc.element('value', data='true')
 dotProjectDoc.close('dictionary')
 dotProjectDoc.close('arguments')
 dotProjectDoc.close('buildCommand')
 def generate_eclipse_workingsets(suite):
 """
 Populate the workspace's working set configuration with working sets generated from project data.
 If the workspace already contains working set definitions, the existing ones will be retained and extended.
 In case mx/env does not contain a WORKSPACE definition pointing to the workspace root directory, the Graal project root directory will be assumed.
 If no workspace root directory can be identified, the Graal project root directory is used and the user has to place the workingsets.xml file by hand.
 """
 # identify the location where to look for workingsets.xml
 wsfilename = 'workingsets.xml'
 wsroot = suite.dir
 if os.environ.has_key('WORKSPACE'):
 wsroot = os.environ['WORKSPACE']
 wsdir = join(wsroot, '.metadata/.plugins/org.eclipse.ui.workbench')
 if not exists(wsdir):
 wsdir = wsroot
 wspath = join(wsdir, wsfilename)
 # gather working set info from project data
 workingSets = dict()
 for p in projects():
 if p.workingSets is None:
 continue
 for w in p.workingSets.split(","):
 if not workingSets.has_key(w):
 workingSets[w] = [p.name]
 else:
 workingSets[w].append(p.name)
 if exists(wspath):
 wsdoc = _copy_workingset_xml(wspath, workingSets)
 else:
 wsdoc = _make_workingset_xml(workingSets)
 update_file(wspath, wsdoc.xml(newl='\n'))
 def _make_workingset_xml(workingSets):
 wsdoc = XMLDoc()
 wsdoc.open('workingSetManager')
 for w in sorted(workingSets.keys()):
 _workingset_open(wsdoc, w)
 for p in workingSets[w]:
 _workingset_element(wsdoc, p)
 wsdoc.close('workingSet')
 wsdoc.close('workingSetManager')
 return wsdoc
 def _copy_workingset_xml(wspath, workingSets):
 target = XMLDoc()
 target.open('workingSetManager')
 parser = xml.parsers.expat.ParserCreate()
 class ParserState(object):
 def __init__(self):
 self.current_ws_name = 'none yet'
 self.current_ws = None
 self.seen_ws = list()
 self.seen_projects = list()
 ps = ParserState()
 # parsing logic
 def _ws_start(name, attributes):
 if name == 'workingSet':
 ps.current_ws_name = attributes['name']
 if workingSets.has_key(ps.current_ws_name):
 ps.seen_projects = list()
 else:
 ps.current_ws = None
 target.open(name, attributes)
 parser.StartElementHandler = _ws_item
 def _ws_end(name):
 if name == 'workingSet':
 if not ps.current_ws is None:
 for p in ps.current_ws:
 if not p in ps.seen_projects:
 if not w in ps.seen_ws:
 _workingset_open(target, w)
 for p in workingSets[w]:
 _workingset_element(target, p)
 target.close('workingSet')
 def _ws_item(name, attributes):
 if name == 'item':
 if ps.current_ws is None:
 target.element(name, attributes)
 else:
-p_name = attributes['elementID'][1:] # strip off the leading '='
+p_name = attributes['elementID'][1:]  # strip off the leading '='
 _workingset_element(target, p_name)
 ps.seen_projects.append(p_name)
 # process document
 parser.StartElementHandler = _ws_start
 parser.EndElementHandler = _ws_end
 with open(wspath, 'r') as wsfile:
 parser.ParseFile(wsfile)
 target.close('workingSetManager')
 return target
 def _workingset_open(wsdoc, ws):
 wsdoc.open('workingSet', {'editPageID': 'org.eclipse.jdt.ui.JavaWorkingSetPage', 'factoryID': 'org.eclipse.ui.internal.WorkingSetFactory', 'id': 'wsid_' + ws, 'label': ws, 'name': ws})
 def _workingset_element(wsdoc, p):
 wsdoc.element('item', {'elementID': '=' + p, 'factoryID': 'org.eclipse.jdt.ui.PersistableJavaElementFactory'})
 def netbeansinit(args, suite=None):
 """(re)generate NetBeans project configurations"""
 if suite is None:
 suite = _mainSuite
-def println(out, obj):
-out.write(str(obj) + '\n')
 updated = False
 for p in projects():
 if p.native:
 continue
-if exists(join(p.dir, 'plugin.xml')): # eclipse plugin project
+if exists(join(p.dir, 'plugin.xml')):  # eclipse plugin project
 continue
 if not exists(join(p.dir, 'nbproject')):
 os.makedirs(join(p.dir, 'nbproject'))
 out.close('data')
 firstDep = True
 for dep in p.all_deps([], True):
 if dep == p:
-continue;
+continue
 if not dep.isLibrary():
 n = dep.name.replace('.', '_')
 if firstDep:
 out.open('references', {'xmlns' : 'http://www.netbeans.org/ns/ant-project-references/1'})
 mainSrc = False
 else:
 print >> out, 'src.' + src + '.dir=${' + ref + '}'
 javacClasspath = []
 deps = p.all_deps([], True)
 annotationProcessorOnlyDeps = []
 if len(p.annotation_processors()) > 0:
 for ap in p.annotation_processors():
 apDep = dependency(ap)
 if not apDep in deps:
 deps.append(apDep)
 annotationProcessorOnlyDeps.append(apDep)
-annotationProcessorReferences = [];
+annotationProcessorReferences = []
 for dep in deps:
 if dep == p:
-continue;
+continue
 if dep.isLibrary():
 if not dep.mustExist:
 continue
 path = dep.get_path(resolve=True)
 if not dep in annotationProcessorOnlyDeps:
 javacClasspath.append('${' + ref + '}')
 else:
 annotationProcessorReferences.append('${' + ref + '}')
-annotationProcessorReferences +=  ":\\\n    ${" + ref + "}"
+annotationProcessorReferences += ":\\\n    ${" + ref + "}"
 print >> out, 'javac.classpath=\\\n    ' + (os.pathsep + '\\\n    ').join(javacClasspath)
 print >> out, 'javac.test.processorpath=${javac.test.classpath}\\\n    ' + (os.pathsep + '\\\n    ').join(annotationProcessorReferences)
 print >> out, 'javac.processorpath=${javac.classpath}\\\n    ' + (os.pathsep + '\\\n    ').join(annotationProcessorReferences)
 updated = update_file(join(p.dir, 'nbproject', 'project.properties'), out.getvalue()) or updated
 out.close()
 if updated:
 log('If using NetBeans:')
 rm(join(p.dir, 'eclipse-build.xml'))
 try:
 rm(join(p.dir, p.name + '.jar'))
 except:
 log("Error removing {0}".format(p.name + '.jar'))
 def ideinit(args, suite=None):
 """(re)generate Eclipse and NetBeans project configurations"""
 eclipseinit(args, suite)
 netbeansinit(args, suite)
 assess_candidate(d, projects)
 if not assess_candidate(p, projects):
 logv('[package-list file exists - skipping {0}]'.format(p.name))
-def find_packages(sourceDirs, pkgs=set()):
+def find_packages(sourceDirs, pkgs=None):
+if pkgs is None:
+pkgs = set()
 for sourceDir in sourceDirs:
 for root, _, files in os.walk(sourceDir):
 if len([name for name in files if name.endswith('.java')]) != 0:
-pkg = root[len(sourceDir) + 1:].replace(os.sep,'.')
+pkg = root[len(sourceDir) + 1:].replace(os.sep, '.')
 if len(packages) == 0 or pkg in packages:
 if len(exclude_packages) == 0 or not pkg in exclude_packages:
 pkgs.add(pkg)
 return pkgs
 if not args.unified:
 for p in projects:
 # The project must be built to ensure javadoc can find class files for all referenced classes
 build(['--no-native', '--projects', p.name])
 pkgs = find_packages(p.source_dirs(), set())
 deps = p.all_deps([], includeLibs=False, includeSelf=False)
 links = ['-link', 'http://docs.oracle.com/javase/' + str(p.javaCompliance.value) + '/docs/api/']
 out = outDir(p)
 for d in deps:
 list(pkgs))
 log('Generated {2} for {0} in {1}'.format(p.name, out, docDir))
 finally:
 if delOverviewFile:
 os.remove(overviewFile)
 else:
 # The projects must be built to ensure javadoc can find class files for all referenced classes
 build(['--no-native'])
 pkgs = set()
 sp = []
 names = []
 for p in projects:
 find_packages(p.source_dirs(), pkgs)
 else:
 rindex = lindex + len(self.ldelim)
 rdelimLen = 0
 old = content[lindex:rindex + rdelimLen]
 return content.replace(old, repl)
 # Post-process an overview-summary.html file to move the
 # complete overview to the top of the page
 def _fix_overview_summary(path, topLink):
 """
 Processes an "overview-summary.html" generated by javadoc to put the complete
 <!-- ======= START OF BOTTOM NAVBAR ====== -->""")
 assert chunk1.text, 'Could not find header section in ' + path
 assert chunk2.text, 'Could not find footer section in ' + path
-content = chunk1.replace(content, '<div class="header"><div class="subTitle"><div class="block">' + topLink + chunk2.text +'</div></div></div>')
+content = chunk1.replace(content, '<div class="header"><div class="subTitle"><div class="block">' + topLink + chunk2.text + '</div></div></div>')
 content = chunk2.replace(content, '')
 with open(path, 'w') as fp:
 fp.write(content)
 <!-- ======= START OF BOTTOM NAVBAR ====== -->""")
 if chunk1.text:
 if chunk2.text:
 repl = re.sub(r'<h2 title=(.*) Description</h2>', r'<h1 title=\1</h1>', chunk2.text, 1)
-content = chunk1.replace(content, '<div class="header">' + repl +'</div></div>')
+content = chunk1.replace(content, '<div class="header">' + repl + '</div></div>')
 content = chunk2.replace(content, '')
 with open(path, 'w') as fp:
 fp.write(content)
 else:
 log('warning: Could not find package description detail section in ' + path)
 <caption><span>Projects</span><span class="tabEnd">&nbsp;</span></caption>
 <tr><th class="colFirst" scope="col">Project</th><th class="colLast" scope="col">&nbsp;</th></tr>
 <tbody>"""
 color = 'row'
 for p in projects:
-print >> fp2, '<tr class="{1}Color"><td class="colFirst"><a href="../{0}/javadoc/index.html", target = "_top">{0}</a></td><td class="colLast">&nbsp;</td></tr>'.format(p.name, color)
+print >> fp2, '<tr class="{1}Color"><td class="colFirst"><a href="../{0}/javadoc/index.html",target = "_top">{0}</a></td><td class="colLast">&nbsp;</td></tr>'.format(p.name, color)
 color = 'row' if color == 'alt' else 'alt'
 print >> fp2, '</tbody></table></div>'
 print >> fp2, content[idx:]
 title = args.title if args.title is not None else args.name
 javadoc(['--base', tmpbase,
 '--unified',
 '--arg', '@-windowtitle', '--arg', '@' + title,
 '--arg', '@-doctitle', '--arg', '@' + title,
 dotErr = None
 try:
 if not 'version' in subprocess.check_output(['dot', '-V'], stderr=subprocess.STDOUT):
 dotErr = 'dot -V does not print a string containing "version"'
 except subprocess.CalledProcessError as e:
 dotErr = 'error calling "dot -V": {}'.format(e)
 except OSError as e:
 dotErr = 'error calling "dot -V": {}'.format(e)
 if dotErr != None:
 abort('cannot generate dependency graph: ' + dotErr)
 dot = join(tmpbase, 'all', str(args.dot_output_base) + '.dot')
 svg = join(tmpbase, 'all', str(args.dot_output_base) + '.svg')
 dim = len(projects)
 print >> fp, 'digraph projects {'
 print >> fp, 'rankdir=BT;'
 print >> fp, 'size = "' + str(dim) + ',' + str(dim) + '";'
 print >> fp, 'node [shape=rect, fontcolor="blue"];'
-#print >> fp, 'edge [color="green"];'
+# print >> fp, 'edge [color="green"];'
 for p in projects:
 print >> fp, '"' + p.name + '" [URL = "../' + p.name + '/javadoc/index.html", target = "_top"]'
 for dep in p.canonical_deps():
 if dep in [proj.name for proj in projects]:
 print >> fp, '"' + p.name + '" -> "' + dep + '"'
 depths = dict()
 for p in projects:
 d = p.max_depth()
 depths.setdefault(d, list()).append(p.name)
 print >> fp, '}'
 run(['dot', '-Tsvg', '-o' + svg, '-Tjpg', '-o' + jpg, dot])
 # Post-process generated SVG to remove title elements which most browsers
 # render as redundant (and annoying) tooltips.
 with open(svg, 'r') as fp:
 content = fp.read()
 content = re.sub('<title>.*</title>', '', content)
 content = re.sub('xlink:title="[^"]*"', '', content)
 with open(svg, 'w') as fp:
 fp.write(content)
 # Create HTML that embeds the svg file in an <object> frame
 with open(html, 'w') as fp:
 print >> fp, '<html><body><object data="{}.svg" type="image/svg+xml"></object></body></html>'.format(args.dot_output_base)
 top = join(tmpbase, 'all', 'overview-summary.html')
 return matches
 def select_items(items, descriptions=None, allowMultiple=True):
 """
 Presents a command line interface for selecting one or more (if allowMultiple is true) items.
 """
 if len(items) <= 1:
 return items
 else:
 if allowMultiple:
 try:
 s = [int(x) for x in s]
 except:
 log('Selection contains non-numeric characters: "' + ' '.join(s) + '"')
 continue
 if allowMultiple and 0 in s:
 return items
 indexes = []
 for n in s:
 if n not in range(1, len(items) + 1):
 log('Invalid selection: ' + str(n))
 continue
 return None
 def javap(args):
 """disassemble classes matching given pattern with javap"""
-javap = java().javap
+javapExe = java().javap
-if not exists(javap):
+if not exists(javapExe):
-abort('The javap executable does not exists: ' + javap)
+abort('The javap executable does not exists: ' + javapExe)
 else:
 candidates = findclass(args, logToConsole=False)
 if len(candidates) == 0:
 log('no matches')
 selection = select_items(candidates)
-run([javap, '-private', '-verbose', '-classpath', classpath()] + selection)
+run([javapExe, '-private', '-verbose', '-classpath', classpath()] + selection)
 def show_projects(args):
 """show all loaded projects"""
 for s in suites():
 projectsFile = join(s.dir, 'mx', 'projects')
 if exists(projectsFile):
 log(projectsFile)
 for p in s.projects:
 log('\t' + p.name)
 def ask_yes_no(question, default=None):
 """"""
 assert not default or default == 'y' or default == 'n'
 if not sys.stdout.isatty():
 if default:
 # Table of commands in alphabetical order.
 # Keys are command names, value are lists: [<function>, <usage msg>, <format args to doc string of function>...]
 # If any of the format args are instances of Callable, then they are called with an 'env' are before being
 # used in the call to str.format().
 # Extensions should update this table directly
-commands = {
+_commands = {
 'about': [about, ''],
 'build': [build, '[options]'],
 'checkstyle': [checkstyle, ''],
 'canonicalizeprojects': [canonicalizeprojects, ''],
 'clean': [clean, ''],
 return
 command = commandAndArgs[0]
 command_args = commandAndArgs[1:]
-if not commands.has_key(command):
+if not _commands.has_key(command):
-hits = [c for c in commands.iterkeys() if c.startswith(command)]
+hits = [c for c in _commands.iterkeys() if c.startswith(command)]
 if len(hits) == 1:
 command = hits[0]
 elif len(hits) == 0:
 abort('mx: unknown command \'{0}\'\n{1}use "mx help" for more options'.format(command, _format_commands()))
 else:
 abort('mx: command \'{0}\' is ambiguous\n    {1}'.format(command, ' '.join(hits)))
-c, _ = commands[command][:2]
+c, _ = _commands[command][:2]
 def term_handler(signum, frame):
 abort(1)
 signal.signal(signal.SIGTERM, term_handler)
 try:
 if opts.timeout != 0:

Mercurial > hg > graal-jvmci-8

comparison mxtool/mx.py @ 11514:dc3c8df55905