Chiebot-Mirror
/
meson
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge pull request #4204 from xclaesse/unify-cmd-line

Browse Source 
Use a single ArgumentParser for all subcommands
pull/4311/head
Jussi Pakkanen 7 years ago committed by GitHub
parent 019a627f04 adae6b56de
commit 577d6bfdb4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 369 additions and 382 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 10
      mesonbuild/mconf.py
  2. 17
      mesonbuild/mesonlib.py
  3. 464
      mesonbuild/mesonmain.py
  4. 8
      mesonbuild/minit.py
  5. 12
      mesonbuild/minstall.py
  6. 8
      mesonbuild/mintro.py
  7. 197
      mesonbuild/msetup.py
  8. 14
      mesonbuild/mtest.py
  9. 9
      mesonbuild/rewriter.py
  10. 6
      mesonbuild/wrap/wraptool.py
  11. 4
      run_project_tests.py
  12. 2
      run_tests.py

10
mesonbuild/mconf.py
Unescape View File

@ -13,17 +13,13 @@
# limitations under the License. # limitations under the License.
import os import os
import argparse
from . import (coredata, mesonlib, build) from . import (coredata, mesonlib, build)
def buildparser(): def add_arguments(parser):
parser = argparse.ArgumentParser(prog='meson configure')
coredata.register_builtin_arguments(parser) coredata.register_builtin_arguments(parser)
parser.add_argument('builddir', nargs='?', default='.') parser.add_argument('builddir', nargs='?', default='.')
parser.add_argument('--clearcache', action='store_true', default=False, parser.add_argument('--clearcache', action='store_true', default=False,
help='Clear cached state (e.g. found dependencies)') help='Clear cached state (e.g. found dependencies)')
return parser
class ConfException(mesonlib.MesonException): class ConfException(mesonlib.MesonException):
@ -149,9 +145,7 @@ class Conf:
self.print_options('Testing options', test_options) self.print_options('Testing options', test_options)
def run(args): def run(options):
args = mesonlib.expand_arguments(args)
options = buildparser().parse_args(args)
coredata.parse_cmd_line_options(options) coredata.parse_cmd_line_options(options)
builddir = os.path.abspath(os.path.realpath(options.builddir)) builddir = os.path.abspath(os.path.realpath(options.builddir))
try: try:

17
mesonbuild/mesonlib.py
Unescape View File

@ -48,6 +48,23 @@ else:
python_command = [sys.executable] python_command = [sys.executable]
meson_command = None meson_command = None
def set_meson_command(mainfile):
global python_command
global meson_command
# On UNIX-like systems `meson` is a Python script
# On Windows `meson` and `meson.exe` are wrapper exes
if not mainfile.endswith('.py'):
meson_command = [mainfile]
elif os.path.isabs(mainfile) and mainfile.endswith('mesonmain.py'):
# Can't actually run meson with an absolute path to mesonmain.py, it must be run as -m mesonbuild.mesonmain
meson_command = python_command + ['-m', 'mesonbuild.mesonmain']
else:
# Either run uninstalled, or full path to meson-script.py
meson_command = python_command + [mainfile]
# We print this value for unit tests.
if 'MESON_COMMAND_TESTS' in os.environ:
mlog.log('meson_command is {!r}'.format(meson_command))
def is_ascii_string(astring): def is_ascii_string(astring):
try: try:
if isinstance(astring, str): if isinstance(astring, str):

464
mesonbuild/mesonmain.py
Unescape View File

