truffle: mxtool/mx.py comparison

comparison mxtool/mx.py @ 18876:c446d00f2cdf

mx: added support for Jython 2.7b3 and made ordering in generated files more deterministic\nContributed-by: Igor Ignatyev <igor.ignatyev@oracle.com>

author	Doug Simon <doug.simon@oracle.com>
date	Sat, 17 Jan 2015 11:26:18 +0100
parents	c3bb622095f1
children	19d99eec8876 765bc32a4311

comparison

equal deleted inserted replaced

-:d71bf1009d71
+:c446d00f2cdf
 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.
 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.
 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=[])
 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
 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)
 _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)
 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:
 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')
 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 > truffle

comparison mxtool/mx.py @ 18876:c446d00f2cdf