Virtualization
/
meson
mirror of https://gitlab.com/qemu-project/meson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

interpreter: Rename dirname to subp_name 

dirname is confusing because the name of a subproject does not always
match its directory name, the wrap file can define another directory.
For example foo.wrap will often extract the subproject into foo-1.2
directory, in that case the subproject name is 'foo' and the subproject
directory is 'foo-1.2'.
This commit is contained in:
Xavier Claessens 2020-04-13 10:17:49 -04:00
parent e36f713a7f
commit 311a07c39a
1 changed files with 65 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

130
mesonbuild/interpreter.py
View File

@ -2840,55 +2840,55 @@ external dependencies (including libraries) must go to "dependencies".''')
def func_subproject(self, nodes, args, kwargs): def func_subproject(self, nodes, args, kwargs):
if len(args) != 1: if len(args) != 1:
raise InterpreterException('Subproject takes exactly one argument') raise InterpreterException('Subproject takes exactly one argument')
dirname = args[0] subp_name = args[0]
return self.do_subproject(dirname, 'meson', kwargs) return self.do_subproject(subp_name, 'meson', kwargs)
def disabled_subproject(self, dirname, disabled_feature=None, exception=None): def disabled_subproject(self, subp_name, disabled_feature=None, exception=None):
sub = SubprojectHolder(None, self.subproject_dir, dirname, sub = SubprojectHolder(None, self.subproject_dir, subp_name,
disabled_feature=disabled_feature, exception=exception) disabled_feature=disabled_feature, exception=exception)
self.subprojects[dirname] = sub self.subprojects[subp_name] = sub
return sub return sub
def get_subproject(self, dirname): def get_subproject(self, subp_name):
sub = self.subprojects.get(dirname) sub = self.subprojects.get(subp_name)
if sub and sub.found(): if sub and sub.found():
return sub return sub
return None return None
def do_subproject(self, dirname: str, method: str, kwargs): def do_subproject(self, subp_name: str, method: str, kwargs):
disabled, required, feature = extract_required_kwarg(kwargs, self.subproject) disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
if disabled: if disabled:
mlog.log('Subproject', mlog.bold(dirname), ':', 'skipped: feature', mlog.bold(feature), 'disabled') mlog.log('Subproject', mlog.bold(subp_name), ':', 'skipped: feature', mlog.bold(feature), 'disabled')
return self.disabled_subproject(dirname, disabled_feature=feature) return self.disabled_subproject(subp_name, disabled_feature=feature)
default_options = mesonlib.stringlistify(kwargs.get('default_options', [])) default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
default_options = coredata.create_options_dict(default_options) default_options = coredata.create_options_dict(default_options)
if dirname == '': if subp_name == '':
raise InterpreterException('Subproject dir name must not be empty.') raise InterpreterException('Subproject name must not be empty.')
if dirname[0] == '.': if subp_name[0] == '.':
raise InterpreterException('Subproject dir name must not start with a period.') raise InterpreterException('Subproject name must not start with a period.')
if '..' in dirname: if '..' in subp_name:
raise InterpreterException('Subproject name must not contain a ".." path segment.') raise InterpreterException('Subproject name must not contain a ".." path segment.')
if os.path.isabs(dirname): if os.path.isabs(subp_name):
raise InterpreterException('Subproject name must not be an absolute path.') raise InterpreterException('Subproject name must not be an absolute path.')
if has_path_sep(dirname): if has_path_sep(subp_name):
mlog.warning('Subproject name has a path separator. This may cause unexpected behaviour.', mlog.warning('Subproject name has a path separator. This may cause unexpected behaviour.',
location=self.current_node) location=self.current_node)
if dirname in self.subproject_stack: if subp_name in self.subproject_stack:
fullstack = self.subproject_stack + [dirname] fullstack = self.subproject_stack + [subp_name]
incpath = ' => '.join(fullstack) incpath = ' => '.join(fullstack)
raise InvalidCode('Recursive include of subprojects: %s.' % incpath) raise InvalidCode('Recursive include of subprojects: %s.' % incpath)
if dirname in self.subprojects: if subp_name in self.subprojects:
subproject = self.subprojects[dirname] subproject = self.subprojects[subp_name]
if required and not subproject.found(): if required and not subproject.found():
raise InterpreterException('Subproject "%s/%s" required but not found.' % ( raise InterpreterException('Subproject "%s/%s" required but not found.' % (
self.subproject_dir, dirname)) self.subproject_dir, subp_name))
return subproject return subproject
r = self.environment.wrap_resolver r = self.environment.wrap_resolver
try: try:
resolved = r.resolve(dirname, method, self.subproject) resolved = r.resolve(subp_name, method, self.subproject)
except wrap.WrapException as e: except wrap.WrapException as e:
subprojdir = os.path.join(self.subproject_dir, r.directory) subprojdir = os.path.join(self.subproject_dir, r.directory)
if isinstance(e, wrap.WrapNotFoundException): if isinstance(e, wrap.WrapNotFoundException):
@ -2896,11 +2896,11 @@ external dependencies (including libraries) must go to "dependencies".''')
# the directory doesn't exist, try to give some helpful # the directory doesn't exist, try to give some helpful
# advice if it's a nested subproject that needs # advice if it's a nested subproject that needs
# promotion... # promotion...
self.print_nested_info(dirname) self.print_nested_info(subp_name)
if not required: if not required:
mlog.log(e) mlog.log(e)
mlog.log('Subproject ', mlog.bold(subprojdir), 'is buildable:', mlog.red('NO'), '(disabling)') mlog.log('Subproject ', mlog.bold(subprojdir), 'is buildable:', mlog.red('NO'), '(disabling)')
return self.disabled_subproject(dirname, exception=e) return self.disabled_subproject(subp_name, exception=e)
raise e raise e
subdir = os.path.join(self.subproject_dir, resolved) subdir = os.path.join(self.subproject_dir, resolved)
@ -2910,14 +2910,14 @@ external dependencies (including libraries) must go to "dependencies".''')
mlog.log() mlog.log()
with mlog.nested(): with mlog.nested():
mlog.log('Executing subproject', mlog.bold(dirname), 'method', mlog.bold(method), '\n') mlog.log('Executing subproject', mlog.bold(subp_name), 'method', mlog.bold(method), '\n')
try: try:
if method == 'meson': if method == 'meson':
return self._do_subproject_meson(dirname, subdir, default_options, kwargs) return self._do_subproject_meson(subp_name, subdir, default_options, kwargs)
elif method == 'cmake': elif method == 'cmake':
return self._do_subproject_cmake(dirname, subdir, subdir_abs, default_options, kwargs) return self._do_subproject_cmake(subp_name, subdir, subdir_abs, default_options, kwargs)
else: else:
raise InterpreterException('The method {} is invalid for the subproject {}'.format(method, dirname)) raise InterpreterException('The method {} is invalid for the subproject {}'.format(method, subp_name))
# Invalid code is always an error # Invalid code is always an error
except InvalidCode: except InvalidCode:
raise raise
@ -2927,18 +2927,18 @@ external dependencies (including libraries) must go to "dependencies".''')
# Suppress the 'ERROR:' prefix because this exception is not # Suppress the 'ERROR:' prefix because this exception is not
# fatal and VS CI treat any logs with "ERROR:" as fatal. # fatal and VS CI treat any logs with "ERROR:" as fatal.
mlog.exception(e, prefix=mlog.yellow('Exception:')) mlog.exception(e, prefix=mlog.yellow('Exception:'))
mlog.log('\nSubproject', mlog.bold(dirname), 'is buildable:', mlog.red('NO'), '(disabling)') mlog.log('\nSubproject', mlog.bold(subp_name), 'is buildable:', mlog.red('NO'), '(disabling)')
return self.disabled_subproject(dirname, exception=e) return self.disabled_subproject(subp_name, exception=e)
raise e raise e
def _do_subproject_meson(self, dirname, subdir, default_options, kwargs, ast=None, build_def_files=None): def _do_subproject_meson(self, subp_name, subdir, default_options, kwargs, ast=None, build_def_files=None):
with mlog.nested(): with mlog.nested():
new_build = self.build.copy() new_build = self.build.copy()
subi = Interpreter(new_build, self.backend, dirname, subdir, self.subproject_dir, subi = Interpreter(new_build, self.backend, subp_name, subdir, self.subproject_dir,
self.modules, default_options, ast=ast) self.modules, default_options, ast=ast)
subi.subprojects = self.subprojects subi.subprojects = self.subprojects
subi.subproject_stack = self.subproject_stack + [dirname] subi.subproject_stack = self.subproject_stack + [subp_name]
current_active = self.active_projectname current_active = self.active_projectname
current_warnings_counter = mlog.log_warnings_counter current_warnings_counter = mlog.log_warnings_counter
mlog.log_warnings_counter = 0 mlog.log_warnings_counter = 0
@ -2946,7 +2946,7 @@ external dependencies (including libraries) must go to "dependencies".''')
subi_warnings = mlog.log_warnings_counter subi_warnings = mlog.log_warnings_counter
mlog.log_warnings_counter = current_warnings_counter mlog.log_warnings_counter = current_warnings_counter
mlog.log('Subproject', mlog.bold(dirname), 'finished.') mlog.log('Subproject', mlog.bold(subp_name), 'finished.')
mlog.log() mlog.log()
@ -2954,10 +2954,10 @@ external dependencies (including libraries) must go to "dependencies".''')
pv = subi.project_version pv = subi.project_version
wanted = kwargs['version'] wanted = kwargs['version']
if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)[0]: if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)[0]:
raise InterpreterException('Subproject %s version is %s but %s required.' % (dirname, pv, wanted)) raise InterpreterException('Subproject %s version is %s but %s required.' % (subp_name, pv, wanted))
self.active_projectname = current_active self.active_projectname = current_active
self.subprojects.update(subi.subprojects) self.subprojects.update(subi.subprojects)
self.subprojects[dirname] = SubprojectHolder(subi, self.subproject_dir, dirname, self.subprojects[subp_name] = SubprojectHolder(subi, self.subproject_dir, subp_name,
warnings=subi_warnings) warnings=subi_warnings)
# Duplicates are possible when subproject uses files from project root # Duplicates are possible when subproject uses files from project root
if build_def_files: if build_def_files:
@ -2965,11 +2965,11 @@ external dependencies (including libraries) must go to "dependencies".''')
else: else:
self.build_def_files = list(set(self.build_def_files + subi.build_def_files)) self.build_def_files = list(set(self.build_def_files + subi.build_def_files))
self.build.merge(subi.build) self.build.merge(subi.build)
self.build.subprojects[dirname] = subi.project_version self.build.subprojects[subp_name] = subi.project_version
self.summary.update(subi.summary) self.summary.update(subi.summary)
return self.subprojects[dirname] return self.subprojects[subp_name]
def _do_subproject_cmake(self, dirname, subdir, subdir_abs, default_options, kwargs): def _do_subproject_cmake(self, subp_name, subdir, subdir_abs, default_options, kwargs):
with mlog.nested(): with mlog.nested():
new_build = self.build.copy() new_build = self.build.copy()
prefix = self.coredata.builtins['prefix'].value prefix = self.coredata.builtins['prefix'].value
@ -3007,7 +3007,7 @@ external dependencies (including libraries) must go to "dependencies".''')
mlog.cmd_ci_include(meson_filename) mlog.cmd_ci_include(meson_filename)
mlog.log() mlog.log()
result = self._do_subproject_meson(dirname, subdir, default_options, kwargs, ast, cm_int.bs_files) result = self._do_subproject_meson(subp_name, subdir, default_options, kwargs, ast, cm_int.bs_files)
result.cm_interpreter = cm_int result.cm_interpreter = cm_int
mlog.log() mlog.log()
@ -3582,8 +3582,8 @@ external dependencies (including libraries) must go to "dependencies".''')
def notfound_dependency(self): def notfound_dependency(self):
return DependencyHolder(NotFoundDependency(self.environment), self.subproject) return DependencyHolder(NotFoundDependency(self.environment), self.subproject)
def verify_fallback_consistency(self, dirname, varname, cached_dep): def verify_fallback_consistency(self, subp_name, varname, cached_dep):
subi = self.get_subproject(dirname) subi = self.get_subproject(subp_name)
if not cached_dep or not varname or not subi or not cached_dep.found(): if not cached_dep or not varname or not subi or not cached_dep.found():
return return
dep = subi.get_variable_method([varname], {}) dep = subi.get_variable_method([varname], {})
@ -3591,13 +3591,13 @@ external dependencies (including libraries) must go to "dependencies".''')
m = 'Inconsistency: Subproject has overridden the dependency with another variable than {!r}' m = 'Inconsistency: Subproject has overridden the dependency with another variable than {!r}'
raise DependencyException(m.format(varname)) raise DependencyException(m.format(varname))
def get_subproject_dep(self, name, display_name, dirname, varname, kwargs): def get_subproject_dep(self, name, display_name, subp_name, varname, kwargs):
required = kwargs.get('required', True) required = kwargs.get('required', True)
wanted = mesonlib.stringlistify(kwargs.get('version', [])) wanted = mesonlib.stringlistify(kwargs.get('version', []))
subproj_path = os.path.join(self.subproject_dir, dirname) subproj_path = os.path.join(self.subproject_dir, subp_name)
dep = self.notfound_dependency() dep = self.notfound_dependency()
try: try:
subproject = self.subprojects[dirname] subproject = self.subprojects[subp_name]
_, cached_dep = self._find_cached_dep(name, display_name, kwargs) _, cached_dep = self._find_cached_dep(name, display_name, kwargs)
if varname is None: if varname is None:
# Assuming the subproject overridden the dependency we want # Assuming the subproject overridden the dependency we want
@ -3614,19 +3614,19 @@ external dependencies (including libraries) must go to "dependencies".''')
mlog.bold(subproj_path), 'found:', mlog.red('NO')) mlog.bold(subproj_path), 'found:', mlog.red('NO'))
return self.notfound_dependency() return self.notfound_dependency()
if subproject.found(): if subproject.found():
self.verify_fallback_consistency(dirname, varname, cached_dep) self.verify_fallback_consistency(subp_name, varname, cached_dep)
dep = self.subprojects[dirname].get_variable_method([varname], {}) dep = self.subprojects[subp_name].get_variable_method([varname], {})
except InvalidArguments: except InvalidArguments:
pass pass
if not isinstance(dep, DependencyHolder): if not isinstance(dep, DependencyHolder):
raise InvalidCode('Fetched variable {!r} in the subproject {!r} is ' raise InvalidCode('Fetched variable {!r} in the subproject {!r} is '
'not a dependency object.'.format(varname, dirname)) 'not a dependency object.'.format(varname, subp_name))
if not dep.found(): if not dep.found():
if required: if required:
raise DependencyException('Could not find dependency {} in subproject {}' raise DependencyException('Could not find dependency {} in subproject {}'
''.format(varname, dirname)) ''.format(varname, subp_name))
# If the dependency is not required, don't raise an exception # If the dependency is not required, don't raise an exception
mlog.log('Dependency', mlog.bold(display_name), 'from subproject', mlog.log('Dependency', mlog.bold(display_name), 'from subproject',
mlog.bold(subproj_path), 'found:', mlog.red('NO')) mlog.bold(subproj_path), 'found:', mlog.red('NO'))
@ -3637,7 +3637,7 @@ external dependencies (including libraries) must go to "dependencies".''')
if required: if required:
raise DependencyException('Version {} of subproject dependency {} already ' raise DependencyException('Version {} of subproject dependency {} already '
'cached, requested incompatible version {} for ' 'cached, requested incompatible version {} for '
'dep {}'.format(found, dirname, wanted, display_name)) 'dep {}'.format(found, subp_name, wanted, display_name))
mlog.log('Dependency', mlog.bold(display_name), 'from subproject', mlog.log('Dependency', mlog.bold(display_name), 'from subproject',
mlog.bold(subproj_path), 'found:', mlog.red('NO'), mlog.bold(subproj_path), 'found:', mlog.red('NO'),
@ -3733,8 +3733,8 @@ external dependencies (including libraries) must go to "dependencies".''')
provider = self.environment.wrap_resolver.find_dep_provider(name) provider = self.environment.wrap_resolver.find_dep_provider(name)
if not provider and allow_fallback is True: if not provider and allow_fallback is True:
raise InvalidArguments('Fallback wrap or subproject not found for dependency \'%s\'' % name) raise InvalidArguments('Fallback wrap or subproject not found for dependency \'%s\'' % name)
dirname = mesonlib.listify(provider)[0] subp_name = mesonlib.listify(provider)[0]
if provider and (allow_fallback is True or required or self.get_subproject(dirname)): if provider and (allow_fallback is True or required or self.get_subproject(subp_name)):
fallback = provider fallback = provider
if 'default_options' in kwargs and not fallback: if 'default_options' in kwargs and not fallback:
@ -3752,8 +3752,8 @@ external dependencies (including libraries) must go to "dependencies".''')
identifier, cached_dep = self._find_cached_dep(name, display_name, kwargs) identifier, cached_dep = self._find_cached_dep(name, display_name, kwargs)
if cached_dep: if cached_dep:
if fallback: if fallback:
dirname, varname = self.get_subproject_infos(fallback) subp_name, varname = self.get_subproject_infos(fallback)
self.verify_fallback_consistency(dirname, varname, cached_dep) self.verify_fallback_consistency(subp_name, varname, cached_dep)
if required and not cached_dep.found(): if required and not cached_dep.found():
m = 'Dependency {!r} was already checked and was not found' m = 'Dependency {!r} was already checked and was not found'
raise DependencyException(m.format(display_name)) raise DependencyException(m.format(display_name))
@ -3762,16 +3762,16 @@ external dependencies (including libraries) must go to "dependencies".''')
if fallback: if fallback:
# If the dependency has already been configured, possibly by # If the dependency has already been configured, possibly by
# a higher level project, try to use it first. # a higher level project, try to use it first.
dirname, varname = self.get_subproject_infos(fallback) subp_name, varname = self.get_subproject_infos(fallback)
if self.get_subproject(dirname): if self.get_subproject(subp_name):
return self.get_subproject_dep(name, display_name, dirname, varname, kwargs) return self.get_subproject_dep(name, display_name, subp_name, varname, kwargs)
wrap_mode = self.coredata.get_builtin_option('wrap_mode') wrap_mode = self.coredata.get_builtin_option('wrap_mode')
force_fallback_for = self.coredata.get_builtin_option('force_fallback_for') force_fallback_for = self.coredata.get_builtin_option('force_fallback_for')
force_fallback = (force_fallback or force_fallback = (force_fallback or
wrap_mode == WrapMode.forcefallback or wrap_mode == WrapMode.forcefallback or
name in force_fallback_for or name in force_fallback_for or
dirname in force_fallback_for) subp_name in force_fallback_for)
if name != '' and (not fallback or not force_fallback): if name != '' and (not fallback or not force_fallback):
self._handle_featurenew_dependencies(name) self._handle_featurenew_dependencies(name)
@ -3825,13 +3825,13 @@ external dependencies (including libraries) must go to "dependencies".''')
return fbinfo return fbinfo
def dependency_fallback(self, name, display_name, fallback, kwargs): def dependency_fallback(self, name, display_name, fallback, kwargs):
dirname, varname = self.get_subproject_infos(fallback) subp_name, varname = self.get_subproject_infos(fallback)
required = kwargs.get('required', True) required = kwargs.get('required', True)
# Explicitly listed fallback preferences for specific subprojects # Explicitly listed fallback preferences for specific subprojects
# take precedence over wrap-mode # take precedence over wrap-mode
force_fallback_for = self.coredata.get_builtin_option('force_fallback_for') force_fallback_for = self.coredata.get_builtin_option('force_fallback_for')
if name in force_fallback_for or dirname in force_fallback_for: if name in force_fallback_for or subp_name in force_fallback_for:
mlog.log('Looking for a fallback subproject for the dependency', mlog.log('Looking for a fallback subproject for the dependency',
mlog.bold(display_name), 'because:\nUse of fallback was forced for that specific subproject') mlog.bold(display_name), 'because:\nUse of fallback was forced for that specific subproject')
elif self.coredata.get_builtin_option('wrap_mode') == WrapMode.nofallback: elif self.coredata.get_builtin_option('wrap_mode') == WrapMode.nofallback:
@ -3852,8 +3852,8 @@ external dependencies (including libraries) must go to "dependencies".''')
'default_options': kwargs.get('default_options', []), 'default_options': kwargs.get('default_options', []),
'required': required, 'required': required,
} }
self.do_subproject(dirname, 'meson', sp_kwargs) self.do_subproject(subp_name, 'meson', sp_kwargs)
return self.get_subproject_dep(name, display_name, dirname, varname, kwargs) return self.get_subproject_dep(name, display_name, subp_name, varname, kwargs)
@FeatureNewKwargs('executable', '0.42.0', ['implib']) @FeatureNewKwargs('executable', '0.42.0', ['implib'])
@permittedKwargs(permitted_kwargs['executable']) @permittedKwargs(permitted_kwargs['executable'])
@ -4709,11 +4709,11 @@ This will probably not work.
Try setting b_lundef to false instead.'''.format(self.coredata.base_options['b_sanitize'].value), Try setting b_lundef to false instead.'''.format(self.coredata.base_options['b_sanitize'].value),
location=self.current_node) location=self.current_node)
def evaluate_subproject_info(self, path_from_source_root, subproject_dirname): def evaluate_subproject_info(self, path_from_source_root, subproject_dir):
depth = 0 depth = 0
subproj_name = '' subproj_name = ''
segs = PurePath(path_from_source_root).parts segs = PurePath(path_from_source_root).parts
segs_spd = PurePath(subproject_dirname).parts segs_spd = PurePath(subproject_dir).parts
while segs and segs[0] == segs_spd[0]: while segs and segs[0] == segs_spd[0]:
if len(segs_spd) == 1: if len(segs_spd) == 1:
subproj_name = segs[1] subproj_name = segs[1]