graal-compiler: mxtool/mx.py comparison

comparison mxtool/mx.py @ 19033:74b144f7c54a

Merge.

author	Josef Eisl <josef.eisl@jku.at>
date	Wed, 28 Jan 2015 19:32:47 +0100
parents	9aa1cff041eb
children	258b3658845a

comparison

equal deleted inserted replaced

-:b646e37bc989
+:74b144f7c54a
 #!/usr/bin/env python2.7
 #
 # ----------------------------------------------------------------------------------------------------
 #
-# Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.
 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 #
 # This code is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License version 2 only, as
 # published by the Free Software Foundation.
 Full documentation can be found at https://wiki.openjdk.java.net/display/Graal/The+mx+Tool
 """
 import sys, os, errno, time, subprocess, shlex, types, StringIO, zipfile, signal, xml.sax.saxutils, tempfile, fnmatch, platform
-import multiprocessing
 import textwrap
 import socket
 import tarfile
 import hashlib
 import xml.parsers.expat
 cmd = popenargs[0]
 error = subprocess.CalledProcessError(retcode, cmd)
 error.output = output
 raise error
 return output
+# Support for jython
+def is_jython():
+return sys.platform.startswith('java')
+if not is_jython():
+import multiprocessing
+def cpu_count():
+if is_jython():
+from java.lang import Runtime
+runtime = Runtime.getRuntime()
+return runtime.availableProcessors()
+else:
+return multiprocessing.cpu_count()
 try: subprocess.check_output
 except: subprocess.check_output = check_output
 try: zipfile.ZipFile.__enter__
 class Dependency:
 def __init__(self, suite, name):
 self.name = name
 self.suite = suite
+def __cmp__(self, other):
+return cmp(self.name, other.name)
 def __str__(self):
 return self.name
 def __eq__(self, other):
 return self.name == other.name
 def all_deps(self, deps, includeLibs, includeSelf=True, includeJreLibs=False, includeAnnotationProcessors=False):
 """
 Add the transitive set of dependencies for this project, including
 libraries if 'includeLibs' is true, to the 'deps' list.
 """
-return self._all_deps_helper(deps, [], includeLibs, includeSelf, includeJreLibs, includeAnnotationProcessors)
+return sorted(self._all_deps_helper(deps, [], includeLibs, includeSelf, includeJreLibs, includeAnnotationProcessors))
 def _all_deps_helper(self, deps, dependants, includeLibs, includeSelf=True, includeJreLibs=False, includeAnnotationProcessors=False):
 if self in dependants:
 abort(str(self) + 'Project dependency cycle found:\n    ' +
 '\n        |\n        V\n    '.join(map(str, dependants[dependants.index(self):])) +
 aps.add(p.name)
 # Inherit annotation processors from dependencies
 aps.update(p.annotation_processors())
-self._annotationProcessors = list(aps)
+self._annotationProcessors = sorted(list(aps))
 return self._annotationProcessors
 """
 Gets the class path composed of the distribution jars containing the
 annotation processors that will be applied when compiling this project.
 """
 def annotation_processors_path(self):
 aps = [project(ap) for ap in self.annotation_processors()]
-if len(aps):
+libAps = [dep for dep in self.all_deps([], includeLibs=True, includeSelf=False) if dep.isLibrary() and hasattr(dep, 'annotationProcessor') and getattr(dep, 'annotationProcessor').lower() == 'true']
-return os.pathsep.join([ap.definedAnnotationProcessorsDist.path for ap in aps if ap.definedAnnotationProcessorsDist])
+if len(aps) + len(libAps):
+return os.pathsep.join([ap.definedAnnotationProcessorsDist.path for ap in aps if ap.definedAnnotationProcessorsDist] + [lib.get_path(False) for lib in libAps])
 return None
+def uses_annotation_processor_library(self):
+for dep in self.all_deps([], includeLibs=True, includeSelf=False):
+if dep.isLibrary() and hasattr(dep, 'annotationProcessor'):
+return True
+return False
 def update_current_annotation_processors_file(self):
 aps = self.annotation_processors()
 outOfDate = False
 currentApsFile = join(self.suite.mxDir, 'currentAnnotationProcessors', self.name)
 break
 d.update(buf)
 return d.hexdigest()
 def download_file_with_sha1(name, path, urls, sha1, sha1path, resolve, mustExist, sources=False, canSymlink=True):
+canSymlink = canSymlink and not (get_os() == 'windows' or get_os() == 'cygwin')
 def _download_lib():
-cacheDir = get_env('MX_CACHE_DIR', join(_opts.user_home, '.mx', 'cache'))
+cacheDir = _cygpathW2U(get_env('MX_CACHE_DIR', join(_opts.user_home, '.mx', 'cache')))
 if not exists(cacheDir):
 os.makedirs(cacheDir)
 base = basename(path)
 cachePath = join(cacheDir, base + '_' + sha1)
 """
 Add the transitive set of dependencies for this JRE library to the 'deps' list.
 """
 if includeJreLibs and includeSelf and not self in deps:
 deps.append(self)
-return deps
+return sorted(deps)
 class Library(BaseLibrary):
 def __init__(self, suite, name, path, optional, urls, sha1, sourcePath, sourceUrls, sourceSha1, deps):
 BaseLibrary.__init__(self, suite, name, optional)
 self.path = path.replace('/', os.sep)
 def all_deps(self, deps, includeLibs, includeSelf=True, includeJreLibs=False, includeAnnotationProcessors=False):
 """
 Add the transitive set of dependencies for this library to the 'deps' list.
 """
 if not includeLibs:
-return deps
+return sorted(deps)
 childDeps = list(self.deps)
 if self in deps:
-return deps
+return sorted(deps)
 for name in childDeps:
 assert name != self.name
 dep = library(name)
 if not dep in deps:
 dep.all_deps(deps, includeLibs=includeLibs, includeJreLibs=includeJreLibs, includeAnnotationProcessors=includeAnnotationProcessors)
 if not self in deps and includeSelf:
 deps.append(self)
-return deps
+return sorted(deps)
 class HgConfig:
 """
 Encapsulates access to Mercurial (hg)
 """
 return []
 if not isinstance(v, list):
 abort('Attribute "' + name + '" for ' + context + ' must be a list')
 return v
-for name, attrs in projsMap.iteritems():
+for name, attrs in sorted(projsMap.iteritems()):
 context = 'project ' + name
 srcDirs = pop_list(attrs, 'sourceDirs', context)
 deps = pop_list(attrs, 'dependencies', context)
 ap = pop_list(attrs, 'annotationProcessors', context)
 javaCompliance = attrs.pop('javaCompliance', None)
 if len(ap) > 0:
 p._declaredAnnotationProcessors = ap
 p.__dict__.update(attrs)
 self.projects.append(p)
-for name, attrs in jreLibsMap.iteritems():
+for name, attrs in sorted(jreLibsMap.iteritems()):
 jar = attrs.pop('jar')
 # JRE libraries are optional by default
 optional = attrs.pop('optional', 'true') != 'false'
 l = JreLibrary(self, name, jar, optional)
 self.jreLibs.append(l)
-for name, attrs in libsMap.iteritems():
+for name, attrs in sorted(libsMap.iteritems()):
 context = 'library ' + name
 if "|" in name:
 if name.count('|') != 2:
 abort("Format error in library name: " + name + "\nsyntax: libname|os-platform|architecture")
 name, platform, architecture = name.split("|")
 optional = False
 l = Library(self, name, path, optional, urls, sha1, sourcePath, sourceUrls, sourceSha1, deps)
 l.__dict__.update(attrs)
 self.libs.append(l)
-for name, attrs in distsMap.iteritems():
+for name, attrs in sorted(distsMap.iteritems()):
 context = 'distribution ' + name
 path = attrs.pop('path')
 sourcesPath = attrs.pop('sourcesPath', None)
 deps = pop_list(attrs, 'dependencies', context)
 mainClass = attrs.pop('mainClass', None)
 result = xml.sax.saxutils.escape(result, entities)
 if standalone is not None:
 result = result.replace('encoding="UTF-8"?>', 'encoding="UTF-8" standalone="' + str(standalone) + '"?>')
 return result
+def get_jython_os():
+from java.lang import System as System
+os_name = System.getProperty('os.name').lower()
+if System.getProperty('isCygwin'):
+return 'cygwin'
+elif os_name.startswith('mac'):
+return 'darwin'
+elif os_name.startswith('linux'):
+return 'linux'
+elif os_name.startswith('sunos'):
+return 'solaris'
+elif os_name.startswith('win'):
+return 'windows'
+else:
+abort('Unknown operating system ' + os_name)
 def get_os():
 """
 Get a canonical form of sys.platform.
 """
-if sys.platform.startswith('darwin'):
+if is_jython():
+return get_jython_os()
+elif sys.platform.startswith('darwin'):
 return 'darwin'
 elif sys.platform.startswith('linux'):
 return 'linux'
 elif sys.platform.startswith('sunos'):
 return 'solaris'
 Translate a path from unix-style to windows-style.
 This method has no effects on other platforms than cygwin.
 """
 if p is None or get_os() != "cygwin":
 return p