@ -12,261 +12,139 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
import time import sys
import sys, stat, traceback, argparse
import datetime
import os.path import os.path
import platform import importlib
import cProfile as profile import traceback
import argparse
from . import environment, interpreter, mesonlib from . import mesonlib
from . import build from . import mlog
from . import mlog, coredata from . import mconf, minit, minstall, mintro, msetup, mtest, rewriter
from .mesonlib import MesonException from .mesonlib import MesonException
from .environment import detect_msys2_arch from .environment import detect_msys2_arch
from .wrap import WrapMode from .wrap import wraptool
default_warning = '1'
class CommandLineParser:
def create_parser(): def __init__(self):
p = argparse.ArgumentParser(prog='meson') self.commands = {}
coredata.register_builtin_arguments(p) self.hidden_commands = []
p.add_argument('--cross-file', default=None, self.parser = argparse.ArgumentParser(prog='meson')
help='File describing cross compilation environment.') self.subparsers = self.parser.add_subparsers(title='Commands',
p.add_argument('-v', '--version', action='version', description='If no command is specified it defaults to setup command.')
version=coredata.version) self.add_command('setup', msetup.add_arguments, msetup.run,
# See the mesonlib.WrapMode enum for documentation help='Configure the project')
p.add_argument('--wrap-mode', default=None, self.add_command('configure', mconf.add_arguments, mconf.run,
type=wrapmodetype, choices=WrapMode, help='Change project options',)
help='Special wrap mode to use') self.add_command('install', minstall.add_arguments, minstall.run,
p.add_argument('--profile-self', action='store_true', dest='profile', help='Install the project')
help=argparse.SUPPRESS) self.add_command('introspect', mintro.add_arguments, mintro.run,
p.add_argument('--fatal-meson-warnings', action='store_true', dest='fatal_warnings', help='Introspect project')
help='Make all Meson warnings fatal') self.add_command('init', minit.add_arguments, minit.run,
p.add_argument('--reconfigure', action='store_true', help='Create a new project')
help='Set options and reconfigure the project. Useful when new ' + self.add_command('test', mtest.add_arguments, mtest.run,
'options have been added to the project and the default value ' + help='Run tests')
'is not working.') self.add_command('wrap', wraptool.add_arguments, wraptool.run,
p.add_argument('builddir', nargs='?', default=None) help='Wrap tools')
p.add_argument('sourcedir', nargs='?', default=None) self.add_command('help', self.add_help_arguments, self.run_help_command,
return p help='Print help of a subcommand')
def wrapmodetype(string): # Hidden commands
try: self.add_command('rewrite', rewriter.add_arguments, rewriter.run,
return getattr(WrapMode, string) help=argparse.SUPPRESS)
except AttributeError: self.add_command('runpython', self.add_runpython_arguments, self.run_runpython_command,
msg = ', '.join([t.name.lower() for t in WrapMode]) help=argparse.SUPPRESS)
msg = 'invalid argument {!r}, use one of {}'.format(string, msg)
raise argparse.ArgumentTypeError(msg) def add_command(self, name, add_arguments_func, run_func, help):
# FIXME: Cannot have hidden subparser:
class MesonApp: # https://bugs.python.org/issue22848
if help == argparse.SUPPRESS:
def __init__(self, options): p = argparse.ArgumentParser(prog='meson ' + name)
(self.source_dir, self.build_dir) = self.validate_dirs(options.builddir, self.hidden_commands.append(name)
options.sourcedir,
options.reconfigure)
self.options = options
def has_build_file(self, dirname):
fname = os.path.join(dirname, environment.build_filename)
return os.path.exists(fname)
def validate_core_dirs(self, dir1, dir2):
if dir1 is None:
if dir2 is None:
if not os.path.exists('meson.build') and os.path.exists('../meson.build'):
dir2 = '..'
else:
raise MesonException('Must specify at least one directory name.')
dir1 = os.getcwd()
if dir2 is None:
dir2 = os.getcwd()
ndir1 = os.path.abspath(os.path.realpath(dir1))
ndir2 = os.path.abspath(os.path.realpath(dir2))
if not os.path.exists(ndir1):
os.makedirs(ndir1)
if not os.path.exists(ndir2):
os.makedirs(ndir2)
if not stat.S_ISDIR(os.stat(ndir1).st_mode):
raise MesonException('%s is not a directory' % dir1)
if not stat.S_ISDIR(os.stat(ndir2).st_mode):
raise MesonException('%s is not a directory' % dir2)
if os.path.samefile(dir1, dir2):
raise MesonException('Source and build directories must not be the same. Create a pristine build directory.')
if self.has_build_file(ndir1):
if self.has_build_file(ndir2):
raise MesonException('Both directories contain a build file %s.' % environment.build_filename)
return ndir1, ndir2
if self.has_build_file(ndir2):
return ndir2, ndir1
raise MesonException('Neither directory contains a build file %s.' % environment.build_filename)
def validate_dirs(self, dir1, dir2, reconfigure):
(src_dir, build_dir) = self.validate_core_dirs(dir1, dir2)
priv_dir = os.path.join(build_dir, 'meson-private/coredata.dat')
if os.path.exists(priv_dir):
if not reconfigure:
print('Directory already configured.\n'
'\nJust run your build command (e.g. ninja) and Meson will regenerate as necessary.\n'
'If ninja fails, run "ninja reconfigure" or "meson --reconfigure"\n'
'to force Meson to regenerate.\n'
'\nIf build failures persist, manually wipe your build directory to clear any\n'
'stored system data.\n'
'\nTo change option values, run "meson configure" instead.')
sys.exit(0)
else: else:
if reconfigure: p = self.subparsers.add_parser(name, help=help)
print('Directory does not contain a valid build tree:\n{}'.format(build_dir)) add_arguments_func(p)
sys.exit(1) p.set_defaults(run_func=run_func)
return src_dir, build_dir self.commands[name] = p
def check_pkgconfig_envvar(self, env): def add_runpython_arguments(self, parser):
curvar = os.environ.get('PKG_CONFIG_PATH', '') parser.add_argument('script_file')
if curvar != env.coredata.pkgconf_envvar: parser.add_argument('script_args', nargs=argparse.REMAINDER)
mlog.warning('PKG_CONFIG_PATH has changed between invocations from "%s" to "%s".' %
(env.coredata.pkgconf_envvar, curvar)) def run_runpython_command(self, options):
env.coredata.pkgconf_envvar = curvar import runpy
sys.argv[1:] = options.script_args
def generate(self): runpy.run_path(options.script_file, run_name='__main__')
env = environment.Environment(self.source_dir, self.build_dir, self.options) return 0
mlog.initialize(env.get_log_dir(), self.options.fatal_warnings)
if self.options.profile: def add_help_arguments(self, parser):
mlog.set_timestamp_start(time.monotonic()) parser.add_argument('command', nargs='?')
with mesonlib.BuildDirLock(self.build_dir):
self._generate(env) def run_help_command(self, options):
if options.command:
def _generate(self, env): self.commands[options.command].print_help()
mlog.debug('Build started at', datetime.datetime.now().isoformat())
mlog.debug('Main binary:', sys.executable)
mlog.debug('Python system:', platform.system())
mlog.log(mlog.bold('The Meson build system'))
self.check_pkgconfig_envvar(env)
mlog.log('Version:', coredata.version)
mlog.log('Source dir:', mlog.bold(self.source_dir))
mlog.log('Build dir:', mlog.bold(self.build_dir))
if env.is_cross_build():
mlog.log('Build type:', mlog.bold('cross build'))
else: else:
mlog.log('Build type:', mlog.bold('native build')) self.parser.print_help()
b = build.Build(env) return 0
intr = interpreter.Interpreter(b) def run(self, args):
if env.is_cross_build(): # If first arg is not a known command, assume user wants to run the setup
mlog.log('Host machine cpu family:', mlog.bold(intr.builtin['host_machine'].cpu_family_method([], {}))) # command.
mlog.log('Host machine cpu:', mlog.bold(intr.builtin['host_machine'].cpu_method([], {}))) known_commands = list(self.commands.keys()) + ['-h', '--help']
mlog.log('Target machine cpu family:', mlog.bold(intr.builtin['target_machine'].cpu_family_method([], {}))) if len(args) == 0 or args[0] not in known_commands:
mlog.log('Target machine cpu:', mlog.bold(intr.builtin['target_machine'].cpu_method([], {}))) args = ['setup'] + args
mlog.log('Build machine cpu family:', mlog.bold(intr.builtin['build_machine'].cpu_family_method([], {})))
mlog.log('Build machine cpu:', mlog.bold(intr.builtin['build_machine'].cpu_method([], {}))) # Hidden commands have their own parser instead of using the global one
if self.options.profile: if args[0] in self.hidden_commands:
fname = os.path.join(self.build_dir, 'meson-private', 'profile-interpreter.log') parser = self.commands[args[0]]
profile.runctx('intr.run()', globals(), locals(), filename=fname) args = args[1:]
else: else:
intr.run() parser = self.parser
# Print all default option values that don't match the current value
for def_opt_name, def_opt_value, cur_opt_value in intr.get_non_matching_default_options(): args = mesonlib.expand_arguments(args)
mlog.log('Option', mlog.bold(def_opt_name), 'is:', options = parser.parse_args(args)
mlog.bold(str(cur_opt_value)),
'[default: {}]'.format(str(def_opt_value)))
try: try:
dumpfile = os.path.join(env.get_scratch_dir(), 'build.dat') return options.run_func(options)
# We would like to write coredata as late as possible since we use the existence of except MesonException as e:
# this file to check if we generated the build file successfully. Since coredata mlog.exception(e)
# includes settings, the build files must depend on it and appear newer. However, due logfile = mlog.shutdown()
# to various kernel caches, we cannot guarantee that any time in Python is exactly in if logfile is not None:
# sync with the time that gets applied to any files. Thus, we dump this file as late as mlog.log("\nA full log can be found at", mlog.bold(logfile))
# possible, but before build files, and if any error occurs, delete it. if os.environ.get('MESON_FORCE_BACKTRACE'):
cdf = env.dump_coredata() raise
if self.options.profile: return 1
fname = 'profile-{}-backend.log'.format(intr.backend.name) except Exception as e:
fname = os.path.join(self.build_dir, 'meson-private', fname) if os.environ.get('MESON_FORCE_BACKTRACE'):
profile.runctx('intr.backend.generate(intr)', globals(), locals(), filename=fname) raise
else: traceback.print_exc()
intr.backend.generate(intr) return 2
build.save(b, dumpfile) finally:
# Post-conf scripts must be run after writing coredata or else introspection fails. mlog.shutdown()
intr.backend.run_postconf_scripts()
except:
if 'cdf' in locals():
old_cdf = cdf + '.prev'
if os.path.exists(old_cdf):
os.replace(old_cdf, cdf)
else:
os.unlink(cdf)
raise
def run_script_command(args): def run_script_command(script_name, script_args):
cmdname = args[0] # Map script name to module name for those that doesn't match
cmdargs = args[1:] script_map = {'exe': 'meson_exe',
if cmdname == 'exe': 'install': 'meson_install',
import mesonbuild.scripts.meson_exe as abc 'delsuffix': 'delwithsuffix',
cmdfunc = abc.run 'gtkdoc': 'gtkdochelper',
elif cmdname == 'cleantrees': 'hotdoc': 'hotdochelper',
import mesonbuild.scripts.cleantrees as abc 'regencheck': 'regen_checker'}
cmdfunc = abc.run module_name = script_map.get(script_name, script_name)
elif cmdname == 'commandrunner':
import mesonbuild.scripts.commandrunner as abc
cmdfunc = abc.run
elif cmdname == 'delsuffix':
import mesonbuild.scripts.delwithsuffix as abc
cmdfunc = abc.run
elif cmdname == 'dirchanger':
import mesonbuild.scripts.dirchanger as abc
cmdfunc = abc.run
elif cmdname == 'gtkdoc':
import mesonbuild.scripts.gtkdochelper as abc
cmdfunc = abc.run
elif cmdname == 'msgfmthelper':
import mesonbuild.scripts.msgfmthelper as abc
cmdfunc = abc.run
elif cmdname == 'hotdoc':
import mesonbuild.scripts.hotdochelper as abc
cmdfunc = abc.run
elif cmdname == 'regencheck':
import mesonbuild.scripts.regen_checker as abc
cmdfunc = abc.run
elif cmdname == 'symbolextractor':
import mesonbuild.scripts.symbolextractor as abc
cmdfunc = abc.run
elif cmdname == 'scanbuild':
import mesonbuild.scripts.scanbuild as abc
cmdfunc = abc.run
elif cmdname == 'vcstagger':
import mesonbuild.scripts.vcstagger as abc
cmdfunc = abc.run
elif cmdname == 'gettext':
import mesonbuild.scripts.gettext as abc
cmdfunc = abc.run
elif cmdname == 'yelphelper':
import mesonbuild.scripts.yelphelper as abc
cmdfunc = abc.run
elif cmdname == 'uninstall':
import mesonbuild.scripts.uninstall as abc
cmdfunc = abc.run
elif cmdname == 'dist':
import mesonbuild.scripts.dist as abc
cmdfunc = abc.run
elif cmdname == 'coverage':
import mesonbuild.scripts.coverage as abc
cmdfunc = abc.run
else:
raise MesonException('Unknown internal command {}.'.format(cmdname))
return cmdfunc(cmdargs)
def set_meson_command(mainfile): try:
# On UNIX-like systems `meson` is a Python script module = importlib.import_module('mesonbuild.scripts.' + module_name)
# On Windows `meson` and `meson.exe` are wrapper exes except ModuleNotFoundError as e:
if not mainfile.endswith('.py'): mlog.exception(e)
mesonlib.meson_command = [mainfile] return 1
elif os.path.isabs(mainfile) and mainfile.endswith('mesonmain.py'):
# Can't actually run meson with an absolute path to mesonmain.py, it must be run as -m mesonbuild.mesonmain try:
mesonlib.meson_command = mesonlib.python_command + ['-m', 'mesonbuild.mesonmain'] return module.run(script_args)
else: except MesonException as e:
# Either run uninstalled, or full path to meson-script.py mlog.error('Error in {} helper script:'.format(script_name))
mesonlib.meson_command = mesonlib.python_command + [mainfile] mlog.exception(e)
# We print this value for unit tests. return 1
if 'MESON_COMMAND_TESTS' in os.environ:
mlog.log('meson_command is {!r}'.format(mesonlib.meson_command))
def run(original_args, mainfile): def run(original_args, mainfile):
if sys.version_info < (3, 5): if sys.version_info < (3, 5):
@ -274,6 +152,7 @@ def run(original_args, mainfile):
print('You have python %s.' % sys.version) print('You have python %s.' % sys.version)
print('Please update your environment') print('Please update your environment')
return 1 return 1
# https://github.com/mesonbuild/meson/issues/3653 # https://github.com/mesonbuild/meson/issues/3653
if sys.platform.lower() == 'msys': if sys.platform.lower() == 'msys':
mlog.error('This python3 seems to be msys/python on MSYS2 Windows, which is known to have path semantics incompatible with Meson') mlog.error('This python3 seems to be msys/python on MSYS2 Windows, which is known to have path semantics incompatible with Meson')
@ -283,104 +162,23 @@ def run(original_args, mainfile):
else: else:
mlog.error('Please download and use Python as detailed at: https://mesonbuild.com/Getting-meson.html') mlog.error('Please download and use Python as detailed at: https://mesonbuild.com/Getting-meson.html')
return 2 return 2
# Set the meson command that will be used to run scripts and so on # Set the meson command that will be used to run scripts and so on
set_meson_command(mainfile) mesonlib.set_meson_command(mainfile)
args = original_args[:] args = original_args[:]
if len(args) > 0:
# First check if we want to run a subcommand.
cmd_name = args[0]
remaining_args = args[1:]
# "help" is a special case: Since printing of the help may be
# delegated to a subcommand, we edit cmd_name before executing
# the rest of the logic here.
if cmd_name == 'help':
remaining_args += ['--help']
args = remaining_args
cmd_name = args[0]
if cmd_name == 'test':
from . import mtest
return mtest.run(remaining_args)
elif cmd_name == 'setup':
args = remaining_args
# FALLTHROUGH like it's 1972.
elif cmd_name == 'install':
from . import minstall
return minstall.run(remaining_args)
elif cmd_name == 'introspect':
from . import mintro
return mintro.run(remaining_args)
elif cmd_name == 'rewrite':
from . import rewriter
return rewriter.run(remaining_args)
elif cmd_name == 'configure':
try:
from . import mconf
return mconf.run(remaining_args)
except MesonException as e:
mlog.exception(e)
sys.exit(1)
elif cmd_name == 'wrap':
from .wrap import wraptool
return wraptool.run(remaining_args)
elif cmd_name == 'init':
from . import minit
return minit.run(remaining_args)
elif cmd_name == 'runpython':
import runpy
script_file = remaining_args[0]
sys.argv[1:] = remaining_args[1:]
runpy.run_path(script_file, run_name='__main__')
sys.exit(0)
# No special command? Do the basic setup/reconf. # Special handling of internal commands called from backends, they don't
# need to go through argparse.
if len(args) >= 2 and args[0] == '--internal': if len(args) >= 2 and args[0] == '--internal':
if args[1] == 'regenerate': if args[1] == 'regenerate':
# Rewrite "meson --internal regenerate" command line to # Rewrite "meson --internal regenerate" command line to
# "meson --reconfigure" # "meson --reconfigure"
args = ['--reconfigure'] + args[2:] args = ['--reconfigure'] + args[2:]
else: else:
script = args[1] return run_script_command(args[1], args[2:])
try:
sys.exit(run_script_command(args[1:]))
except MesonException as e:
mlog.error('\nError in {} helper script:'.format(script))
mlog.exception(e)
sys.exit(1)
parser = create_parser()
args = mesonlib.expand_arguments(args)
options = parser.parse_args(args)
coredata.parse_cmd_line_options(options)
try:
app = MesonApp(options)
except Exception as e:
# Log directory does not exist, so just print
# to stdout.
print('Error during basic setup:\n')
print(e)
return 1
try:
app.generate()
except Exception as e:
if isinstance(e, MesonException):
mlog.exception(e)
# Path to log file
mlog.shutdown()
logfile = os.path.join(app.build_dir, environment.Environment.log_dir, mlog.log_fname)
mlog.log("\nA full log can be found at", mlog.bold(logfile))
if os.environ.get('MESON_FORCE_BACKTRACE'):
raise
return 1
else:
if os.environ.get('MESON_FORCE_BACKTRACE'):
raise
traceback.print_exc()
return 2
finally:
mlog.shutdown()
return 0 return CommandLineParser().run(args)
def main(): def main():
# Always resolve the command path so Ninja can find it for regen, tests, etc. # Always resolve the command path so Ninja can find it for regen, tests, etc.

8
mesonbuild/minit.py
Unescape View File

@ -14,7 +14,7 @@
"""Code that creates simple startup projects.""" """Code that creates simple startup projects."""
import os, sys, argparse, re, shutil, subprocess import os, sys, re, shutil, subprocess
from glob import glob from glob import glob
from mesonbuild import mesonlib from mesonbuild import mesonlib
from mesonbuild.environment import detect_ninja from mesonbuild.environment import detect_ninja
@ -425,8 +425,7 @@ def create_meson_build(options):
open('meson.build', 'w').write(content) open('meson.build', 'w').write(content)
print('Generated meson.build file:\n\n' + content) print('Generated meson.build file:\n\n' + content)
def run(args): def add_arguments(parser):
parser = argparse.ArgumentParser(prog='meson')
parser.add_argument("srcfiles", metavar="sourcefile", nargs="*", parser.add_argument("srcfiles", metavar="sourcefile", nargs="*",
help="source files. default: all recognized files in current directory") help="source files. default: all recognized files in current directory")
parser.add_argument("-n", "--name", help="project name. default: name of current directory") parser.add_argument("-n", "--name", help="project name. default: name of current directory")
@ -441,7 +440,8 @@ def run(args):
parser.add_argument('--type', default='executable', parser.add_argument('--type', default='executable',
choices=['executable', 'library']) choices=['executable', 'library'])
parser.add_argument('--version', default='0.1') parser.add_argument('--version', default='0.1')
options = parser.parse_args(args)
def run(options):
if len(glob('*')) == 0: if len(glob('*')) == 0:
autodetect_options(options, sample=True) autodetect_options(options, sample=True)
if not options.language: if not options.language:

12
mesonbuild/minstall.py
Unescape View File

@ -14,7 +14,6 @@
import sys, pickle, os, shutil, subprocess, gzip, errno import sys, pickle, os, shutil, subprocess, gzip, errno
import shlex import shlex
import argparse
from glob import glob from glob import glob
from .scripts import depfixer from .scripts import depfixer
from .scripts import destdir_join from .scripts import destdir_join
@ -33,15 +32,13 @@ build definitions so that it will not break when the change happens.'''
selinux_updates = [] selinux_updates = []
def buildparser(): def add_arguments(parser):
parser = argparse.ArgumentParser(prog='meson install')
parser.add_argument('-C', default='.', dest='wd', parser.add_argument('-C', default='.', dest='wd',
help='directory to cd into before running') help='directory to cd into before running')
parser.add_argument('--no-rebuild', default=False, action='store_true', parser.add_argument('--no-rebuild', default=False, action='store_true',
help='Do not rebuild before installing.') help='Do not rebuild before installing.')
parser.add_argument('--only-changed', default=False, action='store_true', parser.add_argument('--only-changed', default=False, action='store_true',
help='Only overwrite files that are older than the copied file.') help='Only overwrite files that are older than the copied file.')
return parser
class DirMaker: class DirMaker:
def __init__(self, lf): def __init__(self, lf):
@ -501,9 +498,7 @@ class Installer:
else: else:
raise raise
def run(args): def run(opts):
parser = buildparser()
opts = parser.parse_args(args)
datafilename = 'meson-private/install.dat' datafilename = 'meson-private/install.dat'
private_dir = os.path.dirname(datafilename) private_dir = os.path.dirname(datafilename)
log_dir = os.path.join(private_dir, '../meson-logs') log_dir = os.path.join(private_dir, '../meson-logs')
@ -520,6 +515,3 @@ def run(args):
append_to_log(lf, '# Does not contain files installed by custom scripts.') append_to_log(lf, '# Does not contain files installed by custom scripts.')
installer.do_install(datafilename) installer.do_install(datafilename)
return 0 return 0
if __name__ == '__main__':
sys.exit(run(sys.argv[1:]))

8
mesonbuild/mintro.py
Unescape View File

@ -23,12 +23,10 @@ import json
from . import build, mtest, coredata as cdata from . import build, mtest, coredata as cdata
from . import mesonlib from . import mesonlib
from .backend import ninjabackend from .backend import ninjabackend
import argparse
import sys, os import sys, os
import pathlib import pathlib
def buildparser(): def add_arguments(parser):
parser = argparse.ArgumentParser(prog='meson introspect')
parser.add_argument('--targets', action='store_true', dest='list_targets', default=False, parser.add_argument('--targets', action='store_true', dest='list_targets', default=False,
help='List top level targets.') help='List top level targets.')
parser.add_argument('--installed', action='store_true', dest='list_installed', default=False, parser.add_argument('--installed', action='store_true', dest='list_installed', default=False,
@ -48,7 +46,6 @@ def buildparser():
parser.add_argument('--projectinfo', action='store_true', dest='projectinfo', default=False, parser.add_argument('--projectinfo', action='store_true', dest='projectinfo', default=False,
help='Information about projects.') help='Information about projects.')
parser.add_argument('builddir', nargs='?', default='.', help='The build directory') parser.add_argument('builddir', nargs='?', default='.', help='The build directory')
return parser
def determine_installed_path(target, installdata): def determine_installed_path(target, installdata):
install_target = None install_target = None
@ -206,9 +203,8 @@ def list_projinfo(builddata):
result['subprojects'] = subprojects result['subprojects'] = subprojects
print(json.dumps(result)) print(json.dumps(result))
def run(args): def run(options):
datadir = 'meson-private' datadir = 'meson-private'
options = buildparser().parse_args(args)
if options.builddir is not None: if options.builddir is not None:
datadir = os.path.join(options.builddir, datadir) datadir = os.path.join(options.builddir, datadir)
if not os.path.isdir(datadir): if not os.path.isdir(datadir):

197
mesonbuild/msetup.py
Unescape View File

@ -0,0 +1,197 @@
# Copyright 2016-2018 The Meson development team
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import time
import sys, stat
import datetime
import os.path
import platform
import cProfile as profile
import argparse
from . import environment, interpreter, mesonlib
from . import build
from . import mlog, coredata
from .mesonlib import MesonException
from .wrap import WrapMode
def add_arguments(parser):
coredata.register_builtin_arguments(parser)
parser.add_argument('--cross-file', default=None,
help='File describing cross compilation environment.')
parser.add_argument('-v', '--version', action='version',
version=coredata.version)
# See the mesonlib.WrapMode enum for documentation
parser.add_argument('--wrap-mode', default=None,
type=wrapmodetype, choices=WrapMode,
help='Special wrap mode to use')
parser.add_argument('--profile-self', action='store_true', dest='profile',
help=argparse.SUPPRESS)
parser.add_argument('--fatal-meson-warnings', action='store_true', dest='fatal_warnings',
help='Make all Meson warnings fatal')
parser.add_argument('--reconfigure', action='store_true',
help='Set options and reconfigure the project. Useful when new ' +
'options have been added to the project and the default value ' +
'is not working.')
parser.add_argument('builddir', nargs='?', default=None)
parser.add_argument('sourcedir', nargs='?', default=None)
def wrapmodetype(string):
try:
return getattr(WrapMode, string)
except AttributeError:
msg = ', '.join([t.name.lower() for t in WrapMode])
msg = 'invalid argument {!r}, use one of {}'.format(string, msg)
raise argparse.ArgumentTypeError(msg)
class MesonApp:
def __init__(self, options):
(self.source_dir, self.build_dir) = self.validate_dirs(options.builddir,
options.sourcedir,
options.reconfigure)
self.options = options
def has_build_file(self, dirname):
fname = os.path.join(dirname, environment.build_filename)
return os.path.exists(fname)
def validate_core_dirs(self, dir1, dir2):
if dir1 is None:
if dir2 is None:
if not os.path.exists('meson.build') and os.path.exists('../meson.build'):
dir2 = '..'
else:
raise MesonException('Must specify at least one directory name.')
dir1 = os.getcwd()
if dir2 is None:
dir2 = os.getcwd()
ndir1 = os.path.abspath(os.path.realpath(dir1))
ndir2 = os.path.abspath(os.path.realpath(dir2))
if not os.path.exists(ndir1):
os.makedirs(ndir1)
if not os.path.exists(ndir2):
os.makedirs(ndir2)
if not stat.S_ISDIR(os.stat(ndir1).st_mode):
raise MesonException('%s is not a directory' % dir1)
if not stat.S_ISDIR(os.stat(ndir2).st_mode):
raise MesonException('%s is not a directory' % dir2)
if os.path.samefile(dir1, dir2):
raise MesonException('Source and build directories must not be the same. Create a pristine build directory.')
if self.has_build_file(ndir1):
if self.has_build_file(ndir2):
raise MesonException('Both directories contain a build file %s.' % environment.build_filename)
return ndir1, ndir2
if self.has_build_file(ndir2):
return ndir2, ndir1
raise MesonException('Neither directory contains a build file %s.' % environment.build_filename)
def validate_dirs(self, dir1, dir2, reconfigure):
(src_dir, build_dir) = self.validate_core_dirs(dir1, dir2)
priv_dir = os.path.join(build_dir, 'meson-private/coredata.dat')
if os.path.exists(priv_dir):
if not reconfigure:
print('Directory already configured.\n'
'\nJust run your build command (e.g. ninja) and Meson will regenerate as necessary.\n'
'If ninja fails, run "ninja reconfigure" or "meson --reconfigure"\n'
'to force Meson to regenerate.\n'
'\nIf build failures persist, manually wipe your build directory to clear any\n'
'stored system data.\n'
'\nTo change option values, run "meson configure" instead.')
sys.exit(0)
else:
if reconfigure:
print('Directory does not contain a valid build tree:\n{}'.format(build_dir))
sys.exit(1)
return src_dir, build_dir
def check_pkgconfig_envvar(self, env):
curvar = os.environ.get('PKG_CONFIG_PATH', '')
if curvar != env.coredata.pkgconf_envvar:
mlog.warning('PKG_CONFIG_PATH has changed between invocations from "%s" to "%s".' %
(env.coredata.pkgconf_envvar, curvar))
env.coredata.pkgconf_envvar = curvar
def generate(self):
env = environment.Environment(self.source_dir, self.build_dir, self.options)
mlog.initialize(env.get_log_dir(), self.options.fatal_warnings)
if self.options.profile:
mlog.set_timestamp_start(time.monotonic())
with mesonlib.BuildDirLock(self.build_dir):
self._generate(env)
def _generate(self, env):
mlog.debug('Build started at', datetime.datetime.now().isoformat())
mlog.debug('Main binary:', sys.executable)
mlog.debug('Python system:', platform.system())
mlog.log(mlog.bold('The Meson build system'))
self.check_pkgconfig_envvar(env)
mlog.log('Version:', coredata.version)
mlog.log('Source dir:', mlog.bold(self.source_dir))
mlog.log('Build dir:', mlog.bold(self.build_dir))
if env.is_cross_build():
mlog.log('Build type:', mlog.bold('cross build'))
else:
mlog.log('Build type:', mlog.bold('native build'))
b = build.Build(env)
intr = interpreter.Interpreter(b)
if env.is_cross_build():
mlog.log('Host machine cpu family:', mlog.bold(intr.builtin['host_machine'].cpu_family_method([], {})))
mlog.log('Host machine cpu:', mlog.bold(intr.builtin['host_machine'].cpu_method([], {})))
mlog.log('Target machine cpu family:', mlog.bold(intr.builtin['target_machine'].cpu_family_method([], {})))
mlog.log('Target machine cpu:', mlog.bold(intr.builtin['target_machine'].cpu_method([], {})))
mlog.log('Build machine cpu family:', mlog.bold(intr.builtin['build_machine'].cpu_family_method([], {})))
mlog.log('Build machine cpu:', mlog.bold(intr.builtin['build_machine'].cpu_method([], {})))
if self.options.profile:
fname = os.path.join(self.build_dir, 'meson-private', 'profile-interpreter.log')
profile.runctx('intr.run()', globals(), locals(), filename=fname)
else:
intr.run()
# Print all default option values that don't match the current value
for def_opt_name, def_opt_value, cur_opt_value in intr.get_non_matching_default_options():
mlog.log('Option', mlog.bold(def_opt_name), 'is:',
mlog.bold(str(cur_opt_value)),
'[default: {}]'.format(str(def_opt_value)))
try:
dumpfile = os.path.join(env.get_scratch_dir(), 'build.dat')
# We would like to write coredata as late as possible since we use the existence of
# this file to check if we generated the build file successfully. Since coredata
# includes settings, the build files must depend on it and appear newer. However, due
# to various kernel caches, we cannot guarantee that any time in Python is exactly in
# sync with the time that gets applied to any files. Thus, we dump this file as late as
# possible, but before build files, and if any error occurs, delete it.
cdf = env.dump_coredata()
if self.options.profile:
fname = 'profile-{}-backend.log'.format(intr.backend.name)
fname = os.path.join(self.build_dir, 'meson-private', fname)
profile.runctx('intr.backend.generate(intr)', globals(), locals(), filename=fname)
else:
intr.backend.generate(intr)
build.save(b, dumpfile)
# Post-conf scripts must be run after writing coredata or else introspection fails.
intr.backend.run_postconf_scripts()
except:
if 'cdf' in locals():
old_cdf = cdf + '.prev'
if os.path.exists(old_cdf):
os.replace(old_cdf, cdf)
else:
os.unlink(cdf)
raise
def run(options):
coredata.parse_cmd_line_options(options)
app = MesonApp(options)
app.generate()
return 0

14
mesonbuild/mtest.py
Unescape View File

@ -60,8 +60,7 @@ def determine_worker_count():
num_workers = 1 num_workers = 1
return num_workers return num_workers
def buildparser(): def add_arguments(parser):
parser = argparse.ArgumentParser(prog='meson test')
parser.add_argument('--repeat', default=1, dest='repeat', type=int, parser.add_argument('--repeat', default=1, dest='repeat', type=int,
help='Number of times to run the tests.') help='Number of times to run the tests.')
parser.add_argument('--no-rebuild', default=False, action='store_true', parser.add_argument('--no-rebuild', default=False, action='store_true',
@ -102,7 +101,6 @@ def buildparser():
help='Arguments to pass to the specified test(s) or all tests') help='Arguments to pass to the specified test(s) or all tests')
parser.add_argument('args', nargs='*', parser.add_argument('args', nargs='*',
help='Optional list of tests to run') help='Optional list of tests to run')
return parser
def returncode_to_status(retcode): def returncode_to_status(retcode):
@ -737,9 +735,7 @@ def rebuild_all(wd):
return True return True
def run(args): def run(options):
options = buildparser().parse_args(args)
if options.benchmark: if options.benchmark:
options.num_processes = 1 options.num_processes = 1
@ -784,3 +780,9 @@ def run(args):
else: else:
print(e) print(e)
return 1 return 1
def run_with_args(args):
parser = argparse.ArgumentParser(prog='meson test')
add_arguments(parser)
options = parser.parse_args(args)
return run(options)

9
mesonbuild/rewriter.py
Unescape View File

@ -27,11 +27,8 @@ import mesonbuild.astinterpreter
from mesonbuild.mesonlib import MesonException from mesonbuild.mesonlib import MesonException
from mesonbuild import mlog from mesonbuild import mlog
import sys, traceback import sys, traceback
import argparse
def buildparser():
parser = argparse.ArgumentParser(prog='meson rewrite')
def add_arguments(parser):
parser.add_argument('--sourcedir', default='.', parser.add_argument('--sourcedir', default='.',
help='Path to source directory.') help='Path to source directory.')
parser.add_argument('--target', default=None, parser.add_argument('--target', default=None,
@ -39,10 +36,8 @@ def buildparser():
parser.add_argument('--filename', default=None, parser.add_argument('--filename', default=None,
help='Name of source file to add or remove to target.') help='Name of source file to add or remove to target.')
parser.add_argument('commands', nargs='+') parser.add_argument('commands', nargs='+')
return parser
def run(args): def run(options):
options = buildparser().parse_args(args)
if options.target is None or options.filename is None: if options.target is None or options.filename is None:
sys.exit("Must specify both target and filename.") sys.exit("Must specify both target and filename.")
print('This tool is highly experimental, use with care.') print('This tool is highly experimental, use with care.')

6
mesonbuild/wrap/wraptool.py
Unescape View File

@ -16,7 +16,6 @@ import json
import sys, os import sys, os
import configparser import configparser
import shutil import shutil
import argparse
from glob import glob from glob import glob
@ -208,9 +207,6 @@ def status(options):
else: else:
print('', name, 'not up to date. Have %s %d, but %s %d is available.' % (current_branch, current_revision, latest_branch, latest_revision)) print('', name, 'not up to date. Have %s %d, but %s %d is available.' % (current_branch, current_revision, latest_branch, latest_revision))
def run(args): def run(options):
parser = argparse.ArgumentParser(prog='wraptool')
add_arguments(parser)
options = parser.parse_args(args)
options.wrap_func(options) options.wrap_func(options)
return 0 return 0

4
run_project_tests.py
Unescape View File

@ -247,12 +247,12 @@ def run_test_inprocess(testdir):
os.chdir(testdir) os.chdir(testdir)
test_log_fname = Path('meson-logs', 'testlog.txt') test_log_fname = Path('meson-logs', 'testlog.txt')
try: try:
returncode_test = mtest.run(['--no-rebuild']) returncode_test = mtest.run_with_args(['--no-rebuild'])
if test_log_fname.exists(): if test_log_fname.exists():
test_log = test_log_fname.open(errors='ignore').read() test_log = test_log_fname.open(errors='ignore').read()
else: else:
test_log = '' test_log = ''
returncode_benchmark = mtest.run(['--no-rebuild', '--benchmark', '--logbase', 'benchmarklog']) returncode_benchmark = mtest.run_with_args(['--no-rebuild', '--benchmark', '--logbase', 'benchmarklog'])
finally: finally:
sys.stdout = old_stdout sys.stdout = old_stdout
sys.stderr = old_stderr sys.stderr = old_stderr

2
run_tests.py
Unescape View File

@ -181,7 +181,7 @@ def run_mtest_inprocess(commandlist):
old_stderr = sys.stderr old_stderr = sys.stderr
sys.stderr = mystderr = StringIO() sys.stderr = mystderr = StringIO()
try: try:
returncode = mtest.run(commandlist) returncode = mtest.run_with_args(commandlist)
finally: finally:
sys.stdout = old_stdout sys.stdout = old_stdout
sys.stderr = old_stderr sys.stderr = old_stderr

Write Preview
Loading…
Cancel
Save