-return subprocess.check_output(['cygpath', '-w', p]).strip()
+return subprocess.check_output(['cygpath', '-a', '-w', p]).strip()
 def _cygpathW2U(p):
 """
 Translate a path from windows-style to unix-style.
 This method has no effects on other platforms than cygwin.
 """
 if p is None or get_os() != "cygwin":
 return p
-return subprocess.check_output(['cygpath', '-u', p]).strip()
+return subprocess.check_output(['cygpath', '-a', '-u', p]).strip()
 def _separatedCygpathU2W(p):
 """
 Translate a group of paths, separated by a path separator.
 unix-style to windows-style.
 deps = []
 for p in projects:
 p.all_deps(deps, includeLibs=includeLibs, includeJreLibs=includeJreLibs, includeAnnotationProcessors=includeAnnotationProcessors)
 return deps
-def _handle_missing_java_home():
+def _handle_lookup_java_home(jdk):
+return _handle_lookup_jdk(jdk, 'JAVA_HOME', '--java-home', False)
+def _handle_lookup_extra_java_homes(jdk):
+return _handle_lookup_jdk(jdk, 'EXTRA_JAVA_HOMES', '--extra-java-homes', True)
+def _handle_lookup_jdk(jdk, varName, flagName, allowMultiple):
+if jdk != None and jdk != '':
+return jdk
+jdk = os.environ.get(varName)
+if jdk != None and jdk != '':
+return jdk
 if not sys.stdout.isatty():
-abort('Could not find bootstrap JDK. Use --java-home option or ensure JAVA_HOME environment variable is set.')
+abort('Could not find bootstrap {0}. Use {1} option or ensure {2} environment variable is set.'.format(varName, flagName, varName))
 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'))]
 base = r'C:\Program Files\Java'
 candidateJdks = [join(base, n) for n in os.listdir(base) if exists(join(base, n, r'jre\lib\rt.jar'))]
 javaHome = None
 if len(candidateJdks) != 0:
-javaHome = select_items(candidateJdks + ['<other>'], allowMultiple=False)
+log('Missing value for {0}.'.format(varName))
+javaHome = select_items(candidateJdks + ['<other>'], allowMultiple=allowMultiple)
 if javaHome == '<other>':
 javaHome = None
+if javaHome != None and allowMultiple:
+javaHome = os.pathsep.join(javaHome)
 while javaHome is None:
-javaHome = raw_input('Enter path of bootstrap JDK: ')
+javaHome = raw_input('Enter path of JDK for {0}: '.format(varName))
 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(_primary_suite.mxDir, 'env')
-if ask_yes_no('Persist this setting by adding "JAVA_HOME=' + javaHome + '" to ' + envPath, 'y'):
+if ask_yes_no('Persist this setting by adding "{0}={1}" to {2}'.format(varName, javaHome, envPath), 'y'):
 with open(envPath, 'a') as fp:
-print >> fp, 'JAVA_HOME=' + javaHome
+print >> fp, varName + '=' + 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('-w', action='store_true', dest='warn', help='enable warning messages')
 self.add_argument('-p', '--primary-suite-path', help='set the primary suite directory', metavar='<path>')
 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('--backup-modified', action='store_true', help='backup generated files if they pre-existed and are modified')
 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>')
 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=[])
 opts.__dict__.setdefault('ptimeout', 0)
 if opts.very_verbose:
 opts.verbose = True
-if opts.java_home is None:
+opts.java_home = _handle_lookup_java_home(opts.java_home)
-opts.java_home = os.environ.get('JAVA_HOME')
+opts.extra_java_homes = _handle_lookup_extra_java_homes(opts.extra_java_homes)
-if opts.extra_java_homes is None:
-opts.extra_java_homes = os.environ.get('EXTRA_JAVA_HOMES')
-if opts.java_home is None or opts.java_home == '':
-opts.java_home = _handle_missing_java_home()
 if opts.user_home is None or opts.user_home == '':
 abort('Could not find user home. Use --user-home option or ensure HOME environment variable is set.')
 os.environ['JAVA_HOME'] = opts.java_home
 assert isinstance(args, types.ListType), "'args' must be a list: " + str(args)
 for arg in args:
 assert isinstance(arg, types.StringTypes), 'argument is not a string: ' + str(arg)
 if env is None:
-env = os.environ
+env = os.environ.copy()
+# Ideally the command line could be communicated directly in an environment
+# variable. However, since environment variables share the same resource
+# space as the command line itself (on Unix at least), this would cause the
+# limit to be exceeded too easily.
+with tempfile.NamedTemporaryFile(suffix='', prefix='mx_subprocess_command.', mode='w', delete=False) as fp:
+subprocessCommandFile = fp.name
+for arg in args:
+# TODO: handle newlines in args once there's a use case
+assert '\n' not in arg
+print >> fp, arg
+env['MX_SUBPROCESS_COMMAND_FILE'] = subprocessCommandFile
 if _opts.verbose:
 if _opts.very_verbose:
 log('Environment variables:')
 for key in sorted(env.keys()):
 try:
 # On Unix, the new subprocess should be in a separate group so that a timeout alarm
 # can use os.killpg() to kill the whole subprocess group
 preexec_fn = None
 creationflags = 0
-if get_os() == 'windows':
+if not is_jython():
-creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
+if get_os() == 'windows':
-else:
+creationflags = subprocess.CREATE_NEW_PROCESS_GROUP
-preexec_fn = os.setsid
+else:
+preexec_fn = os.setsid
 def redirect(stream, f):
 for line in iter(stream.readline, ''):
 f(line)
 stream.close()
 stdout = out if not callable(out) else subprocess.PIPE
 abort(e.errno)
 except KeyboardInterrupt:
 abort(1)
 finally:
 _removeSubprocess(sub)
+os.remove(subprocessCommandFile)
 if retcode and nonZeroIsFatal:
 if _opts.verbose:
 if _opts.very_verbose:
 raise subprocess.CalledProcessError(retcode, ' '.join(args))
 if not exists(outDir):
 os.makedirs(outDir)
 javaSource = join(myDir, 'ClasspathDump.java')
 if not exists(join(outDir, 'ClasspathDump.class')):
 subprocess.check_call([self.javac, '-d', _cygpathU2W(outDir), _cygpathU2W(javaSource)], stderr=subprocess.PIPE, stdout=subprocess.PIPE)
-self._bootclasspath, self._extdirs, self._endorseddirs = [x if x != 'null' else None for x in subprocess.check_output([self.java, '-cp', _separatedCygpathU2W(outDir), 'ClasspathDump'], stderr=subprocess.PIPE).split('|')]
+self._bootclasspath, self._extdirs, self._endorseddirs = [x if x != 'null' else None for x in subprocess.check_output([self.java, '-cp', _cygpathU2W(outDir), 'ClasspathDump'], stderr=subprocess.PIPE).split('|')]
 if not self._bootclasspath or not self._extdirs or not self._endorseddirs:
 warn("Could not find all classpaths: boot='" + str(self._bootclasspath) + "' extdirs='" + str(self._extdirs) + "' endorseddirs='" + str(self._endorseddirs) + "'")
 self._bootclasspath = _filter_non_existant_paths(self._bootclasspath)
 self._extdirs = _filter_non_existant_paths(self._extdirs)
 self._endorseddirs = _filter_non_existant_paths(self._endorseddirs)
+def __repr__(self):
+return "JavaConfig(" + str(self.jdk) + ", " + str(self.debug_port) + ")"
+def __str__(self):
+return "Java " + str(self.version) + " (" + str(self.javaCompliance) + ") from " + str(self.jdk)
 def __hash__(self):
 return hash(self.jdk)
 def __cmp__(self, other):
 if isinstance(other, JavaConfig):
-return cmp(self.javaCompliance, other.javaCompliance)
+compilanceCmp = cmp(self.javaCompliance, other.javaCompliance)
+if compilanceCmp:
+return compilanceCmp
+versionCmp = cmp(self.version, other.version)
+if versionCmp:
+return versionCmp
+return cmp(self.jdk, other.jdk)
 raise TypeError()
 def format_cmd(self, args, addDefaultArgs):
 if addDefaultArgs:
 return [self.java] + self.processArgs(args)
 _send_sigquit()
 def is_alive(p):
 if isinstance(p, subprocess.Popen):
 return p.poll() is None
-assert isinstance(p, multiprocessing.Process), p
+assert is_jython() or isinstance(p, multiprocessing.Process), p
 return p.is_alive()
 for p, args in _currentSubprocesses:
 if is_alive(p):
 try:
 with open(path, 'rb') as f:
 old = f.read()
 if old == content:
 return False
+if existed and _opts.backup_modified:
+shutil.move(path, path + '.orig')
 with open(path, 'wb') as f:
 f.write(content)
 log(('modified ' if existed else 'created ') + path)
 log('JDT properties file {0} not found'.format(jdtProperties))
 else:
 with open(jdtProperties) as fp:
 origContent = fp.read()
 content = origContent
-if args.jdt_warning_as_error:
+if self.proj.uses_annotation_processor_library():
+# unfortunately, the command line compiler doesn't let us ignore warnings for generated files only
+content = content.replace('=warning', '=ignore')
+elif args.jdt_warning_as_error:
 content = content.replace('=warning', '=error')
 if not args.jdt_show_task_tags:
 content = content + '\norg.eclipse.jdt.core.compiler.problem.tasks=ignore'
 if origContent != content:
 jdtPropertiesTmp = jdtProperties + '.tmp'
 parser = ArgumentParser(prog='mx build')
 parser = parser if parser is not None else ArgumentParser(prog='mx build')
 parser.add_argument('-f', action='store_true', dest='force', help='force build (disables timestamp checking)')
 parser.add_argument('-c', action='store_true', dest='clean', help='removes existing build output')
-parser.add_argument('-p', action='store_true', dest='parallelize', help='parallelizes Java compilation')
+parser.add_argument('-p', action='store_true', dest='parallelize', help='parallelizes Java compilation if possible')
 parser.add_argument('--source', dest='compliance', help='Java compliance level for projects without an explicit one')
 parser.add_argument('--Wapi', action='store_true', dest='warnAPI', help='show warnings about using internal APIs')
 parser.add_argument('--projects', action='store', help='comma separated projects to build (omit to build all projects)')
 parser.add_argument('--only', action='store', help='comma separated projects to build, without checking their dependencies (omit to build all projects)')
 parser.add_argument('--no-java', action='store_false', dest='java', help='do not build Java projects')
 if suppliedParser:
 parser.add_argument('remainder', nargs=REMAINDER, metavar='...')
 args = parser.parse_args(args)
+if is_jython():
+if args.parallelize:
+logv('[multiprocessing not available in jython]')
+args.parallelize = False
 jdtJar = None
 if not args.javac and args.jdt is not None:
 if not args.jdt.endswith('.jar'):
 abort('Path for Eclipse batch compiler does not look like a jar file: ' + args.jdt)
 jdtJar = args.jdt
 def sortWorklist(tasks):
 for t in tasks:
 t._d = None
 return sorted(tasks, compareTasks)
-cpus = multiprocessing.cpu_count()
+cpus = cpu_count()
 worklist = sortWorklist(tasks.values())
 active = []
 failed = []
 while len(worklist) != 0:
 while True:
 srcDir = join(p.dir, src)
 if not exists(srcDir):
 os.mkdir(srcDir)
 out.element('classpathentry', {'kind' : 'src', 'path' : src})
-if len(p.annotation_processors()) > 0:
+processorPath = p.annotation_processors_path()
+if processorPath:
 genDir = p.source_gen_dir()
 if not exists(genDir):
 os.mkdir(genDir)
-out.element('classpathentry', {'kind' : 'src', 'path' : 'src_gen'})
+out.open('classpathentry', {'kind' : 'src', 'path' : 'src_gen'})
+if p.uses_annotation_processor_library():
+# ignore warnings produced by third-party annotation processors
+out.open('attributes')
+out.element('attribute', {'name' : 'ignore_optional_problems', 'value' : 'true'})
+out.close('attributes')
+out.close('classpathentry')
 if files:
 files.append(genDir)
 # Every Java program depends on a JRE
 out.element('classpathentry', {'kind' : 'con', 'path' : 'org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-' + str(p.javaCompliance)})
 else:
 libraryDeps.add(dep)
 elif dep.isProject():
 projectDeps.add(dep)
-for dep in containerDeps:
+for dep in sorted(containerDeps):
 out.element('classpathentry', {'exported' : 'true', 'kind' : 'con', 'path' : dep})
-for dep in libraryDeps:
+for dep in sorted(libraryDeps):
 path = dep.path
 dep.get_path(resolve=True)
 # Relative paths for "lib" class path entries have various semantics depending on the Eclipse
 # version being used (e.g. see https://bugs.eclipse.org/bugs/show_bug.cgi?id=274737) so it's
 attributes['sourcepath'] = sourcePath
 out.element('classpathentry', attributes)
 if libFiles:
 libFiles.append(path)
-for dep in projectDeps:
+for dep in sorted(projectDeps):
 out.element('classpathentry', {'combineaccessrules' : 'false', 'exported' : 'true', 'kind' : 'src', 'path' : '/' + dep.name})
 out.element('classpathentry', {'kind' : 'output', 'path' : getattr(p, 'eclipse.output', 'bin')})
 out.close('classpath')
 classpathFile = join(p.dir, '.classpath')
 esdict[name] = os.path.abspath(join(projectSettingsDir, name))
 # copy a possibly modified file to the project's .settings directory
 for name, path in esdict.iteritems():
 # ignore this file altogether if this project has no annotation processors
-if name == "org.eclipse.jdt.apt.core.prefs" and not len(p.annotation_processors()) > 0:
+if name == "org.eclipse.jdt.apt.core.prefs" and not processorPath:
 continue
 with open(path) as f:
 content = f.read()
 content = content.replace('${javaCompliance}', str(p.javaCompliance))
-if len(p.annotation_processors()) > 0:
+if processorPath:
 content = content.replace('org.eclipse.jdt.core.compiler.processAnnotations=disabled', 'org.eclipse.jdt.core.compiler.processAnnotations=enabled')
 update_file(join(settingsDir, name), content)
 if files:
 files.append(join(settingsDir, name))
-processorPath = p.annotation_processors_path()
 if processorPath:
 out = XMLDoc()
 out.open('factorypath')
 out.element('factorypathentry', {'kind' : 'PLUGIN', 'id' : 'org.eclipse.jst.ws.annotations.core', 'enabled' : 'true', 'runInBatchMode' : 'false'})
 for e in processorPath.split(os.pathsep):
 compilerXml.element('entry', attributes={'name': '!?*.java'})
 compilerXml.close('wildcardResourcePatterns')
 if annotationProcessorProfiles:
 compilerXml.open('annotationProcessing')
-for processors, modules in annotationProcessorProfiles.items():
+for processors, modules in sorted(annotationProcessorProfiles.iteritems()):
 compilerXml.open('profile', attributes={'default': 'false', 'name': '-'.join(processors), 'enabled': 'true'})
 compilerXml.element('sourceOutputDir', attributes={'name': 'src_gen'})  # TODO use p.source_gen_dir() ?
 compilerXml.element('outputRelativeToContentRoot', attributes={'value': 'true'})
 compilerXml.open('processorPath', attributes={'useClasspath': 'false'})
 for apName in processors:
 abort('mx: command \'{0}\' is ambiguous\n    {1}'.format(command, ' '.join(hits)))
 c, _ = _commands[command][:2]
 def term_handler(signum, frame):
 abort(1)
-signal.signal(signal.SIGTERM, term_handler)
+if not is_jython():
+signal.signal(signal.SIGTERM, term_handler)
 def quit_handler(signum, frame):
 _send_sigquit()
-if get_os() != 'windows':
+if not is_jython() and get_os() != 'windows':
 signal.signal(signal.SIGQUIT, quit_handler)
 try:
 if opts.timeout != 0:
 def alarm_handler(signum, frame):

Mercurial > hg > graal-compiler

comparison mxtool/mx.py @ 19033:74b144f7c54a