files: # Copyright 2012-2016 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 os, pickle, re
  from .. import build
  from .. import dependencies
  from .. import mesonlib
  from .. import mlog
  from .. import compilers
  import json
  import subprocess
  from ..mesonlib import MesonException, OrderedSet
  from ..mesonlib import classify_unity_sources
  from ..mesonlib import File
  from ..compilers import CompilerArgs
  from collections import OrderedDict
  import shlex
  
  class CleanTrees:
      '''
      Directories outputted by custom targets that have to be manually cleaned
      because on Linux `ninja clean` only deletes empty directories.
      '''
      def __init__(self, build_dir, trees):
          self.build_dir = build_dir
          self.trees = trees
  
  class InstallData:
      def __init__(self, source_dir, build_dir, prefix, strip_bin,
                   install_umask, mesonintrospect):
          self.source_dir = source_dir
          self.build_dir = build_dir
          self.prefix = prefix
          self.strip_bin = strip_bin
          self.install_umask = install_umask
          self.targets = []
          self.headers = []
          self.man = []
          self.data = []
          self.po_package_name = ''
          self.po = []
          self.install_scripts = []
          self.install_subdirs = []
          self.mesonintrospect = mesonintrospect
  
  class TargetInstallData:
      def __init__(self, fname, outdir, aliases, strip, install_name_mappings, install_rpath, install_mode):
          self.fname = fname
          self.outdir = outdir
          self.aliases = aliases
          self.strip = strip
          self.install_name_mappings = install_name_mappings
          self.install_rpath = install_rpath
          self.install_mode = install_mode
  
  class ExecutableSerialisation:
      def __init__(self, name, fname, cmd_args, env, is_cross, exe_wrapper,
                   workdir, extra_paths, capture):
          self.name = name
          self.fname = fname
          self.cmd_args = cmd_args
          self.env = env
          self.is_cross = is_cross
          self.exe_runner = exe_wrapper
          self.workdir = workdir
          self.extra_paths = extra_paths
          self.capture = capture
  
  class TestSerialisation:
      def __init__(self, name, project, suite, fname, is_cross_built, exe_wrapper, is_parallel,
                   cmd_args, env, should_fail, timeout, workdir, extra_paths):
          self.name = name
          self.project_name = project
          self.suite = suite
          self.fname = fname
          self.is_cross_built = is_cross_built
          self.exe_runner = exe_wrapper
          self.is_parallel = is_parallel
          self.cmd_args = cmd_args
          self.env = env
          self.should_fail = should_fail
          self.timeout = timeout
          self.workdir = workdir
          self.extra_paths = extra_paths
  
  class OptionProxy:
      def __init__(self, name, value):
          self.name = name
          self.value = value
  
  class OptionOverrideProxy:
      '''Mimic an option list but transparently override
      selected option values.'''
      def __init__(self, overrides, *options):
          self.overrides = overrides
          self.options = options
  
      def __getitem__(self, option_name):
          for opts in self.options:
              if option_name in opts:
                  return self._get_override(option_name, opts[option_name])
          raise KeyError('Option not found', option_name)
  
      def _get_override(self, option_name, base_opt):
          if option_name in self.overrides:
              return OptionProxy(base_opt.name, base_opt.validate_value(self.overrides[option_name]))
          return base_opt
  
  # This class contains the basic functionality that is needed by all backends.
  # Feel free to move stuff in and out of it as you see fit.
  class Backend:
      def __init__(self, build):
          self.build = build
          self.environment = build.environment
          self.processed_targets = {}
          self.build_to_src = os.path.relpath(self.environment.get_source_dir(),
                                              self.environment.get_build_dir())
  
      def get_target_filename(self, t):
          if isinstance(t, build.CustomTarget):
              if len(t.get_outputs()) != 1:
                  mlog.warning('custom_target {!r} has more than one output! '
                               'Using the first one.'.format(t.name))
              filename = t.get_outputs()[0]
          else:
              assert(isinstance(t, build.BuildTarget))
              filename = t.get_filename()
          return os.path.join(self.get_target_dir(t), filename)
  
      def get_target_filename_abs(self, target):
          return os.path.join(self.environment.get_build_dir(), self.get_target_filename(target))
  
      def get_builtin_options_for_target(self, target):
          return OptionOverrideProxy(target.option_overrides,
                                     self.environment.coredata.builtins)
  
      def get_base_options_for_target(self, target):
          return OptionOverrideProxy(target.option_overrides,
                                     self.environment.coredata.builtins,
                                     self.environment.coredata.base_options)
  
      def get_compiler_options_for_target(self, target):
          return OptionOverrideProxy(target.option_overrides,
                                     # no code depends on builtins for now
                                     self.environment.coredata.compiler_options)
  
      def get_option_for_target(self, option_name, target):
          if option_name in target.option_overrides:
              override = target.option_overrides[option_name]
              return self.environment.coredata.validate_option_value(option_name, override)
          return self.environment.coredata.get_builtin_option(option_name)
  
      def get_target_filename_for_linking(self, target):
          # On some platforms (msvc for instance), the file that is used for
          # dynamic linking is not the same as the dynamic library itself. This
          # file is called an import library, and we want to link against that.
          # On all other platforms, we link to the library directly.
          if isinstance(target, build.SharedLibrary):
              link_lib = target.get_import_filename() or target.get_filename()
              return os.path.join(self.get_target_dir(target), link_lib)
          elif isinstance(target, build.StaticLibrary):
              return os.path.join(self.get_target_dir(target), target.get_filename())
          elif isinstance(target, build.Executable):
              if target.import_filename:
                  return os.path.join(self.get_target_dir(target), target.get_import_filename())
              else:
                  return None
          raise AssertionError('BUG: Tried to link to {!r} which is not linkable'.format(target))
  
      def get_target_dir(self, target):
          if self.environment.coredata.get_builtin_option('layout') == 'mirror':
              dirname = target.get_subdir()
          else:
              dirname = 'meson-out'
          return dirname
  
      def get_target_dir_relative_to(self, t, o):
          '''Get a target dir relative to another target's directory'''
          target_dir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(t))
          othert_dir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(o))
          return os.path.relpath(target_dir, othert_dir)
  
      def get_target_source_dir(self, target):
          # if target dir is empty, avoid extraneous trailing / from os.path.join()
          target_dir = self.get_target_dir(target)
          if target_dir:
              return os.path.join(self.build_to_src, target_dir)
          return self.build_to_src
  
      def get_target_private_dir(self, target):
          return os.path.join(self.get_target_dir(target), target.get_id())
  
      def get_target_private_dir_abs(self, target):
          return os.path.join(self.environment.get_build_dir(), self.get_target_private_dir(target))
  
      def get_target_generated_dir(self, target, gensrc, src):
          """
          Takes a BuildTarget, a generator source (CustomTarget or GeneratedList),
          and a generated source filename.
          Returns the full path of the generated source relative to the build root
          """
          # CustomTarget generators output to the build dir of the CustomTarget
          if isinstance(gensrc, (build.CustomTarget, build.CustomTargetIndex)):
              return os.path.join(self.get_target_dir(gensrc), src)
          # GeneratedList generators output to the private build directory of the
          # target that the GeneratedList is used in
          return os.path.join(self.get_target_private_dir(target), src)
  
      def get_unity_source_file(self, target, suffix):
          # There is a potential conflict here, but it is unlikely that
          # anyone both enables unity builds and has a file called foo-unity.cpp.
          osrc = target.name + '-unity.' + suffix
          return mesonlib.File.from_built_file(self.get_target_private_dir(target), osrc)
  
      def generate_unity_files(self, target, unity_src):
          abs_files = []
          result = []
          compsrcs = classify_unity_sources(target.compilers.values(), unity_src)
  
          def init_language_file(suffix):
              unity_src = self.get_unity_source_file(target, suffix)
              outfileabs = unity_src.absolute_path(self.environment.get_source_dir(),
                                                   self.environment.get_build_dir())
              outfileabs_tmp = outfileabs + '.tmp'
              abs_files.append(outfileabs)
              outfileabs_tmp_dir = os.path.dirname(outfileabs_tmp)
              if not os.path.exists(outfileabs_tmp_dir):
                  os.makedirs(outfileabs_tmp_dir)
              result.append(unity_src)
              return open(outfileabs_tmp, 'w')
  
          # For each language, generate a unity source file and return the list
          for comp, srcs in compsrcs.items():
              with init_language_file(comp.get_default_suffix()) as ofile:
                  for src in srcs:
                      ofile.write('#include<%s>\n' % src)
          [mesonlib.replace_if_different(x, x + '.tmp') for x in abs_files]
          return result
  
      def relpath(self, todir, fromdir):
          return os.path.relpath(os.path.join('dummyprefixdir', todir),
                                 os.path.join('dummyprefixdir', fromdir))
  
      def flatten_object_list(self, target, proj_dir_to_build_root=''):
          return self._flatten_object_list(target, target.get_objects(), proj_dir_to_build_root)
  
      def _flatten_object_list(self, target, objects, proj_dir_to_build_root):
          obj_list = []
          for obj in objects:
              if isinstance(obj, str):
                  o = os.path.join(proj_dir_to_build_root,
                                   self.build_to_src, target.get_subdir(), obj)
                  obj_list.append(o)
              elif isinstance(obj, mesonlib.File):
                  obj_list.append(obj.rel_to_builddir(self.build_to_src))
              elif isinstance(obj, build.ExtractedObjects):
                  if obj.recursive:
                      obj_list += self._flatten_object_list(obj.target, obj.objlist, proj_dir_to_build_root)
                  obj_list += self.determine_ext_objs(obj, proj_dir_to_build_root)
              else:
                  raise MesonException('Unknown data type in object list.')
          return obj_list
  
      def serialize_executable(self, exe, cmd_args, workdir, env={},
                               extra_paths=None, capture=None):
          import hashlib
          if extra_paths is None:
              # The callee didn't check if we needed extra paths, so check it here
              if mesonlib.is_windows() or mesonlib.is_cygwin():
                  extra_paths = self.determine_windows_extra_paths(exe, [])
              else:
                  extra_paths = []
          # Can't just use exe.name here; it will likely be run more than once
          if isinstance(exe, (dependencies.ExternalProgram,
                              build.BuildTarget, build.CustomTarget)):
              basename = exe.name
          else:
              basename = os.path.basename(exe)
          # Take a digest of the cmd args, env, workdir, and capture. This avoids
          # collisions and also makes the name deterministic over regenerations
          # which avoids a rebuild by Ninja because the cmdline stays the same.
          data = bytes(str(sorted(env.items())) + str(cmd_args) + str(workdir) + str(capture),
                       encoding='utf-8')
          digest = hashlib.sha1(data).hexdigest()
          scratch_file = 'meson_exe_{0}_{1}.dat'.format(basename, digest)
          exe_data = os.path.join(self.environment.get_scratch_dir(), scratch_file)
          with open(exe_data, 'wb') as f:
              if isinstance(exe, dependencies.ExternalProgram):
                  exe_cmd = exe.get_command()
                  exe_needs_wrapper = False
              elif isinstance(exe, (build.BuildTarget, build.CustomTarget)):
                  exe_cmd = [self.get_target_filename_abs(exe)]
                  exe_needs_wrapper = exe.is_cross
              else:
                  exe_cmd = [exe]
                  exe_needs_wrapper = False
              is_cross_built = exe_needs_wrapper and \
                  self.environment.is_cross_build() and \
                  self.environment.cross_info.need_cross_compiler() and \
                  self.environment.cross_info.need_exe_wrapper()
              if is_cross_built:
                  exe_wrapper = self.environment.cross_info.config['binaries'].get('exe_wrapper', None)
              else:
                  exe_wrapper = None
              es = ExecutableSerialisation(basename, exe_cmd, cmd_args, env,
                                           is_cross_built, exe_wrapper, workdir,
                                           extra_paths, capture)
              pickle.dump(es, f)
          return exe_data
  
      def serialize_tests(self):
          test_data = os.path.join(self.environment.get_scratch_dir(), 'meson_test_setup.dat')
          with open(test_data, 'wb') as datafile:
              self.write_test_file(datafile)
          benchmark_data = os.path.join(self.environment.get_scratch_dir(), 'meson_benchmark_setup.dat')
          with open(benchmark_data, 'wb') as datafile:
              self.write_benchmark_file(datafile)
          return test_data, benchmark_data
  
      def determine_linker_and_stdlib_args(self, target):
          '''
          If we're building a static library, there is only one static linker.
          Otherwise, we query the target for the dynamic linker.
          '''
          if isinstance(target, build.StaticLibrary):
              if target.is_cross:
                  return self.build.static_cross_linker, []
              else:
                  return self.build.static_linker, []
          l, stdlib_args = target.get_clink_dynamic_linker_and_stdlibs()
          return l, stdlib_args
  
      @staticmethod
      def _libdir_is_system(libdir, compilers):
          for cc in compilers.values():
              if libdir in cc.get_library_dirs():
                  return True
          return False
  
      def rpaths_for_bundled_shared_libraries(self, target, exclude_system=True):
          paths = []
          for dep in target.external_deps:
              if not isinstance(dep, (dependencies.ExternalLibrary, dependencies.PkgConfigDependency)):
                  continue
              la = dep.link_args
              if len(la) != 1 or not os.path.isabs(la[0]):
                  continue
              # The only link argument is an absolute path to a library file.
              libpath = la[0]
              libdir = os.path.dirname(libpath)
              if exclude_system and self._libdir_is_system(libdir, target.compilers):
                  # No point in adding system paths.
                  continue
              # Windows doesn't support rpaths, but we use this function to
              # emulate rpaths by setting PATH, so also accept DLLs here
              if os.path.splitext(libpath)[1] not in ['.dll', '.lib', '.so', '.dylib']:
                  continue
              if libdir.startswith(self.environment.get_source_dir()):
                  rel_to_src = libdir[len(self.environment.get_source_dir()) + 1:]
                  assert not os.path.isabs(rel_to_src), 'rel_to_src: {} is absolute'.format(rel_to_src)
                  paths.append(os.path.join(self.build_to_src, rel_to_src))
              else:
                  paths.append(libdir)
          return paths
  
      def determine_rpath_dirs(self, target):
          link_deps = target.get_all_link_deps()
          result = set()
          for ld in link_deps:
              if ld is target:
                  continue
              result.add(self.get_target_dir(ld))
          result.update(self.rpaths_for_bundled_shared_libraries(target))
          return list(result)
  
      def object_filename_from_source(self, target, source):
          assert isinstance(source, mesonlib.File)
          build_dir = self.environment.get_build_dir()
          rel_src = source.rel_to_builddir(self.build_to_src)
  
          # foo.vala files compile down to foo.c and then foo.c.o, not foo.vala.o
          if rel_src.endswith(('.vala', '.gs')):
              # See description in generate_vala_compile for this logic.
              if source.is_built:
                  if os.path.isabs(rel_src):
                      rel_src = rel_src[len(build_dir) + 1:]
                  rel_src = os.path.relpath(rel_src, self.get_target_private_dir(target))
              else:
                  rel_src = os.path.basename(rel_src)
              # A meson- prefixed directory is reserved; hopefully no-one creates a file name with such a weird prefix.
              source = 'meson-generated_' + rel_src[:-5] + '.c'
          elif source.is_built:
              if os.path.isabs(rel_src):
                  rel_src = rel_src[len(build_dir) + 1:]
              targetdir = self.get_target_private_dir(target)
              # A meson- prefixed directory is reserved; hopefully no-one creates a file name with such a weird prefix.
              source = 'meson-generated_' + os.path.relpath(rel_src, targetdir)
          else:
              if os.path.isabs(rel_src):
                  # Not from the source directory; hopefully this doesn't conflict with user's source files.
                  source = os.path.basename(rel_src)
              else:
                  source = os.path.relpath(os.path.join(build_dir, rel_src),
                                           os.path.join(self.environment.get_source_dir(), target.get_subdir()))
          return source.replace('/', '_').replace('\\', '_') + '.' + self.environment.get_object_suffix()
  
      def determine_ext_objs(self, extobj, proj_dir_to_build_root):
          result = []
  
          # Merge sources and generated sources
          sources = list(extobj.srclist)
          for gensrc in extobj.genlist:
              for s in gensrc.get_outputs():
                  path = self.get_target_generated_dir(extobj.target, gensrc, s)
                  dirpart, fnamepart = os.path.split(path)
                  sources.append(File(True, dirpart, fnamepart))
  
          # Filter out headers and all non-source files
          sources = [s for s in sources if self.environment.is_source(s) and not self.environment.is_header(s)]
  
          # extobj could contain only objects and no sources
          if not sources:
              return result
  
          targetdir = self.get_target_private_dir(extobj.target)
  
          # With unity builds, there's just one object that contains all the
          # sources, and we only support extracting all the objects in this mode,
          # so just return that.
          if self.is_unity(extobj.target):
              compsrcs = classify_unity_sources(extobj.target.compilers.values(), sources)
              sources = []
              for comp in compsrcs.keys():
                  osrc = self.get_unity_source_file(extobj.target,
                                                    comp.get_default_suffix())
                  sources.append(osrc)
  
          for osrc in sources:
              objname = self.object_filename_from_source(extobj.target, osrc)
              objpath = os.path.join(proj_dir_to_build_root, targetdir, objname)
              result.append(objpath)
  
          return result
  
      def get_pch_include_args(self, compiler, target):
          args = []
          pchpath = self.get_target_private_dir(target)
          includeargs = compiler.get_include_args(pchpath, False)
          p = target.get_pch(compiler.get_language())
          if p:
              args += compiler.get_pch_use_args(pchpath, p[0])
          return includeargs + args
  
      @staticmethod
      def escape_extra_args(compiler, args):
          # No extra escaping/quoting needed when not running on Windows
          if not mesonlib.is_windows():
              return args
          extra_args = []
          # Compiler-specific escaping is needed for -D args but not for any others
          if compiler.get_id() == 'msvc':
              # MSVC needs escaping when a -D argument ends in \ or \"
              for arg in args:
                  if arg.startswith('-D') or arg.startswith('/D'):
                      # Without extra escaping for these two, the next character
                      # gets eaten
                      if arg.endswith('\\'):
                          arg += '\\'
                      elif arg.endswith('\\"'):
                          arg = arg[:-2] + '\\\\"'
                  extra_args.append(arg)
          else:
              # MinGW GCC needs all backslashes in defines to be doubly-escaped
              # FIXME: Not sure about Cygwin or Clang
              for arg in args:
                  if arg.startswith('-D') or arg.startswith('/D'):
                      arg = arg.replace('\\', '\\\\')
                  extra_args.append(arg)
          return extra_args
  
      def generate_basic_compiler_args(self, target, compiler, no_warn_args=False):
          # Create an empty commands list, and start adding arguments from
          # various sources in the order in which they must override each other
          # starting from hard-coded defaults followed by build options and so on.
          commands = CompilerArgs(compiler)
  
          copt_proxy = self.get_compiler_options_for_target(target)
          # First, the trivial ones that are impossible to override.
          #
          # Add -nostdinc/-nostdinc++ if needed; can't be overridden
          commands += self.get_cross_stdlib_args(target, compiler)
          # Add things like /NOLOGO or -pipe; usually can't be overridden
          commands += compiler.get_always_args()
          # Only add warning-flags by default if the buildtype enables it, and if
          # we weren't explicitly asked to not emit warnings (for Vala, f.ex)
          if no_warn_args:
              commands += compiler.get_no_warn_args()
          elif self.get_option_for_target('buildtype', target) != 'plain':
              commands += compiler.get_warn_args(self.get_option_for_target('warning_level', target))
          # Add -Werror if werror=true is set in the build options set on the
          # command-line or default_options inside project(). This only sets the
          # action to be done for warnings if/when they are emitted, so it's ok
          # to set it after get_no_warn_args() or get_warn_args().
          if self.get_option_for_target('werror', target):
              commands += compiler.get_werror_args()
          # Add compile args for c_* or cpp_* build options set on the
          # command-line or default_options inside project().
          commands += compiler.get_option_compile_args(copt_proxy)
          # Add buildtype args: optimization level, debugging, etc.
          commands += compiler.get_buildtype_args(self.get_option_for_target('buildtype', target))
          # Add compile args added using add_project_arguments()
          commands += self.build.get_project_args(compiler, target.subproject)
          # Add compile args added using add_global_arguments()
          # These override per-project arguments
          commands += self.build.get_global_args(compiler)
          if not target.is_cross:
              # Compile args added from the env: CFLAGS/CXXFLAGS, etc. We want these
              # to override all the defaults, but not the per-target compile args.
              commands += self.environment.coredata.get_external_args(compiler.get_language())
          # Always set -fPIC for shared libraries
          if isinstance(target, build.SharedLibrary):
              commands += compiler.get_pic_args()
          # Set -fPIC for static libraries by default unless explicitly disabled
          if isinstance(target, build.StaticLibrary) and target.pic:
              commands += compiler.get_pic_args()
          # Add compile args needed to find external dependencies. Link args are
          # added while generating the link command.
          # NOTE: We must preserve the order in which external deps are
          # specified, so we reverse the list before iterating over it.
          for dep in reversed(target.get_external_deps()):
              if not dep.found():
                  continue
  
              if compiler.language == 'vala':
                  if isinstance(dep, dependencies.PkgConfigDependency):
                      if dep.name == 'glib-2.0' and dep.version_reqs is not None:
                          for req in dep.version_reqs:
                              if req.startswith(('>=', '==')):
                                  commands += ['--target-glib', req[2:]]
                                  break
                      commands += ['--pkg', dep.name]
                  elif isinstance(dep, dependencies.ExternalLibrary):
                      commands += dep.get_link_args('vala')
              else:
                  commands += dep.get_compile_args()
              # Qt needs -fPIC for executables
              # XXX: We should move to -fPIC for all executables
              if isinstance(target, build.Executable):
                  commands += dep.get_exe_args(compiler)
              # For 'automagic' deps: Boost and GTest. Also dependency('threads').
              # pkg-config puts the thread flags itself via `Cflags:`
              if dep.need_threads():
                  commands += compiler.thread_flags(self.environment)
              elif dep.need_openmp():
                  commands += compiler.openmp_flags()
          # Fortran requires extra include directives.
          if compiler.language == 'fortran':
              for lt in target.link_targets:
                  priv_dir = self.get_target_private_dir(lt)
                  commands += compiler.get_include_args(priv_dir, False)
          return commands
  
      def build_target_link_arguments(self, compiler, deps):
          args = []
          for d in deps:
              if not (d.is_linkable_target()):
                  raise RuntimeError('Tried to link with a non-library target "%s".' % d.get_basename())
              d_arg = self.get_target_filename_for_linking(d)
              if not d_arg:
                  continue
              if isinstance(compiler, (compilers.LLVMDCompiler, compilers.DmdDCompiler)):
                  d_arg = '-L' + d_arg
              args.append(d_arg)
          return args
  
      def get_mingw_extra_paths(self, target):
          paths = OrderedSet()
          # The cross bindir
          root = self.environment.cross_info.get_root()
          if root:
              paths.add(os.path.join(root, 'bin'))
          # The toolchain bindir
          sys_root = self.environment.cross_info.get_sys_root()
          if sys_root:
              paths.add(os.path.join(sys_root, 'bin'))
          # Get program and library dirs from all target compilers
          if isinstance(target, build.BuildTarget):
              for cc in target.compilers.values():
                  paths.update(cc.get_program_dirs())
                  paths.update(cc.get_library_dirs())
          return list(paths)
  
      def determine_windows_extra_paths(self, target, extra_bdeps, is_cross=False):
          '''On Windows there is no such thing as an rpath.
          We must determine all locations of DLLs that this exe
          links to and return them so they can be used in unit
          tests.'''
          result = set()
          prospectives = set()
          if isinstance(target, build.BuildTarget):
              prospectives.update(target.get_transitive_link_deps())
              # External deps
              for deppath in self.rpaths_for_bundled_shared_libraries(target, exclude_system=False):
                  result.add(os.path.normpath(os.path.join(self.environment.get_build_dir(), deppath)))
          for bdep in extra_bdeps:
              prospectives.update(bdep.get_transitive_link_deps())
          # Internal deps
          for ld in prospectives:
              if ld == '' or ld == '.':
                  continue
              dirseg = os.path.join(self.environment.get_build_dir(), self.get_target_dir(ld))
              result.add(dirseg)
          if is_cross:
              result.update(self.get_mingw_extra_paths(target))
          return list(result)
  
      def write_benchmark_file(self, datafile):
          self.write_test_serialisation(self.build.get_benchmarks(), datafile)
  
      def write_test_file(self, datafile):
          self.write_test_serialisation(self.build.get_tests(), datafile)
  
      def write_test_serialisation(self, tests, datafile):
          arr = []
          for t in tests:
              exe = t.get_exe()
              if isinstance(exe, dependencies.ExternalProgram):
                  cmd = exe.get_command()
              else:
                  cmd = [os.path.join(self.environment.get_build_dir(), self.get_target_filename(t.get_exe()))]
              is_cross = self.environment.is_cross_build() and \
                  self.environment.cross_info.need_cross_compiler() and \
                  self.environment.cross_info.need_exe_wrapper()
              if isinstance(exe, build.BuildTarget):
                  is_cross = is_cross and exe.is_cross
              if isinstance(exe, dependencies.ExternalProgram):
                  # E.g. an external verifier or simulator program run on a generated executable.
                  # Can always be run.
                  is_cross = False
              if is_cross:
                  exe_wrapper = self.environment.cross_info.config['binaries'].get('exe_wrapper', None)
              else:
                  exe_wrapper = None
              if mesonlib.for_windows(is_cross, self.environment) or \
                 mesonlib.for_cygwin(is_cross, self.environment):
                  extra_bdeps = []
                  if isinstance(exe, build.CustomTarget):
                      extra_bdeps = exe.get_transitive_build_target_deps()
                  extra_paths = self.determine_windows_extra_paths(exe, extra_bdeps, is_cross)
              else:
                  extra_paths = []
              cmd_args = []
              for a in t.cmd_args:
                  if hasattr(a, 'held_object'):
                      a = a.held_object
                  if isinstance(a, build.BuildTarget):
                      extra_paths += self.determine_windows_extra_paths(a, [])
                  if isinstance(a, mesonlib.File):
                      a = os.path.join(self.environment.get_build_dir(), a.rel_to_builddir(self.build_to_src))
                      cmd_args.append(a)
                  elif isinstance(a, str):
                      cmd_args.append(a)
                  elif isinstance(a, build.Target):
                      cmd_args.append(self.get_target_filename(a))
                  else:
                      raise MesonException('Bad object in test command.')
              ts = TestSerialisation(t.get_name(), t.project_name, t.suite, cmd, is_cross,
                                     exe_wrapper, t.is_parallel, cmd_args, t.env,
                                     t.should_fail, t.timeout, t.workdir, extra_paths)
              arr.append(ts)
          pickle.dump(arr, datafile)
  
      def generate_depmf_install(self, d):
          if self.build.dep_manifest_name is None:
              return
          ifilename = os.path.join(self.environment.get_build_dir(), 'depmf.json')
          ofilename = os.path.join(self.environment.get_prefix(), self.build.dep_manifest_name)
          mfobj = {'type': 'dependency manifest', 'version': '1.0', 'projects': self.build.dep_manifest}
          with open(ifilename, 'w') as f:
              f.write(json.dumps(mfobj))
          # Copy file from, to, and with mode unchanged
          d.data.append([ifilename, ofilename, None])
  
      def get_regen_filelist(self):
          '''List of all files whose alteration means that the build
          definition needs to be regenerated.'''
          deps = [os.path.join(self.build_to_src, df)
                  for df in self.interpreter.get_build_def_files()]
          if self.environment.is_cross_build():
              deps.append(os.path.join(self.build_to_src,
                                       self.environment.coredata.cross_file))
          deps.append('meson-private/coredata.dat')
          if os.path.exists(os.path.join(self.environment.get_source_dir(), 'meson_options.txt')):
              deps.append(os.path.join(self.build_to_src, 'meson_options.txt'))
          for sp in self.build.subprojects.keys():
              fname = os.path.join(self.environment.get_source_dir(), sp, 'meson_options.txt')
              if os.path.isfile(fname):
                  deps.append(os.path.join(self.build_to_src, sp, 'meson_options.txt'))
          return deps
  
      def exe_object_to_cmd_array(self, exe):
          if self.environment.is_cross_build() and \
             self.environment.cross_info.need_exe_wrapper() and \
             isinstance(exe, build.BuildTarget) and exe.is_cross:
              if 'exe_wrapper' not in self.environment.cross_info.config['binaries']:
                  s = 'Can not use target %s as a generator because it is cross-built\n'
                  s += 'and no exe wrapper is defined. You might want to set it to native instead.'
                  s = s % exe.name
                  raise MesonException(s)
          if isinstance(exe, build.BuildTarget):
              exe_arr = [os.path.join(self.environment.get_build_dir(), self.get_target_filename(exe))]
          else:
              exe_arr = exe.get_command()
          return exe_arr
  
      def replace_extra_args(self, args, genlist):
          final_args = []
          for a in args:
              if a == '@EXTRA_ARGS@':
                  final_args += genlist.get_extra_args()
              else:
                  final_args.append(a)
          return final_args
  
      def replace_outputs(self, args, private_dir, output_list):
          newargs = []
          regex = re.compile('@OUTPUT(\d+)@')
          for arg in args:
              m = regex.search(arg)
              while m is not None:
                  index = int(m.group(1))
                  src = '@OUTPUT%d@' % index
                  arg = arg.replace(src, os.path.join(private_dir, output_list[index]))
                  m = regex.search(arg)
              newargs.append(arg)
          return newargs
  
      def get_build_by_default_targets(self):
          result = OrderedDict()
          # Get all build and custom targets that must be built by default
          for name, t in self.build.get_targets().items():
              if t.build_by_default or t.install:
                  result[name] = t
          # Get all targets used as test executables and arguments. These must
          # also be built by default. XXX: Sometime in the future these should be
          # built only before running tests.
          for t in self.build.get_tests():
              exe = t.exe
              if hasattr(exe, 'held_object'):
                  exe = exe.held_object
              if isinstance(exe, (build.CustomTarget, build.BuildTarget)):
                  result[exe.get_id()] = exe
              for arg in t.cmd_args:
                  if hasattr(arg, 'held_object'):
                      arg = arg.held_object
                  if not isinstance(arg, (build.CustomTarget, build.BuildTarget)):
                      continue
                  result[arg.get_id()] = arg
              for dep in t.depends:
                  assert isinstance(dep, (build.CustomTarget, build.BuildTarget))
                  result[dep.get_id()] = dep
          return result
  
      def get_custom_target_provided_libraries(self, target):
          libs = []
          for t in target.get_generated_sources():
              if not isinstance(t, build.CustomTarget):
                  continue
              for f in t.get_outputs():
                  if self.environment.is_library(f):
                      libs.append(os.path.join(self.get_target_dir(t), f))
          return libs
  
      def is_unity(self, target):
          optval = self.get_option_for_target('unity', target)
          if optval == 'on' or (optval == 'subprojects' and target.subproject != ''):
              return True
          return False
  
      def get_custom_target_sources(self, target):
          '''
          Custom target sources can be of various object types; strings, File,
          BuildTarget, even other CustomTargets.
          Returns the path to them relative to the build root directory.
          '''
          srcs = []
          for i in target.get_sources():
              if hasattr(i, 'held_object'):
                  i = i.held_object
              if isinstance(i, str):
                  fname = [os.path.join(self.build_to_src, target.subdir, i)]
              elif isinstance(i, build.BuildTarget):
                  fname = [self.get_target_filename(i)]
              elif isinstance(i, (build.CustomTarget, build.CustomTargetIndex)):
                  fname = [os.path.join(self.get_target_dir(i), p) for p in i.get_outputs()]
              elif isinstance(i, build.GeneratedList):
                  fname = [os.path.join(self.get_target_private_dir(target), p) for p in i.get_outputs()]
              else:
                  fname = [i.rel_to_builddir(self.build_to_src)]
              if target.absolute_paths:
                  fname = [os.path.join(self.environment.get_build_dir(), f) for f in fname]
              srcs += fname
          return srcs
  
      def get_custom_target_depend_files(self, target, absolute_paths=False):
          deps = []
          for i in target.depend_files:
              if isinstance(i, mesonlib.File):
                  if absolute_paths:
                      deps.append(i.absolute_path(self.environment.get_source_dir(),
                                                  self.environment.get_build_dir()))
                  else:
                      deps.append(i.rel_to_builddir(self.build_to_src))
              else:
                  if absolute_paths:
                      deps.append(os.path.join(self.environment.get_source_dir(), target.subdir, i))
                  else:
                      deps.append(os.path.join(self.build_to_src, target.subdir, i))
          return deps
  
      def eval_custom_target_command(self, target, absolute_outputs=False):
          # We want the outputs to be absolute only when using the VS backend
          # XXX: Maybe allow the vs backend to use relative paths too?
          source_root = self.build_to_src
          build_root = '.'
          outdir = self.get_target_dir(target)
          if absolute_outputs:
              source_root = self.environment.get_source_dir()
              build_root = self.environment.get_build_dir()
              outdir = os.path.join(self.environment.get_build_dir(), outdir)
          outputs = []
          for i in target.get_outputs():
              outputs.append(os.path.join(outdir, i))
          inputs = self.get_custom_target_sources(target)
          # Evaluate the command list
          cmd = []
          for i in target.command:
              if isinstance(i, build.Executable):
                  cmd += self.exe_object_to_cmd_array(i)
                  continue
              elif isinstance(i, build.CustomTarget):
                  # GIR scanner will attempt to execute this binary but
                  # it assumes that it is in path, so always give it a full path.
                  tmp = i.get_outputs()[0]
                  i = os.path.join(self.get_target_dir(i), tmp)
              elif isinstance(i, mesonlib.File):
                  i = i.rel_to_builddir(self.build_to_src)
                  if target.absolute_paths:
                      i = os.path.join(self.environment.get_build_dir(), i)
              # FIXME: str types are blindly added ignoring 'target.absolute_paths'
              # because we can't know if they refer to a file or just a string
              elif not isinstance(i, str):
                  err_msg = 'Argument {0} is of unknown type {1}'
                  raise RuntimeError(err_msg.format(str(i), str(type(i))))
              elif '@SOURCE_ROOT@' in i:
                  i = i.replace('@SOURCE_ROOT@', source_root)
              elif '@BUILD_ROOT@' in i:
                  i = i.replace('@BUILD_ROOT@', build_root)
              elif '@DEPFILE@' in i:
                  if target.depfile is None:
                      msg = 'Custom target {!r} has @DEPFILE@ but no depfile ' \
                            'keyword argument.'.format(target.name)
                      raise MesonException(msg)
                  dfilename = os.path.join(outdir, target.depfile)
                  i = i.replace('@DEPFILE@', dfilename)
              elif '@PRIVATE_OUTDIR_' in i:
                  match = re.search('@PRIVATE_OUTDIR_(ABS_)?([^/\s*]*)@', i)
                  if not match:
                      msg = 'Custom target {!r} has an invalid argument {!r}' \
                            ''.format(target.name, i)
                      raise MesonException(msg)
                  source = match.group(0)
                  if match.group(1) is None and not target.absolute_paths:
                      lead_dir = ''
                  else:
                      lead_dir = self.environment.get_build_dir()
                  i = i.replace(source, os.path.join(lead_dir, outdir))
              cmd.append(i)
          # Substitute the rest of the template strings
          values = mesonlib.get_filenames_templates_dict(inputs, outputs)
          cmd = mesonlib.substitute_values(cmd, values)
          # This should not be necessary but removing it breaks
          # building GStreamer on Windows. The underlying issue
          # is problems with quoting backslashes on Windows
          # which is the seventh circle of hell. The downside is
          # that this breaks custom targets whose command lines
          # have backslashes. If you try to fix this be sure to
          # check that it does not break GST.
          #
          # The bug causes file paths such as c:\foo to get escaped
          # into c:\\foo.
          #
          # Unfortunately we have not been able to come up with an
          # isolated test case for this so unless you manage to come up
          # with one, the only way is to test the building with Gst's
          # setup. Note this in your MR or ping us and we will get it
          # fixed.
          #
          # https://github.com/mesonbuild/meson/pull/737
          cmd = [i.replace('\\', '/') for i in cmd]
          return inputs, outputs, cmd
  
      def run_postconf_scripts(self):
          env = {'MESON_SOURCE_ROOT': self.environment.get_source_dir(),
                 'MESON_BUILD_ROOT': self.environment.get_build_dir(),
                 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in self.environment.get_build_command() + ['introspect']]),
                 }
          child_env = os.environ.copy()
          child_env.update(env)
  
          for s in self.build.postconf_scripts:
              cmd = s['exe'] + s['args']
              subprocess.check_call(cmd, env=child_env)
  
files: mesonbuild/backend/backends.py
files: # Copyright 2012-2016 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 os, pickle, re
  from .. import build
  from .. import dependencies
  from .. import mesonlib
  from .. import mlog
  from .. import compilers
  import json
  import subprocess
  from ..mesonlib import MesonException, OrderedSet
  from ..mesonlib import classify_unity_sources
  from ..mesonlib import File
  from ..compilers import CompilerArgs
  from collections import OrderedDict
  import shlex
  
  class CleanTrees:
      '''
      Directories outputted by custom targets that have to be manually cleaned
      because on Linux `ninja clean` only deletes empty directories.
      '''
      def __init__(self, build_dir, trees):
          self.build_dir = build_dir
          self.trees = trees
  
  class InstallData:
      def __init__(self, source_dir, build_dir, prefix, strip_bin,
                   install_umask, mesonintrospect):
          self.source_dir = source_dir
          self.build_dir = build_dir
          self.prefix = prefix
          self.strip_bin = strip_bin
          self.install_umask = install_umask
          self.targets = []
          self.headers = []
          self.man = []
          self.data = []
          self.po_package_name = ''
          self.po = []
          self.install_scripts = []
          self.install_subdirs = []
          self.mesonintrospect = mesonintrospect
  
  class TargetInstallData:
      def __init__(self, fname, outdir, aliases, strip, install_name_mappings, install_rpath, install_mode):
          self.fname = fname
          self.outdir = outdir
          self.aliases = aliases
          self.strip = strip
          self.install_name_mappings = install_name_mappings
          self.install_rpath = install_rpath
          self.install_mode = install_mode
  
  class ExecutableSerialisation:
      def __init__(self, name, fname, cmd_args, env, is_cross, exe_wrapper,
                   workdir, extra_paths, capture):
          self.name = name
          self.fname = fname
          self.cmd_args = cmd_args
          self.env = env
          self.is_cross = is_cross
          self.exe_runner = exe_wrapper
          self.workdir = workdir
          self.extra_paths = extra_paths
          self.capture = capture
  
  class TestSerialisation:
      def __init__(self, name, project, suite, fname, is_cross_built, exe_wrapper, is_parallel,
                   cmd_args, env, should_fail, timeout, workdir, extra_paths):
          self.name = name
          self.project_name = project
          self.suite = suite
          self.fname = fname
          self.is_cross_built = is_cross_built
          self.exe_runner = exe_wrapper
          self.is_parallel = is_parallel
          self.cmd_args = cmd_args
          self.env = env
          self.should_fail = should_fail
          self.timeout = timeout
          self.workdir = workdir
          self.extra_paths = extra_paths
  
  class OptionProxy:
      def __init__(self, name, value):
          self.name = name
          self.value = value
  
  class OptionOverrideProxy:
      '''Mimic an option list but transparently override
      selected option values.'''
      def __init__(self, overrides, *options):
          self.overrides = overrides
          self.options = options
  
      def __getitem__(self, option_name):
          for opts in self.options:
              if option_name in opts:
                  return self._get_override(option_name, opts[option_name])
          raise KeyError('Option not found', option_name)
  
      def _get_override(self, option_name, base_opt):
          if option_name in self.overrides:
              return OptionProxy(base_opt.name, base_opt.validate_value(self.overrides[option_name]))
          return base_opt
  
  # This class contains the basic functionality that is needed by all backends.
  # Feel free to move stuff in and out of it as you see fit.
  class Backend:
      def __init__(self, build):
          self.build = build
          self.environment = build.environment
          self.processed_targets = {}
          self.build_to_src = os.path.relpath(self.environment.get_source_dir(),
                                              self.environment.get_build_dir())
  
      def get_target_filename(self, t):
          if isinstance(t, build.CustomTarget):
              if len(t.get_outputs()) != 1:
                  mlog.warning('custom_target {!r} has more than one output! '
                               'Using the first one.'.format(t.name))
              filename = t.get_outputs()[0]
          else:
              assert(isinstance(t, build.BuildTarget))
              filename = t.get_filename()
          return os.path.join(self.get_target_dir(t), filename)
  
      def get_target_filename_abs(self, target):
          return os.path.join(self.environment.get_build_dir(), self.get_target_filename(target))
  
      def get_builtin_options_for_target(self, target):
          return OptionOverrideProxy(target.option_overrides,
                                     self.environment.coredata.builtins)
  
      def get_base_options_for_target(self, target):
          return OptionOverrideProxy(target.option_overrides,
                                     self.environment.coredata.builtins,
                                     self.environment.coredata.base_options)
  
      def get_compiler_options_for_target(self, target):
          return OptionOverrideProxy(target.option_overrides,
                                     # no code depends on builtins for now
                                     self.environment.coredata.compiler_options)
  
      def get_option_for_target(self, option_name, target):
          if option_name in target.option_overrides:
              override = target.option_overrides[option_name]
              return self.environment.coredata.validate_option_value(option_name, override)
          return self.environment.coredata.get_builtin_option(option_name)
  
      def get_target_filename_for_linking(self, target):
          # On some platforms (msvc for instance), the file that is used for
          # dynamic linking is not the same as the dynamic library itself. This
          # file is called an import library, and we want to link against that.
          # On all other platforms, we link to the library directly.
          if isinstance(target, build.SharedLibrary):
              link_lib = target.get_import_filename() or target.get_filename()
              return os.path.join(self.get_target_dir(target), link_lib)
          elif isinstance(target, build.StaticLibrary):
              return os.path.join(self.get_target_dir(target), target.get_filename())
          elif isinstance(target, build.Executable):
              if target.import_filename:
                  return os.path.join(self.get_target_dir(target), target.get_import_filename())
              else:
                  return None
          raise AssertionError('BUG: Tried to link to {!r} which is not linkable'.format(target))
  
      def get_target_dir(self, target):
          if self.environment.coredata.get_builtin_option('layout') == 'mirror':
              dirname = target.get_subdir()
          else:
              dirname = 'meson-out'
          return dirname
  
      def get_target_dir_relative_to(self, t, o):
          '''Get a target dir relative to another target's directory'''
          target_dir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(t))
          othert_dir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(o))
          return os.path.relpath(target_dir, othert_dir)
  
      def get_target_source_dir(self, target):
          # if target dir is empty, avoid extraneous trailing / from os.path.join()
          target_dir = self.get_target_dir(target)
          if target_dir:
              return os.path.join(self.build_to_src, target_dir)
          return self.build_to_src
  
      def get_target_private_dir(self, target):
          return os.path.join(self.get_target_dir(target), target.get_id())
  
      def get_target_private_dir_abs(self, target):
          return os.path.join(self.environment.get_build_dir(), self.get_target_private_dir(target))
  
      def get_target_generated_dir(self, target, gensrc, src):
          """
          Takes a BuildTarget, a generator source (CustomTarget or GeneratedList),
          and a generated source filename.
          Returns the full path of the generated source relative to the build root
          """
          # CustomTarget generators output to the build dir of the CustomTarget
          if isinstance(gensrc, (build.CustomTarget, build.CustomTargetIndex)):
              return os.path.join(self.get_target_dir(gensrc), src)
          # GeneratedList generators output to the private build directory of the
          # target that the GeneratedList is used in
          return os.path.join(self.get_target_private_dir(target), src)
  
      def get_unity_source_file(self, target, suffix):
          # There is a potential conflict here, but it is unlikely that
          # anyone both enables unity builds and has a file called foo-unity.cpp.
          osrc = target.name + '-unity.' + suffix
          return mesonlib.File.from_built_file(self.get_target_private_dir(target), osrc)
  
      def generate_unity_files(self, target, unity_src):
          abs_files = []
          result = []
          compsrcs = classify_unity_sources(target.compilers.values(), unity_src)
  
          def init_language_file(suffix):
              unity_src = self.get_unity_source_file(target, suffix)
              outfileabs = unity_src.absolute_path(self.environment.get_source_dir(),
                                                   self.environment.get_build_dir())
              outfileabs_tmp = outfileabs + '.tmp'
              abs_files.append(outfileabs)
              outfileabs_tmp_dir = os.path.dirname(outfileabs_tmp)
              if not os.path.exists(outfileabs_tmp_dir):
                  os.makedirs(outfileabs_tmp_dir)
              result.append(unity_src)
              return open(outfileabs_tmp, 'w')
  
          # For each language, generate a unity source file and return the list
          for comp, srcs in compsrcs.items():
              with init_language_file(comp.get_default_suffix()) as ofile:
                  for src in srcs:
                      ofile.write('#include<%s>\n' % src)
          [mesonlib.replace_if_different(x, x + '.tmp') for x in abs_files]
          return result
  
      def relpath(self, todir, fromdir):
          return os.path.relpath(os.path.join('dummyprefixdir', todir),
                                 os.path.join('dummyprefixdir', fromdir))
  
      def flatten_object_list(self, target, proj_dir_to_build_root=''):
          return self._flatten_object_list(target, target.get_objects(), proj_dir_to_build_root)
  
      def _flatten_object_list(self, target, objects, proj_dir_to_build_root):
          obj_list = []
          for obj in objects:
              if isinstance(obj, str):
                  o = os.path.join(proj_dir_to_build_root,
                                   self.build_to_src, target.get_subdir(), obj)
                  obj_list.append(o)
              elif isinstance(obj, mesonlib.File):
                  obj_list.append(obj.rel_to_builddir(self.build_to_src))
              elif isinstance(obj, build.ExtractedObjects):
                  if obj.recursive:
                      obj_list += self._flatten_object_list(obj.target, obj.objlist, proj_dir_to_build_root)
                  obj_list += self.determine_ext_objs(obj, proj_dir_to_build_root)
              else:
                  raise MesonException('Unknown data type in object list.')
          return obj_list
  
      def serialize_executable(self, exe, cmd_args, workdir, env={},
                               extra_paths=None, capture=None):
          import hashlib
          if extra_paths is None:
              # The callee didn't check if we needed extra paths, so check it here
              if mesonlib.is_windows() or mesonlib.is_cygwin():
                  extra_paths = self.determine_windows_extra_paths(exe, [])
              else:
                  extra_paths = []
          # Can't just use exe.name here; it will likely be run more than once
          if isinstance(exe, (dependencies.ExternalProgram,
                              build.BuildTarget, build.CustomTarget)):
              basename = exe.name
          else:
              basename = os.path.basename(exe)
          # Take a digest of the cmd args, env, workdir, and capture. This avoids
          # collisions and also makes the name deterministic over regenerations
          # which avoids a rebuild by Ninja because the cmdline stays the same.
          data = bytes(str(sorted(env.items())) + str(cmd_args) + str(workdir) + str(capture),
                       encoding='utf-8')
          digest = hashlib.sha1(data).hexdigest()
          scratch_file = 'meson_exe_{0}_{1}.dat'.format(basename, digest)
          exe_data = os.path.join(self.environment.get_scratch_dir(), scratch_file)
          with open(exe_data, 'wb') as f:
              if isinstance(exe, dependencies.ExternalProgram):
                  exe_cmd = exe.get_command()
                  exe_needs_wrapper = False
              elif isinstance(exe, (build.BuildTarget, build.CustomTarget)):
                  exe_cmd = [self.get_target_filename_abs(exe)]
                  exe_needs_wrapper = exe.is_cross
              else:
                  exe_cmd = [exe]
                  exe_needs_wrapper = False
              is_cross_built = exe_needs_wrapper and \
                  self.environment.is_cross_build() and \
                  self.environment.cross_info.need_cross_compiler() and \
                  self.environment.cross_info.need_exe_wrapper()
              if is_cross_built:
                  exe_wrapper = self.environment.cross_info.config['binaries'].get('exe_wrapper', None)
              else:
                  exe_wrapper = None
              es = ExecutableSerialisation(basename, exe_cmd, cmd_args, env,
                                           is_cross_built, exe_wrapper, workdir,
                                           extra_paths, capture)
              pickle.dump(es, f)
          return exe_data
  
      def serialize_tests(self):
          test_data = os.path.join(self.environment.get_scratch_dir(), 'meson_test_setup.dat')
          with open(test_data, 'wb') as datafile:
              self.write_test_file(datafile)
          benchmark_data = os.path.join(self.environment.get_scratch_dir(), 'meson_benchmark_setup.dat')
          with open(benchmark_data, 'wb') as datafile:
              self.write_benchmark_file(datafile)
          return test_data, benchmark_data
  
      def determine_linker_and_stdlib_args(self, target):
          '''
          If we're building a static library, there is only one static linker.
          Otherwise, we query the target for the dynamic linker.
          '''
          if isinstance(target, build.StaticLibrary):
              if target.is_cross:
                  return self.build.static_cross_linker, []
              else:
                  return self.build.static_linker, []
          l, stdlib_args = target.get_clike_dynamic_linker_and_stdlibs()
          return l, stdlib_args
  
      @staticmethod
      def _libdir_is_system(libdir, compilers):
          for cc in compilers.values():
              if libdir in cc.get_library_dirs():
                  return True
          return False
  
      def rpaths_for_bundled_shared_libraries(self, target, exclude_system=True):
          paths = []
          for dep in target.external_deps:
              if not isinstance(dep, (dependencies.ExternalLibrary, dependencies.PkgConfigDependency)):
                  continue
              la = dep.link_args
              if len(la) != 1 or not os.path.isabs(la[0]):
                  continue
              # The only link argument is an absolute path to a library file.
              libpath = la[0]
              libdir = os.path.dirname(libpath)
              if exclude_system and self._libdir_is_system(libdir, target.compilers):
                  # No point in adding system paths.
                  continue
              # Windows doesn't support rpaths, but we use this function to
              # emulate rpaths by setting PATH, so also accept DLLs here
              if os.path.splitext(libpath)[1] not in ['.dll', '.lib', '.so', '.dylib']:
                  continue
              if libdir.startswith(self.environment.get_source_dir()):
                  rel_to_src = libdir[len(self.environment.get_source_dir()) + 1:]
                  assert not os.path.isabs(rel_to_src), 'rel_to_src: {} is absolute'.format(rel_to_src)
                  paths.append(os.path.join(self.build_to_src, rel_to_src))
              else:
                  paths.append(libdir)
          return paths
  
      def determine_rpath_dirs(self, target):
          link_deps = target.get_all_link_deps()
          result = set()
          for ld in link_deps:
              if ld is target:
                  continue
              result.add(self.get_target_dir(ld))
          result.update(self.rpaths_for_bundled_shared_libraries(target))
          return list(result)
  
      def object_filename_from_source(self, target, source):
          assert isinstance(source, mesonlib.File)
          build_dir = self.environment.get_build_dir()
          rel_src = source.rel_to_builddir(self.build_to_src)
  
          # foo.vala files compile down to foo.c and then foo.c.o, not foo.vala.o
          if rel_src.endswith(('.vala', '.gs')):
              # See description in generate_vala_compile for this logic.
              if source.is_built:
                  if os.path.isabs(rel_src):
                      rel_src = rel_src[len(build_dir) + 1:]
                  rel_src = os.path.relpath(rel_src, self.get_target_private_dir(target))
              else:
                  rel_src = os.path.basename(rel_src)
              # A meson- prefixed directory is reserved; hopefully no-one creates a file name with such a weird prefix.
              source = 'meson-generated_' + rel_src[:-5] + '.c'
          elif source.is_built:
              if os.path.isabs(rel_src):
                  rel_src = rel_src[len(build_dir) + 1:]
              targetdir = self.get_target_private_dir(target)
              # A meson- prefixed directory is reserved; hopefully no-one creates a file name with such a weird prefix.
              source = 'meson-generated_' + os.path.relpath(rel_src, targetdir)
          else:
              if os.path.isabs(rel_src):
                  # Not from the source directory; hopefully this doesn't conflict with user's source files.
                  source = os.path.basename(rel_src)
              else:
                  source = os.path.relpath(os.path.join(build_dir, rel_src),
                                           os.path.join(self.environment.get_source_dir(), target.get_subdir()))
          return source.replace('/', '_').replace('\\', '_') + '.' + self.environment.get_object_suffix()
  
      def determine_ext_objs(self, extobj, proj_dir_to_build_root):
          result = []
  
          # Merge sources and generated sources
          sources = list(extobj.srclist)
          for gensrc in extobj.genlist:
              for s in gensrc.get_outputs():
                  path = self.get_target_generated_dir(extobj.target, gensrc, s)
                  dirpart, fnamepart = os.path.split(path)
                  sources.append(File(True, dirpart, fnamepart))
  
          # Filter out headers and all non-source files
          sources = [s for s in sources if self.environment.is_source(s) and not self.environment.is_header(s)]
  
          # extobj could contain only objects and no sources
          if not sources:
              return result
  
          targetdir = self.get_target_private_dir(extobj.target)
  
          # With unity builds, there's just one object that contains all the
          # sources, and we only support extracting all the objects in this mode,
          # so just return that.
          if self.is_unity(extobj.target):
              compsrcs = classify_unity_sources(extobj.target.compilers.values(), sources)
              sources = []
              for comp in compsrcs.keys():
                  osrc = self.get_unity_source_file(extobj.target,
                                                    comp.get_default_suffix())
                  sources.append(osrc)
  
          for osrc in sources:
              objname = self.object_filename_from_source(extobj.target, osrc)
              objpath = os.path.join(proj_dir_to_build_root, targetdir, objname)
              result.append(objpath)
  
          return result
  
      def get_pch_include_args(self, compiler, target):
          args = []
          pchpath = self.get_target_private_dir(target)
          includeargs = compiler.get_include_args(pchpath, False)
          p = target.get_pch(compiler.get_language())
          if p:
              args += compiler.get_pch_use_args(pchpath, p[0])
          return includeargs + args
  
      @staticmethod
      def escape_extra_args(compiler, args):
          # No extra escaping/quoting needed when not running on Windows
          if not mesonlib.is_windows():
              return args
          extra_args = []
          # Compiler-specific escaping is needed for -D args but not for any others
          if compiler.get_id() == 'msvc':
              # MSVC needs escaping when a -D argument ends in \ or \"
              for arg in args:
                  if arg.startswith('-D') or arg.startswith('/D'):
                      # Without extra escaping for these two, the next character
                      # gets eaten
                      if arg.endswith('\\'):
                          arg += '\\'
                      elif arg.endswith('\\"'):
                          arg = arg[:-2] + '\\\\"'
                  extra_args.append(arg)
          else:
              # MinGW GCC needs all backslashes in defines to be doubly-escaped
              # FIXME: Not sure about Cygwin or Clang
              for arg in args:
                  if arg.startswith('-D') or arg.startswith('/D'):
                      arg = arg.replace('\\', '\\\\')
                  extra_args.append(arg)
          return extra_args
  
      def generate_basic_compiler_args(self, target, compiler, no_warn_args=False):
          # Create an empty commands list, and start adding arguments from
          # various sources in the order in which they must override each other
          # starting from hard-coded defaults followed by build options and so on.
          commands = CompilerArgs(compiler)
  
          copt_proxy = self.get_compiler_options_for_target(target)
          # First, the trivial ones that are impossible to override.
          #
          # Add -nostdinc/-nostdinc++ if needed; can't be overridden
          commands += self.get_cross_stdlib_args(target, compiler)
          # Add things like /NOLOGO or -pipe; usually can't be overridden
          commands += compiler.get_always_args()
          # Only add warning-flags by default if the buildtype enables it, and if
          # we weren't explicitly asked to not emit warnings (for Vala, f.ex)
          if no_warn_args:
              commands += compiler.get_no_warn_args()
          elif self.get_option_for_target('buildtype', target) != 'plain':
              commands += compiler.get_warn_args(self.get_option_for_target('warning_level', target))
          # Add -Werror if werror=true is set in the build options set on the
          # command-line or default_options inside project(). This only sets the
          # action to be done for warnings if/when they are emitted, so it's ok
          # to set it after get_no_warn_args() or get_warn_args().
          if self.get_option_for_target('werror', target):
              commands += compiler.get_werror_args()
          # Add compile args for c_* or cpp_* build options set on the
          # command-line or default_options inside project().
          commands += compiler.get_option_compile_args(copt_proxy)
          # Add buildtype args: optimization level, debugging, etc.
          commands += compiler.get_buildtype_args(self.get_option_for_target('buildtype', target))
          # Add compile args added using add_project_arguments()
          commands += self.build.get_project_args(compiler, target.subproject)
          # Add compile args added using add_global_arguments()
          # These override per-project arguments
          commands += self.build.get_global_args(compiler)
          if not target.is_cross:
              # Compile args added from the env: CFLAGS/CXXFLAGS, etc. We want these
              # to override all the defaults, but not the per-target compile args.
              commands += self.environment.coredata.get_external_args(compiler.get_language())
          # Always set -fPIC for shared libraries
          if isinstance(target, build.SharedLibrary):
              commands += compiler.get_pic_args()
          # Set -fPIC for static libraries by default unless explicitly disabled
          if isinstance(target, build.StaticLibrary) and target.pic:
              commands += compiler.get_pic_args()
          # Add compile args needed to find external dependencies. Link args are
          # added while generating the link command.
          # NOTE: We must preserve the order in which external deps are
          # specified, so we reverse the list before iterating over it.
          for dep in reversed(target.get_external_deps()):
              if not dep.found():
                  continue
  
              if compiler.language == 'vala':
                  if isinstance(dep, dependencies.PkgConfigDependency):
                      if dep.name == 'glib-2.0' and dep.version_reqs is not None:
                          for req in dep.version_reqs:
                              if req.startswith(('>=', '==')):
                                  commands += ['--target-glib', req[2:]]
                                  break
                      commands += ['--pkg', dep.name]
                  elif isinstance(dep, dependencies.ExternalLibrary):
                      commands += dep.get_link_args('vala')
              else:
                  commands += dep.get_compile_args()
              # Qt needs -fPIC for executables
              # XXX: We should move to -fPIC for all executables
              if isinstance(target, build.Executable):
                  commands += dep.get_exe_args(compiler)
              # For 'automagic' deps: Boost and GTest. Also dependency('threads').
              # pkg-config puts the thread flags itself via `Cflags:`
              if dep.need_threads():
                  commands += compiler.thread_flags(self.environment)
              elif dep.need_openmp():
                  commands += compiler.openmp_flags()
          # Fortran requires extra include directives.
          if compiler.language == 'fortran':
              for lt in target.link_targets:
                  priv_dir = self.get_target_private_dir(lt)
                  commands += compiler.get_include_args(priv_dir, False)
          return commands
  
      def build_target_link_arguments(self, compiler, deps):
          args = []
          for d in deps:
              if not (d.is_linkable_target()):
                  raise RuntimeError('Tried to link with a non-library target "%s".' % d.get_basename())
              d_arg = self.get_target_filename_for_linking(d)
              if not d_arg:
                  continue
              if isinstance(compiler, (compilers.LLVMDCompiler, compilers.DmdDCompiler)):
                  d_arg = '-L' + d_arg
              args.append(d_arg)
          return args
  
      def get_mingw_extra_paths(self, target):
          paths = OrderedSet()
          # The cross bindir
          root = self.environment.cross_info.get_root()
          if root:
              paths.add(os.path.join(root, 'bin'))
          # The toolchain bindir
          sys_root = self.environment.cross_info.get_sys_root()
          if sys_root:
              paths.add(os.path.join(sys_root, 'bin'))
          # Get program and library dirs from all target compilers
          if isinstance(target, build.BuildTarget):
              for cc in target.compilers.values():
                  paths.update(cc.get_program_dirs())
                  paths.update(cc.get_library_dirs())
          return list(paths)
  
      def determine_windows_extra_paths(self, target, extra_bdeps, is_cross=False):
          '''On Windows there is no such thing as an rpath.
          We must determine all locations of DLLs that this exe
          links to and return them so they can be used in unit
          tests.'''
          result = set()
          prospectives = set()
          if isinstance(target, build.BuildTarget):
              prospectives.update(target.get_transitive_link_deps())
              # External deps
              for deppath in self.rpaths_for_bundled_shared_libraries(target, exclude_system=False):
                  result.add(os.path.normpath(os.path.join(self.environment.get_build_dir(), deppath)))
          for bdep in extra_bdeps:
              prospectives.update(bdep.get_transitive_link_deps())
          # Internal deps
          for ld in prospectives:
              if ld == '' or ld == '.':
                  continue
              dirseg = os.path.join(self.environment.get_build_dir(), self.get_target_dir(ld))
              result.add(dirseg)
          if is_cross:
              result.update(self.get_mingw_extra_paths(target))
          return list(result)
  
      def write_benchmark_file(self, datafile):
          self.write_test_serialisation(self.build.get_benchmarks(), datafile)
  
      def write_test_file(self, datafile):
          self.write_test_serialisation(self.build.get_tests(), datafile)
  
      def write_test_serialisation(self, tests, datafile):
          arr = []
          for t in tests:
              exe = t.get_exe()
              if isinstance(exe, dependencies.ExternalProgram):
                  cmd = exe.get_command()
              else:
                  cmd = [os.path.join(self.environment.get_build_dir(), self.get_target_filename(t.get_exe()))]
              is_cross = self.environment.is_cross_build() and \
                  self.environment.cross_info.need_cross_compiler() and \
                  self.environment.cross_info.need_exe_wrapper()
              if isinstance(exe, build.BuildTarget):
                  is_cross = is_cross and exe.is_cross
              if isinstance(exe, dependencies.ExternalProgram):
                  # E.g. an external verifier or simulator program run on a generated executable.
                  # Can always be run.
                  is_cross = False
              if is_cross:
                  exe_wrapper = self.environment.cross_info.config['binaries'].get('exe_wrapper', None)
              else:
                  exe_wrapper = None
              if mesonlib.for_windows(is_cross, self.environment) or \
                 mesonlib.for_cygwin(is_cross, self.environment):
                  extra_bdeps = []
                  if isinstance(exe, build.CustomTarget):
                      extra_bdeps = exe.get_transitive_build_target_deps()
                  extra_paths = self.determine_windows_extra_paths(exe, extra_bdeps, is_cross)
              else:
                  extra_paths = []
              cmd_args = []
              for a in t.cmd_args:
                  if hasattr(a, 'held_object'):
                      a = a.held_object
                  if isinstance(a, build.BuildTarget):
                      extra_paths += self.determine_windows_extra_paths(a, [])
                  if isinstance(a, mesonlib.File):
                      a = os.path.join(self.environment.get_build_dir(), a.rel_to_builddir(self.build_to_src))
                      cmd_args.append(a)
                  elif isinstance(a, str):
                      cmd_args.append(a)
                  elif isinstance(a, build.Target):
                      cmd_args.append(self.get_target_filename(a))
                  else:
                      raise MesonException('Bad object in test command.')
              ts = TestSerialisation(t.get_name(), t.project_name, t.suite, cmd, is_cross,
                                     exe_wrapper, t.is_parallel, cmd_args, t.env,
                                     t.should_fail, t.timeout, t.workdir, extra_paths)
              arr.append(ts)
          pickle.dump(arr, datafile)
  
      def generate_depmf_install(self, d):
          if self.build.dep_manifest_name is None:
              return
          ifilename = os.path.join(self.environment.get_build_dir(), 'depmf.json')
          ofilename = os.path.join(self.environment.get_prefix(), self.build.dep_manifest_name)
          mfobj = {'type': 'dependency manifest', 'version': '1.0', 'projects': self.build.dep_manifest}
          with open(ifilename, 'w') as f:
              f.write(json.dumps(mfobj))
          # Copy file from, to, and with mode unchanged
          d.data.append([ifilename, ofilename, None])
  
      def get_regen_filelist(self):
          '''List of all files whose alteration means that the build
          definition needs to be regenerated.'''
          deps = [os.path.join(self.build_to_src, df)
                  for df in self.interpreter.get_build_def_files()]
          if self.environment.is_cross_build():
              deps.append(os.path.join(self.build_to_src,
                                       self.environment.coredata.cross_file))
          deps.append('meson-private/coredata.dat')
          if os.path.exists(os.path.join(self.environment.get_source_dir(), 'meson_options.txt')):
              deps.append(os.path.join(self.build_to_src, 'meson_options.txt'))
          for sp in self.build.subprojects.keys():
              fname = os.path.join(self.environment.get_source_dir(), sp, 'meson_options.txt')
              if os.path.isfile(fname):
                  deps.append(os.path.join(self.build_to_src, sp, 'meson_options.txt'))
          return deps
  
      def exe_object_to_cmd_array(self, exe):
          if self.environment.is_cross_build() and \
             self.environment.cross_info.need_exe_wrapper() and \
             isinstance(exe, build.BuildTarget) and exe.is_cross:
              if 'exe_wrapper' not in self.environment.cross_info.config['binaries']:
                  s = 'Can not use target %s as a generator because it is cross-built\n'
                  s += 'and no exe wrapper is defined. You might want to set it to native instead.'
                  s = s % exe.name
                  raise MesonException(s)
          if isinstance(exe, build.BuildTarget):
              exe_arr = [os.path.join(self.environment.get_build_dir(), self.get_target_filename(exe))]
          else:
              exe_arr = exe.get_command()
          return exe_arr
  
      def replace_extra_args(self, args, genlist):
          final_args = []
          for a in args:
              if a == '@EXTRA_ARGS@':
                  final_args += genlist.get_extra_args()
              else:
                  final_args.append(a)
          return final_args
  
      def replace_outputs(self, args, private_dir, output_list):
          newargs = []
          regex = re.compile('@OUTPUT(\d+)@')
          for arg in args:
              m = regex.search(arg)
              while m is not None:
                  index = int(m.group(1))
                  src = '@OUTPUT%d@' % index
                  arg = arg.replace(src, os.path.join(private_dir, output_list[index]))
                  m = regex.search(arg)
              newargs.append(arg)
          return newargs
  
      def get_build_by_default_targets(self):
          result = OrderedDict()
          # Get all build and custom targets that must be built by default
          for name, t in self.build.get_targets().items():
              if t.build_by_default or t.install:
                  result[name] = t
          # Get all targets used as test executables and arguments. These must
          # also be built by default. XXX: Sometime in the future these should be
          # built only before running tests.
          for t in self.build.get_tests():
              exe = t.exe
              if hasattr(exe, 'held_object'):
                  exe = exe.held_object
              if isinstance(exe, (build.CustomTarget, build.BuildTarget)):
                  result[exe.get_id()] = exe
              for arg in t.cmd_args:
                  if hasattr(arg, 'held_object'):
                      arg = arg.held_object
                  if not isinstance(arg, (build.CustomTarget, build.BuildTarget)):
                      continue
                  result[arg.get_id()] = arg
              for dep in t.depends:
                  assert isinstance(dep, (build.CustomTarget, build.BuildTarget))
                  result[dep.get_id()] = dep
          return result
  
      def get_custom_target_provided_libraries(self, target):
          libs = []
          for t in target.get_generated_sources():
              if not isinstance(t, build.CustomTarget):
                  continue
              for f in t.get_outputs():
                  if self.environment.is_library(f):
                      libs.append(os.path.join(self.get_target_dir(t), f))
          return libs
  
      def is_unity(self, target):
          optval = self.get_option_for_target('unity', target)
          if optval == 'on' or (optval == 'subprojects' and target.subproject != ''):
              return True
          return False
  
      def get_custom_target_sources(self, target):
          '''
          Custom target sources can be of various object types; strings, File,
          BuildTarget, even other CustomTargets.
          Returns the path to them relative to the build root directory.
          '''
          srcs = []
          for i in target.get_sources():
              if hasattr(i, 'held_object'):
                  i = i.held_object
              if isinstance(i, str):
                  fname = [os.path.join(self.build_to_src, target.subdir, i)]
              elif isinstance(i, build.BuildTarget):
                  fname = [self.get_target_filename(i)]
              elif isinstance(i, (build.CustomTarget, build.CustomTargetIndex)):
                  fname = [os.path.join(self.get_target_dir(i), p) for p in i.get_outputs()]
              elif isinstance(i, build.GeneratedList):
                  fname = [os.path.join(self.get_target_private_dir(target), p) for p in i.get_outputs()]
              else:
                  fname = [i.rel_to_builddir(self.build_to_src)]
              if target.absolute_paths:
                  fname = [os.path.join(self.environment.get_build_dir(), f) for f in fname]
              srcs += fname
          return srcs
  
      def get_custom_target_depend_files(self, target, absolute_paths=False):
          deps = []
          for i in target.depend_files:
              if isinstance(i, mesonlib.File):
                  if absolute_paths:
                      deps.append(i.absolute_path(self.environment.get_source_dir(),
                                                  self.environment.get_build_dir()))
                  else:
                      deps.append(i.rel_to_builddir(self.build_to_src))
              else:
                  if absolute_paths:
                      deps.append(os.path.join(self.environment.get_source_dir(), target.subdir, i))
                  else:
                      deps.append(os.path.join(self.build_to_src, target.subdir, i))
          return deps
  
      def eval_custom_target_command(self, target, absolute_outputs=False):
          # We want the outputs to be absolute only when using the VS backend
          # XXX: Maybe allow the vs backend to use relative paths too?
          source_root = self.build_to_src
          build_root = '.'
          outdir = self.get_target_dir(target)
          if absolute_outputs:
              source_root = self.environment.get_source_dir()
              build_root = self.environment.get_build_dir()
              outdir = os.path.join(self.environment.get_build_dir(), outdir)
          outputs = []
          for i in target.get_outputs():
              outputs.append(os.path.join(outdir, i))
          inputs = self.get_custom_target_sources(target)
          # Evaluate the command list
          cmd = []
          for i in target.command:
              if isinstance(i, build.Executable):
                  cmd += self.exe_object_to_cmd_array(i)
                  continue
              elif isinstance(i, build.CustomTarget):
                  # GIR scanner will attempt to execute this binary but
                  # it assumes that it is in path, so always give it a full path.
                  tmp = i.get_outputs()[0]
                  i = os.path.join(self.get_target_dir(i), tmp)
              elif isinstance(i, mesonlib.File):
                  i = i.rel_to_builddir(self.build_to_src)
                  if target.absolute_paths:
                      i = os.path.join(self.environment.get_build_dir(), i)
              # FIXME: str types are blindly added ignoring 'target.absolute_paths'
              # because we can't know if they refer to a file or just a string
              elif not isinstance(i, str):
                  err_msg = 'Argument {0} is of unknown type {1}'
                  raise RuntimeError(err_msg.format(str(i), str(type(i))))
              elif '@SOURCE_ROOT@' in i:
                  i = i.replace('@SOURCE_ROOT@', source_root)
              elif '@BUILD_ROOT@' in i:
                  i = i.replace('@BUILD_ROOT@', build_root)
              elif '@DEPFILE@' in i:
                  if target.depfile is None:
                      msg = 'Custom target {!r} has @DEPFILE@ but no depfile ' \
                            'keyword argument.'.format(target.name)
                      raise MesonException(msg)
                  dfilename = os.path.join(outdir, target.depfile)
                  i = i.replace('@DEPFILE@', dfilename)
              elif '@PRIVATE_OUTDIR_' in i:
                  match = re.search('@PRIVATE_OUTDIR_(ABS_)?([^/\s*]*)@', i)
                  if not match:
                      msg = 'Custom target {!r} has an invalid argument {!r}' \
                            ''.format(target.name, i)
                      raise MesonException(msg)
                  source = match.group(0)
                  if match.group(1) is None and not target.absolute_paths:
                      lead_dir = ''
                  else:
                      lead_dir = self.environment.get_build_dir()
                  i = i.replace(source, os.path.join(lead_dir, outdir))
              cmd.append(i)
          # Substitute the rest of the template strings
          values = mesonlib.get_filenames_templates_dict(inputs, outputs)
          cmd = mesonlib.substitute_values(cmd, values)
          # This should not be necessary but removing it breaks
          # building GStreamer on Windows. The underlying issue
          # is problems with quoting backslashes on Windows
          # which is the seventh circle of hell. The downside is
          # that this breaks custom targets whose command lines
          # have backslashes. If you try to fix this be sure to
          # check that it does not break GST.
          #
          # The bug causes file paths such as c:\foo to get escaped
          # into c:\\foo.
          #
          # Unfortunately we have not been able to come up with an
          # isolated test case for this so unless you manage to come up
          # with one, the only way is to test the building with Gst's
          # setup. Note this in your MR or ping us and we will get it
          # fixed.
          #
          # https://github.com/mesonbuild/meson/pull/737
          cmd = [i.replace('\\', '/') for i in cmd]
          return inputs, outputs, cmd
  
      def run_postconf_scripts(self):
          env = {'MESON_SOURCE_ROOT': self.environment.get_source_dir(),
                 'MESON_BUILD_ROOT': self.environment.get_build_dir(),
                 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in self.environment.get_build_command() + ['introspect']]),
                 }
          child_env = os.environ.copy()
          child_env.update(env)
  
          for s in self.build.postconf_scripts:
              cmd = s['exe'] + s['args']
              subprocess.check_call(cmd, env=child_env)
  
files: mesonbuild/backend/backends.py
files: # Copyright 2012-2017 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 copy, os, re
  from collections import OrderedDict
  import itertools, pathlib
  import pickle
  
  from . import environment
  from . import dependencies
  from . import mlog
  from .mesonlib import File, MesonException, listify, extract_as_list
  from .mesonlib import typeslistify, stringlistify, classify_unity_sources
  from .mesonlib import get_filenames_templates_dict, substitute_values
  from .mesonlib import for_windows, for_darwin, for_cygwin, for_android, has_path_sep
  from .compilers import is_object, clink_langs, sort_clink, lang_suffixes
  from .interpreterbase import FeatureNew, FeatureNewKwargs
  
  pch_kwargs = set(['c_pch', 'cpp_pch'])
  
  lang_arg_kwargs = set([
      'c_args',
      'cpp_args',
      'd_args',
      'd_import_dirs',
      'd_unittest',
      'd_module_versions',
      'fortran_args',
      'java_args',
      'objc_args',
      'objcpp_args',
      'rust_args',
      'vala_args',
      'cs_args',
  ])
  
  vala_kwargs = set(['vala_header', 'vala_gir', 'vala_vapi'])
  rust_kwargs = set(['rust_crate_type'])
  cs_kwargs = set(['resources', 'cs_args'])
  
  buildtarget_kwargs = set([
      'build_by_default',
      'build_rpath',
      'dependencies',
      'extra_files',
      'gui_app',
      'link_with',
      'link_whole',
      'link_args',
      'link_depends',
      'implicit_include_directories',
      'include_directories',
      'install',
      'install_rpath',
      'install_dir',
      'install_mode',
      'name_prefix',
      'name_suffix',
      'native',
      'objects',
      'override_options',
      'sources',
  ])
  
  known_build_target_kwargs = (
      buildtarget_kwargs |
      lang_arg_kwargs |
      pch_kwargs |
      vala_kwargs |
      rust_kwargs |
      cs_kwargs)
  
  known_exe_kwargs = known_build_target_kwargs | {'implib', 'export_dynamic'}
  known_shlib_kwargs = known_build_target_kwargs | {'version', 'soversion', 'vs_module_defs'}
  known_shmod_kwargs = known_build_target_kwargs
  known_stlib_kwargs = known_build_target_kwargs | {'pic'}
  known_jar_kwargs = known_exe_kwargs | {'main_class'}
  
  class InvalidArguments(MesonException):
      pass
  
  class Build:
      """A class that holds the status of one build including
      all dependencies and so on.
      """
  
      def __init__(self, environment):
          self.project_name = 'name of master project'
          self.project_version = None
          self.environment = environment
          self.projects = {}
          self.targets = OrderedDict()
          self.compilers = OrderedDict()
          self.cross_compilers = OrderedDict()
          self.global_args = {}
          self.projects_args = {}
          self.global_link_args = {}
          self.projects_link_args = {}
          self.tests = []
          self.benchmarks = []
          self.headers = []
          self.man = []
          self.data = []
          self.static_linker = None
          self.static_cross_linker = None
          self.subprojects = {}
          self.subproject_dir = ''
          self.install_scripts = []
          self.postconf_scripts = []
          self.install_dirs = []
          self.dep_manifest_name = None
          self.dep_manifest = {}
          self.cross_stdlibs = {}
          self.test_setups = {}
          self.find_overrides = {}
          self.searched_programs = set() # The list of all programs that have been searched for.
  
      def add_compiler(self, compiler):
          if self.static_linker is None and compiler.needs_static_linker():
              self.static_linker = self.environment.detect_static_linker(compiler)
          lang = compiler.get_language()
          if lang not in self.compilers:
              self.compilers[lang] = compiler
  
      def add_cross_compiler(self, compiler):
          if not self.cross_compilers:
              self.static_cross_linker = self.environment.detect_static_linker(compiler)
          lang = compiler.get_language()
          if lang not in self.cross_compilers:
              self.cross_compilers[lang] = compiler
  
      def get_project(self):
          return self.projects['']
  
      def get_subproject_dir(self):
          return self.subproject_dir
  
      def get_targets(self):
          return self.targets
  
      def get_tests(self):
          return self.tests
  
      def get_benchmarks(self):
          return self.benchmarks
  
      def get_headers(self):
          return self.headers
  
      def get_man(self):
          return self.man
  
      def get_data(self):
          return self.data
  
      def get_install_subdirs(self):
          return self.install_dirs
  
      def get_global_args(self, compiler):
          return self.global_args.get(compiler.get_language(), [])
  
      def get_project_args(self, compiler, project):
          args = self.projects_args.get(project)
          if not args:
              return []
          return args.get(compiler.get_language(), [])
  
      def get_global_link_args(self, compiler):
          return self.global_link_args.get(compiler.get_language(), [])
  
      def get_project_link_args(self, compiler, project):
          link_args = self.projects_link_args.get(project)
          if not link_args:
              return []
  
          return link_args.get(compiler.get_language(), [])
  
  class IncludeDirs:
      def __init__(self, curdir, dirs, is_system, extra_build_dirs=None):
          self.curdir = curdir
          self.incdirs = dirs
          self.is_system = is_system
          # Interpreter has validated that all given directories
          # actually exist.
          if extra_build_dirs is None:
              self.extra_build_dirs = []
          else:
              self.extra_build_dirs = extra_build_dirs
  
      def __repr__(self):
          r = '<{} {}/{}>'
          return r.format(self.__class__.__name__, self.curdir, self.incdirs)
  
      def get_curdir(self):
          return self.curdir
  
      def get_incdirs(self):
          return self.incdirs
  
      def get_extra_build_dirs(self):
          return self.extra_build_dirs
  
  class ExtractedObjects:
      '''
      Holds a list of sources for which the objects must be extracted
      '''
      def __init__(self, target, srclist=[], genlist=[], objlist=[], recursive=True):
          self.target = target
          self.recursive = recursive
          self.srclist = srclist
          self.genlist = genlist
          self.objlist = objlist
          if self.target.is_unity:
              self.check_unity_compatible()
  
      def __repr__(self):
          r = '<{0} {1!r}: {2}>'
          return r.format(self.__class__.__name__, self.target.name, self.srclist)
  
      def classify_all_sources(self, sources, generated_sources):
          # Merge sources and generated sources
          sources = list(sources)
          for gensrc in generated_sources:
              for s in gensrc.get_outputs():
                  # We cannot know the path where this source will be generated,
                  # but all we need here is the file extension to determine the
                  # compiler.
                  sources.append(s)
  
          # Filter out headers and all non-source files
          sources = [s for s in sources if environment.is_source(s) and not environment.is_header(s)]
  
          return classify_unity_sources(self.target.compilers.values(), sources)
  
      def check_unity_compatible(self):
          # Figure out if the extracted object list is compatible with a Unity
          # build. When we're doing a Unified build, we go through the sources,
          # and create a single source file from each subset of the sources that
          # can be compiled with a specific compiler. Then we create one object
          # from each unified source file. So for each compiler we can either
          # extra all its sources or none.
          cmpsrcs = self.classify_all_sources(self.target.sources, self.target.generated)
          extracted_cmpsrcs = self.classify_all_sources(self.srclist, self.genlist)
  
          for comp, srcs in extracted_cmpsrcs.items():
              if set(srcs) != set(cmpsrcs[comp]):
                  raise MesonException('Single object files can not be extracted '
                                       'in Unity builds. You can only extract all '
                                       'the object files for each compiler at once.')
  
  class EnvironmentVariables:
      def __init__(self):
          self.envvars = []
  
      def __repr__(self):
          repr_str = "<{0}: {1}>"
          return repr_str.format(self.__class__.__name__, self.envvars)
  
      def get_value(self, values, kwargs):
          separator = kwargs.get('separator', os.pathsep)
  
          value = ''
          for var in values:
              value += separator + var
          return separator, value.strip(separator)
  
      def set(self, env, name, values, kwargs):
          return self.get_value(values, kwargs)[1]
  
      def append(self, env, name, values, kwargs):
          sep, value = self.get_value(values, kwargs)
          if name in env:
              return env[name] + sep + value
          return value
  
      def prepend(self, env, name, values, kwargs):
          sep, value = self.get_value(values, kwargs)
          if name in env:
              return value + sep + env[name]
  
          return value
  
      def get_env(self, full_env):
          env = full_env.copy()
          for method, name, values, kwargs in self.envvars:
              env[name] = method(full_env, name, values, kwargs)
          return env
  
  class Target:
      def __init__(self, name, subdir, subproject, build_by_default):
          if has_path_sep(name):
              # Fix failing test 53 when this becomes an error.
              mlog.warning('''Target "%s" has a path separator in its name.
  This is not supported, it can cause unexpected failures and will become
  a hard error in the future.''' % name)
          self.name = name
          self.subdir = subdir
          self.subproject = subproject
          self.build_by_default = build_by_default
          self.install = False
          self.build_always_stale = False
          self.option_overrides = {}
  
      def get_basename(self):
          return self.name
  
      def get_subdir(self):
          return self.subdir
  
      def get_id(self):
          # This ID must also be a valid file name on all OSs.
          # It should also avoid shell metacharacters for obvious
          # reasons. '@' is not used as often as '_' in source code names.
          # In case of collisions consider using checksums.
          # FIXME replace with assert when slash in names is prohibited
          name_part = self.name.replace('/', '@').replace('\\', '@')
          assert not has_path_sep(self.type_suffix())
          myid = name_part + self.type_suffix()
          if self.subdir:
              subdir_part = self.subdir.replace('/', '@').replace('\\', '@')
              myid = subdir_part + '@@' + myid
          return myid
  
      @FeatureNewKwargs('build target', '0.42.0', ['rust_crate_type', 'build_rpath', 'implicit_include_directories'])
      @FeatureNewKwargs('build target', '0.41.0', ['rust_args'])
      @FeatureNewKwargs('build target', '0.40.0', ['build_by_default'])
      def process_kwargs(self, kwargs):
          if 'build_by_default' in kwargs:
              self.build_by_default = kwargs['build_by_default']
              if not isinstance(self.build_by_default, bool):
                  raise InvalidArguments('build_by_default must be a boolean value.')
          self.option_overrides = self.parse_overrides(kwargs)
  
      def parse_overrides(self, kwargs):
          result = {}
          overrides = stringlistify(kwargs.get('override_options', []))
          for o in overrides:
              if '=' not in o:
                  raise InvalidArguments('Overrides must be of form "key=value"')
              k, v = o.split('=', 1)
              k = k.strip()
              v = v.strip()
              result[k] = v
          return result
  
  
  class BuildTarget(Target):
      known_kwargs = known_build_target_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          super().__init__(name, subdir, subproject, True)
          self.is_cross = is_cross
          unity_opt = environment.coredata.get_builtin_option('unity')
          self.is_unity = unity_opt == 'on' or (unity_opt == 'subprojects' and subproject != '')
          self.environment = environment
          self.sources = []
          self.compilers = OrderedDict()
          self.objects = []
          self.external_deps = []
          self.include_dirs = []
          self.link_targets = []
          self.link_whole_targets = []
          self.link_depends = []
          self.name_prefix_set = False
          self.name_suffix_set = False
          self.filename = 'no_name'
          # The list of all files outputted by this target. Useful in cases such
          # as Vala which generates .vapi and .h besides the compiled output.
          self.outputs = [self.filename]
          self.need_install = False
          self.pch = {}
          self.extra_args = {}
          self.generated = []
          self.extra_files = []
          self.d_features = {}
          # Sources can be:
          # 1. Pre-existing source files in the source tree
          # 2. Pre-existing sources generated by configure_file in the build tree
          # 3. Sources files generated by another target or a Generator
          self.process_sourcelist(sources)
          # Objects can be:
          # 1. Pre-existing objects provided by the user with the `objects:` kwarg
          # 2. Compiled objects created by and extracted from another target
          self.process_objectlist(objects)
          self.process_kwargs(kwargs, environment)
          self.check_unknown_kwargs(kwargs)
          self.process_compilers()
          if not any([self.sources, self.generated, self.objects, self.link_whole]):
              raise InvalidArguments('Build target %s has no sources.' % name)
          self.process_compilers_late()
          self.validate_sources()
          self.validate_cross_install(environment)
          self.check_module_linking()
  
      def __lt__(self, other):
          return self.get_id() < other.get_id()
  
      def __repr__(self):
          repr_str = "<{0} {1}: {2}>"
          return repr_str.format(self.__class__.__name__, self.get_id(), self.filename)
  
      def validate_cross_install(self, environment):
          if environment.is_cross_build() and not self.is_cross and self.install:
              raise InvalidArguments('Tried to install a natively built target in a cross build.')
  
      def check_unknown_kwargs(self, kwargs):
          # Override this method in derived classes that have more
          # keywords.
          self.check_unknown_kwargs_int(kwargs, self.known_kwargs)
  
      def check_unknown_kwargs_int(self, kwargs, known_kwargs):
          unknowns = []
          for k in kwargs:
              if k not in known_kwargs:
                  unknowns.append(k)
          if len(unknowns) > 0:
              mlog.warning('Unknown keyword argument(s) in target %s: %s.' %
                           (self.name, ', '.join(unknowns)))
  
      def process_objectlist(self, objects):
          assert(isinstance(objects, list))
          for s in objects:
              if hasattr(s, 'held_object'):
                  s = s.held_object
              if isinstance(s, (str, File, ExtractedObjects)):
                  self.objects.append(s)
              elif isinstance(s, (GeneratedList, CustomTarget)):
                  msg = 'Generated files are not allowed in the \'objects\' kwarg ' + \
                      'for target {!r}.\nIt is meant only for '.format(self.name) + \
                      'pre-built object files that are shipped with the\nsource ' + \
                      'tree. Try adding it in the list of sources.'
                  raise InvalidArguments(msg)
              else:
                  msg = 'Bad object of type {!r} in target {!r}.'.format(type(s).__name__, self.name)
                  raise InvalidArguments(msg)
  
      def process_sourcelist(self, sources):
          sources = listify(sources)
          added_sources = {} # If the same source is defined multiple times, use it only once.
          for s in sources:
              # Holder unpacking. Ugly.
              if hasattr(s, 'held_object'):
                  s = s.held_object
              if isinstance(s, File):
                  if s not in added_sources:
                      self.sources.append(s)
                      added_sources[s] = True
              elif isinstance(s, (GeneratedList, CustomTarget, CustomTargetIndex)):
                  self.generated.append(s)
              else:
                  msg = 'Bad source of type {!r} in target {!r}.'.format(type(s).__name__, self.name)
                  raise InvalidArguments(msg)
  
      @staticmethod
      def can_compile_remove_sources(compiler, sources):
          removed = False
          for s in sources[:]:
              if compiler.can_compile(s):
                  sources.remove(s)
                  removed = True
          return removed
  
      def process_compilers_late(self):
          """Processes additional compilers after kwargs have been evaluated.
  
          This can add extra compilers that might be required by keyword
          arguments, such as link_with or dependencies. It will also try to guess
          which compiler to use if one hasn't been selected already.
          """
          # Populate list of compilers
          if self.is_cross:
              compilers = self.environment.coredata.cross_compilers
          else:
              compilers = self.environment.coredata.compilers
  
          # If this library is linked against another library we need to consider
          # the languages of those libraries as well.
          if self.link_targets or self.link_whole_targets:
              extra = set()
              for t in itertools.chain(self.link_targets, self.link_whole_targets):
                  for name, compiler in t.compilers.items():
                      if name in clink_langs:
                          extra.add((name, compiler))
              for name, compiler in sorted(extra, key=lambda p: sort_clink(p[0])):
                  self.compilers[name] = compiler
  
          if not self.compilers:
              # No source files or parent targets, target consists of only object
              # files of unknown origin. Just add the first clink compiler
              # that we have and hope that it can link these objects
              for lang in clink_langs:
                  if lang in compilers:
                      self.compilers[lang] = compilers[lang]
                      break
  
      def process_compilers(self):
          '''
          Populate self.compilers, which is the list of compilers that this
          target will use for compiling all its sources.
          We also add compilers that were used by extracted objects to simplify
          dynamic linker determination.
          '''
          if not self.sources and not self.generated and not self.objects:
              return
          # Populate list of compilers
          if self.is_cross:
              compilers = self.environment.coredata.cross_compilers
          else:
              compilers = self.environment.coredata.compilers
          # Pre-existing sources
          sources = list(self.sources)
          # All generated sources
          for gensrc in self.generated:
              for s in gensrc.get_outputs():
                  # Generated objects can't be compiled, so don't use them for
                  # compiler detection. If our target only has generated objects,
                  # we will fall back to using the first c-like compiler we find,
                  # which is what we need.
                  if not is_object(s):
                      sources.append(s)
          for d in self.external_deps:
              if hasattr(d, 'held_object'):
                  d = d.held_object
              for s in d.sources:
                  if isinstance(s, (str, File)):
                      sources.append(s)
  
          # Sources that were used to create our extracted objects
          for o in self.objects:
              if not isinstance(o, ExtractedObjects):
                  continue
              for s in o.srclist:
                  # Don't add Vala sources since that will pull in the Vala
                  # compiler even though we will never use it since we are
                  # dealing with compiled C code.
                  if not s.endswith(lang_suffixes['vala']):
                      sources.append(s)
          if sources:
              # For each source, try to add one compiler that can compile it.
              # It's ok if no compilers can do so, because users are expected to
              # be able to add arbitrary non-source files to the sources list.
              for s in sources:
                  for lang, compiler in compilers.items():
                      if compiler.can_compile(s):
                          if lang not in self.compilers:
                              self.compilers[lang] = compiler
                          break
              # Re-sort according to clink_langs
              self.compilers = OrderedDict(sorted(self.compilers.items(),
                                                  key=lambda t: sort_clink(t[0])))
  
          # If all our sources are Vala, our target also needs the C compiler but
          # it won't get added above.
          if 'vala' in self.compilers and 'c' not in self.compilers:
              self.compilers['c'] = compilers['c']
  
      def validate_sources(self):
          if not self.sources:
              return
          for lang in ('cs', 'java'):
              if lang in self.compilers:
                  check_sources = list(self.sources)
                  compiler = self.compilers[lang]
                  if not self.can_compile_remove_sources(compiler, check_sources):
                      m = 'No {} sources found in target {!r}'.format(lang, self.name)
                      raise InvalidArguments(m)
                  if check_sources:
                      m = '{0} targets can only contain {0} files:\n'.format(lang.capitalize())
                      m += '\n'.join([repr(c) for c in check_sources])
                      raise InvalidArguments(m)
                  # CSharp and Java targets can't contain any other file types
                  assert(len(self.compilers) == 1)
                  return
  
      def process_link_depends(self, sources, environment):
          """Process the link_depends keyword argument.
  
          This is designed to handle strings, Files, and the output of Custom
          Targets. Notably it doesn't handle generator() returned objects, since
          adding them as a link depends would inherently cause them to be
          generated twice, since the output needs to be passed to the ld_args and
          link_depends.
          """
          sources = listify(sources)
          for s in sources:
              if hasattr(s, 'held_object'):
                  s = s.held_object
  
              if isinstance(s, File):
                  self.link_depends.append(s)
              elif isinstance(s, str):
                  self.link_depends.append(
                      File.from_source_file(environment.source_dir, self.subdir, s))
              elif hasattr(s, 'get_outputs'):
                  self.link_depends.extend(
                      [File.from_built_file(s.subdir, p) for p in s.get_outputs()])
              else:
                  raise InvalidArguments(
                      'Link_depends arguments must be strings, Files, '
                      'or a Custom Target, or lists thereof.')
  
      def get_original_kwargs(self):
          return self.kwargs
  
      def unpack_holder(self, d):
          d = listify(d)
          newd = []
          for i in d:
              if isinstance(i, list):
                  i = self.unpack_holder(i)
              elif hasattr(i, 'held_object'):
                  i = i.held_object
              for t in ['dependencies', 'link_with', 'include_directories', 'sources']:
                  if hasattr(i, t):
                      setattr(i, t, self.unpack_holder(getattr(i, t)))
              newd.append(i)
          return newd
  
      def copy_kwargs(self, kwargs):
          self.kwargs = copy.copy(kwargs)
          # This sucks quite badly. Arguments
          # are holders but they can't be pickled
          # so unpack those known.
          for k, v in self.kwargs.items():
              if isinstance(v, list):
                  self.kwargs[k] = self.unpack_holder(v)
              if hasattr(v, 'held_object'):
                  self.kwargs[k] = v.held_object
          for t in ['dependencies', 'link_with', 'include_directories', 'sources']:
              if t in self.kwargs:
                  self.kwargs[t] = self.unpack_holder(self.kwargs[t])
  
      def extract_objects(self, srclist):
          obj_src = []
          for src in srclist:
              if not isinstance(src, str):
                  raise MesonException('Object extraction arguments must be strings.')
              src = File(False, self.subdir, src)
              # FIXME: It could be a generated source
              if src not in self.sources:
                  raise MesonException('Tried to extract unknown source %s.' % src)
              obj_src.append(src)
          return ExtractedObjects(self, obj_src)
  
      def extract_all_objects(self, recursive=True):
          return ExtractedObjects(self, self.sources, self.generated, self.objects,
                                  recursive)
  
      def get_all_link_deps(self):
          return self.get_transitive_link_deps()
  
      def get_transitive_link_deps(self):
          result = []
          for i in self.link_targets:
              result += i.get_all_link_deps()
          return result
  
      def get_custom_install_dir(self):
          return self.install_dir
  
      def get_custom_install_mode(self):
          return self.install_mode
  
      def process_kwargs(self, kwargs, environment):
          super().process_kwargs(kwargs)
          self.copy_kwargs(kwargs)
          kwargs.get('modules', [])
          self.need_install = kwargs.get('install', self.need_install)
          llist = extract_as_list(kwargs, 'link_with')
          for linktarget in llist:
              # Sorry for this hack. Keyword targets are kept in holders
              # in kwargs. Unpack here without looking at the exact type.
              if hasattr(linktarget, "held_object"):
                  linktarget = linktarget.held_object
              if isinstance(linktarget, dependencies.ExternalLibrary):
                  raise MesonException('''An external library was used in link_with keyword argument, which
  is reserved for libraries built as part of this project. External
  libraries must be passed using the dependencies keyword argument
  instead, because they are conceptually "external dependencies",
  just like those detected with the dependency() function.''')
              self.link(linktarget)
          lwhole = extract_as_list(kwargs, 'link_whole')
          for linktarget in lwhole:
              self.link_whole(linktarget)
  
          c_pchlist, cpp_pchlist, clist, cpplist, cslist, valalist,  objclist, objcpplist, fortranlist, rustlist \
              = extract_as_list(kwargs, 'c_pch', 'cpp_pch', 'c_args', 'cpp_args', 'cs_args', 'vala_args', 'objc_args',
                                'objcpp_args', 'fortran_args', 'rust_args')
  
          self.add_pch('c', c_pchlist)
          self.add_pch('cpp', cpp_pchlist)
          compiler_args = {'c': clist, 'cpp': cpplist, 'cs': cslist, 'vala': valalist, 'objc': objclist, 'objcpp': objcpplist,
                           'fortran': fortranlist, 'rust': rustlist
                           }
          for key, value in compiler_args.items():
              self.add_compiler_args(key, value)
  
          if not isinstance(self, Executable) or 'export_dynamic' in kwargs:
              self.vala_header = kwargs.get('vala_header', self.name + '.h')
              self.vala_vapi = kwargs.get('vala_vapi', self.name + '.vapi')
              self.vala_gir = kwargs.get('vala_gir', None)
  
          dlist = stringlistify(kwargs.get('d_args', []))
          self.add_compiler_args('d', dlist)
          dfeatures = dict()
          dfeature_unittest = kwargs.get('d_unittest', False)
          if dfeature_unittest:
              dfeatures['unittest'] = dfeature_unittest
          dfeature_versions = kwargs.get('d_module_versions', None)
          if dfeature_versions:
              dfeatures['versions'] = dfeature_versions
          if 'd_import_dirs' in kwargs:
              dfeature_import_dirs = extract_as_list(kwargs, 'd_import_dirs', unholder=True)
              for d in dfeature_import_dirs:
                  if not isinstance(d, IncludeDirs):
                      raise InvalidArguments('Arguments to d_import_dirs must be include_directories.')
              dfeatures['import_dirs'] = dfeature_import_dirs
          if dfeatures:
              self.d_features = dfeatures
  
          self.link_args = extract_as_list(kwargs, 'link_args')
          for i in self.link_args:
              if not isinstance(i, str):
                  raise InvalidArguments('Link_args arguments must be strings.')
          for l in self.link_args:
              if '-Wl,-rpath' in l or l.startswith('-rpath'):
                  mlog.warning('''Please do not define rpath with a linker argument, use install_rpath or build_rpath properties instead.
  This will become a hard error in a future Meson release.''')
          self.process_link_depends(kwargs.get('link_depends', []), environment)
          # Target-specific include dirs must be added BEFORE include dirs from
          # internal deps (added inside self.add_deps()) to override them.
          inclist = extract_as_list(kwargs, 'include_directories')
          self.add_include_dirs(inclist)
          # Add dependencies (which also have include_directories)
          deplist = extract_as_list(kwargs, 'dependencies')
          self.add_deps(deplist)
          # If an item in this list is False, the output corresponding to
          # the list index of that item will not be installed
          self.install_dir = typeslistify(kwargs.get('install_dir', [None]),
                                          (str, bool))
          self.install_mode = kwargs.get('install_mode', None)
          main_class = kwargs.get('main_class', '')
          if not isinstance(main_class, str):
              raise InvalidArguments('Main class must be a string')
          self.main_class = main_class
          if isinstance(self, Executable):
              self.gui_app = kwargs.get('gui_app', False)
              if not isinstance(self.gui_app, bool):
                  raise InvalidArguments('Argument gui_app must be boolean.')
          elif 'gui_app' in kwargs:
              raise InvalidArguments('Argument gui_app can only be used on executables.')
          extra_files = extract_as_list(kwargs, 'extra_files')
          for i in extra_files:
              assert(isinstance(i, File))
              trial = os.path.join(environment.get_source_dir(), i.subdir, i.fname)
              if not(os.path.isfile(trial)):
                  raise InvalidArguments('Tried to add non-existing extra file %s.' % i)
          self.extra_files = extra_files
          self.install_rpath = kwargs.get('install_rpath', '')
          if not isinstance(self.install_rpath, str):
              raise InvalidArguments('Install_rpath is not a string.')
          self.build_rpath = kwargs.get('build_rpath', '')
          if not isinstance(self.build_rpath, str):
              raise InvalidArguments('Build_rpath is not a string.')
          resources = extract_as_list(kwargs, 'resources')
          for r in resources:
              if not isinstance(r, str):
                  raise InvalidArguments('Resource argument is not a string.')
              trial = os.path.join(environment.get_source_dir(), self.subdir, r)
              if not os.path.isfile(trial):
                  raise InvalidArguments('Tried to add non-existing resource %s.' % r)
          self.resources = resources
          if 'name_prefix' in kwargs:
              name_prefix = kwargs['name_prefix']
              if isinstance(name_prefix, list):
                  if name_prefix:
                      raise InvalidArguments('name_prefix array must be empty to signify null.')
              elif not isinstance(name_prefix, str):
                  raise InvalidArguments('name_prefix must be a string.')
              self.prefix = name_prefix
              self.name_prefix_set = True
          if 'name_suffix' in kwargs:
              name_suffix = kwargs['name_suffix']
              if isinstance(name_suffix, list):
                  if name_suffix:
                      raise InvalidArguments('name_suffix array must be empty to signify null.')
              else:
                  if not isinstance(name_suffix, str):
                      raise InvalidArguments('name_suffix must be a string.')
                  if name_suffix == '':
                      raise InvalidArguments('name_suffix should not be an empty string. '
                                             'If you want meson to use the default behaviour '
                                             'for each platform pass `[]` (empty array)')
                  self.suffix = name_suffix
                  self.name_suffix_set = True
          if isinstance(self, StaticLibrary):
              # You can't disable PIC on OS X. The compiler ignores -fno-PIC.
              # PIC is always on for Windows (all code is position-independent
              # since library loading is done differently)
              if for_darwin(self.is_cross, self.environment) or for_windows(self.is_cross, self.environment):
                  self.pic = True
              elif '-fPIC' in clist + cpplist:
                  mlog.warning("Use the 'pic' kwarg instead of passing -fPIC manually to static library {!r}".format(self.name))
                  self.pic = True
              else:
                  self.pic = kwargs.get('pic', False)
                  if not isinstance(self.pic, bool):
                      raise InvalidArguments('Argument pic to static library {!r} must be boolean'.format(self.name))
          self.implicit_include_directories = kwargs.get('implicit_include_directories', True)
          if not isinstance(self.implicit_include_directories, bool):
              raise InvalidArguments('Implicit_include_directories must be a boolean.')
  
      def get_filename(self):
          return self.filename
  
      def get_outputs(self):
          return self.outputs
  
      def get_extra_args(self, language):
          return self.extra_args.get(language, [])
  
      def get_dependencies(self, exclude=None, internal=True):
          transitive_deps = []
          if exclude is None:
              exclude = []
          if internal:
              link_targets = itertools.chain(self.link_targets, self.link_whole_targets)
          else:
              # We don't want the 'internal' libraries when generating the
              # `Libs:` and `Libs.private:` lists in pkg-config files.
              link_targets = self.link_targets
          for t in link_targets:
              if t in transitive_deps or t in exclude:
                  continue
              transitive_deps.append(t)
              if isinstance(t, StaticLibrary):
                  transitive_deps += t.get_dependencies(transitive_deps + exclude, internal)
          return transitive_deps
  
      def get_source_subdir(self):
          return self.subdir
  
      def get_sources(self):
          return self.sources
  
      def get_objects(self):
          return self.objects
  
      def get_generated_sources(self):
          return self.generated
  
      def should_install(self):
          return self.need_install
  
      def has_pch(self):
          return len(self.pch) > 0
  
      def get_pch(self, language):
          try:
              return self.pch[language]
          except KeyError:
              return[]
  
      def get_include_dirs(self):
          return self.include_dirs
  
      def add_deps(self, deps):
          deps = listify(deps)
          for dep in deps:
              if hasattr(dep, 'held_object'):
                  dep = dep.held_object
              if isinstance(dep, dependencies.InternalDependency):
                  # Those parts that are internal.
                  self.process_sourcelist(dep.sources)
                  self.add_include_dirs(dep.include_directories)
                  for l in dep.libraries:
                      self.link(l)
                  for l in dep.whole_libraries:
                      self.link_whole(l)
                  if dep.compile_args or dep.link_args:
                      # Those parts that are external.
                      extpart = dependencies.InternalDependency('undefined',
                                                                [],
                                                                dep.compile_args,
                                                                dep.link_args,
                                                                [], [], [], [])
                      self.external_deps.append(extpart)
                  # Deps of deps.
                  self.add_deps(dep.ext_deps)
              elif isinstance(dep, dependencies.Dependency):
                  self.external_deps.append(dep)
                  self.process_sourcelist(dep.get_sources())
              elif isinstance(dep, BuildTarget):
                  raise InvalidArguments('''Tried to use a build target as a dependency.
  You probably should put it in link_with instead.''')
              else:
                  # This is a bit of a hack. We do not want Build to know anything
                  # about the interpreter so we can't import it and use isinstance.
                  # This should be reliable enough.
                  if hasattr(dep, 'project_args_frozen') or hasattr(dep, 'global_args_frozen'):
                      raise InvalidArguments('Tried to use subproject object as a dependency.\n'
                                             'You probably wanted to use a dependency declared in it instead.\n'
                                             'Access it by calling get_variable() on the subproject object.')
                  raise InvalidArguments('Argument is of an unacceptable type {!r}.\nMust be '
                                         'either an external dependency (returned by find_library() or '
                                         'dependency()) or an internal dependency (returned by '
                                         'declare_dependency()).'.format(type(dep).__name__))
  
      def get_external_deps(self):
          return self.external_deps
  
      def link(self, target):
          for t in listify(target, unholder=True):
              if not isinstance(t, Target):
                  raise InvalidArguments('{!r} is not a target.'.format(t))
              if not t.is_linkable_target():
                  raise InvalidArguments('Link target {!r} is not linkable.'.format(t))
              if isinstance(self, SharedLibrary) and isinstance(t, StaticLibrary) and not t.pic:
                  msg = "Can't link non-PIC static library {!r} into shared library {!r}. ".format(t.name, self.name)
                  msg += "Use the 'pic' option to static_library to build with PIC."
                  raise InvalidArguments(msg)
              if self.is_cross != t.is_cross:
                  raise InvalidArguments('Tried to mix cross built and native libraries in target {!r}'.format(self.name))
              self.link_targets.append(t)
  
      def link_whole(self, target):
          for t in listify(target, unholder=True):
              if not isinstance(t, StaticLibrary):
                  raise InvalidArguments('{!r} is not a static library.'.format(t))
              if isinstance(self, SharedLibrary) and not t.pic:
                  msg = "Can't link non-PIC static library {!r} into shared library {!r}. ".format(t.name, self.name)
                  msg += "Use the 'pic' option to static_library to build with PIC."
                  raise InvalidArguments(msg)
              if self.is_cross != t.is_cross:
                  raise InvalidArguments('Tried to mix cross built and native libraries in target {!r}'.format(self.name))
              self.link_whole_targets.append(t)
  
      def add_pch(self, language, pchlist):
          if not pchlist:
              return
          elif len(pchlist) == 1:
              if not environment.is_header(pchlist[0]):
                  raise InvalidArguments('PCH argument %s is not a header.' % pchlist[0])
          elif len(pchlist) == 2:
              if environment.is_header(pchlist[0]):
                  if not environment.is_source(pchlist[1]):
                      raise InvalidArguments('PCH definition must contain one header and at most one source.')
              elif environment.is_source(pchlist[0]):
                  if not environment.is_header(pchlist[1]):
                      raise InvalidArguments('PCH definition must contain one header and at most one source.')
                  pchlist = [pchlist[1], pchlist[0]]
              else:
                  raise InvalidArguments('PCH argument %s is of unknown type.' % pchlist[0])
          elif len(pchlist) > 2:
              raise InvalidArguments('PCH definition may have a maximum of 2 files.')
          self.pch[language] = pchlist
  
      def add_include_dirs(self, args):
          ids = []
          for a in args:
              # FIXME same hack, forcibly unpack from holder.
              if hasattr(a, 'held_object'):
                  a = a.held_object
              if not isinstance(a, IncludeDirs):
                  raise InvalidArguments('Include directory to be added is not an include directory object.')
              ids.append(a)
          self.include_dirs += ids
  
      def add_compiler_args(self, language, args):
          args = listify(args)
          for a in args:
              if not isinstance(a, (str, File)):
                  raise InvalidArguments('A non-string passed to compiler args.')
          if language in self.extra_args:
              self.extra_args[language] += args
          else:
              self.extra_args[language] = args
  
      def get_aliases(self):
          return {}
  
      def get_langs_used_by_deps(self):
          '''
          Sometimes you want to link to a C++ library that exports C API, which
          means the linker must link in the C++ stdlib, and we must use a C++
          compiler for linking. The same is also applicable for objc/objc++, etc,
          so we can keep using clink_langs for the priority order.
  
          See: https://github.com/mesonbuild/meson/issues/1653
          '''
          langs = []
          # Check if any of the external libraries were written in this language
          for dep in self.external_deps:
              if dep.language is None:
                  continue
              if dep.language not in langs:
                  langs.append(dep.language)
          # Check if any of the internal libraries this target links to were
          # written in this language
          for link_target in itertools.chain(self.link_targets, self.link_whole_targets):
              for language in link_target.compilers:
                  if language not in langs:
                      langs.append(language)
          return langs
  
      def get_clink_dynamic_linker_and_stdlibs(self):
          '''
          We use the order of languages in `clink_langs` to determine which
          linker to use in case the target has sources compiled with multiple
          compilers. All languages other than those in this list have their own
          linker.
          Note that Vala outputs C code, so Vala sources can use any linker
          that can link compiled C. We don't actually need to add an exception
          for Vala here because of that.
          '''
          # Populate list of all compilers, not just those being used to compile
          # sources in this target
          if self.is_cross:
              all_compilers = self.environment.coredata.cross_compilers
          else:
              all_compilers = self.environment.coredata.compilers
          # Languages used by dependencies
          dep_langs = self.get_langs_used_by_deps()
          # Pick a compiler based on the language priority-order
          for l in clink_langs:
              if l in self.compilers or l in dep_langs:
                  try:
                      linker = all_compilers[l]
                  except KeyError:
                      raise MesonException(
                          'Could not get a dynamic linker for build target {!r}. '
                          'Requires a linker for language "{}", but that is not '
                          'a project language.'.format(self.name, l))
                  stdlib_args = []
                  added_languages = set()
                  for dl in itertools.chain(self.compilers, dep_langs):
                      if dl != linker.language:
                          stdlib_args += all_compilers[dl].language_stdlib_only_link_flags()
                          added_languages.add(dl)
                  return linker, stdlib_args
  
          m = 'Could not get a dynamic linker for build target {!r}'
          raise AssertionError(m.format(self.name))
  
      def get_using_msvc(self):
          '''
          Check if the dynamic linker is MSVC. Used by Executable, StaticLibrary,
          and SharedLibrary for deciding when to use MSVC-specific file naming
          and debug filenames.
  
          If at least some code is built with MSVC and the final library is
          linked with MSVC, we can be sure that some debug info will be
          generated. We only check the dynamic linker here because the static
          linker is guaranteed to be of the same type.
  
          Interesting cases:
          1. The Vala compiler outputs C code to be compiled by whatever
             C compiler we're using, so all objects will still be created by the
             MSVC compiler.
          2. If the target contains only objects, process_compilers guesses and
             picks the first compiler that smells right.
          '''
          linker, _ = self.get_clink_dynamic_linker_and_stdlibs()
          # Mixing many languages with MSVC is not supported yet so ignore stdlibs.
          if linker and linker.get_id() == 'msvc':
              return True
          return False
  
      def is_linkable_target(self):
          return False
  
      def check_module_linking(self):
          '''
          Warn if shared modules are linked with target: (link_with) #2865
          '''
          for link_target in self.link_targets:
              if isinstance(link_target, SharedModule):
                  if for_darwin(self.is_cross, self.environment):
                      raise MesonException('''target links against shared modules.
  This is not permitted on OSX''')
                  else:
                      mlog.warning('''target links against shared modules. This is not
  recommended as it is not supported on some platforms''')
                  return
  
  class Generator:
      @FeatureNewKwargs('generator', '0.43.0', ['capture'])
      def __init__(self, args, kwargs):
          if len(args) != 1:
              raise InvalidArguments('Generator requires exactly one positional argument: the executable')
          exe = args[0]
          if hasattr(exe, 'held_object'):
              exe = exe.held_object
          if not isinstance(exe, (Executable, dependencies.ExternalProgram)):
              raise InvalidArguments('First generator argument must be an executable.')
          self.exe = exe
          self.depfile = None
          self.capture = False
          self.process_kwargs(kwargs)
  
      def __repr__(self):
          repr_str = "<{0}: {1}>"
          return repr_str.format(self.__class__.__name__, self.exe)
  
      def get_exe(self):
          return self.exe
  
      def process_kwargs(self, kwargs):
          if 'arguments' not in kwargs:
              raise InvalidArguments('Generator must have "arguments" keyword argument.')
          args = kwargs['arguments']
          if isinstance(args, str):
              args = [args]
          if not isinstance(args, list):
              raise InvalidArguments('"Arguments" keyword argument must be a string or a list of strings.')
          for a in args:
              if not isinstance(a, str):
                  raise InvalidArguments('A non-string object in "arguments" keyword argument.')
          self.arglist = args
          if 'output' not in kwargs:
              raise InvalidArguments('Generator must have "output" keyword argument.')
          outputs = listify(kwargs['output'])
          for rule in outputs:
              if not isinstance(rule, str):
                  raise InvalidArguments('"output" may only contain strings.')
              if '@BASENAME@' not in rule and '@PLAINNAME@' not in rule:
                  raise InvalidArguments('Every element of "output" must contain @BASENAME@ or @PLAINNAME@.')
              if has_path_sep(rule):
                  raise InvalidArguments('"outputs" must not contain a directory separator.')
          if len(outputs) > 1:
              for o in outputs:
                  if '@OUTPUT@' in o:
                      raise InvalidArguments('Tried to use @OUTPUT@ in a rule with more than one output.')
          self.outputs = outputs
          if 'depfile' in kwargs:
              depfile = kwargs['depfile']
              if not isinstance(depfile, str):
                  raise InvalidArguments('Depfile must be a string.')
              if os.path.basename(depfile) != depfile:
                  raise InvalidArguments('Depfile must be a plain filename without a subdirectory.')
              self.depfile = depfile
          if 'capture' in kwargs:
              capture = kwargs['capture']
              if not isinstance(capture, bool):
                  raise InvalidArguments('Capture must be boolean.')
              self.capture = capture
  
      def get_base_outnames(self, inname):
          plainname = os.path.basename(inname)
          basename = os.path.splitext(plainname)[0]
          bases = [x.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname) for x in self.outputs]
          return bases
  
      def get_dep_outname(self, inname):
          if self.depfile is None:
              raise InvalidArguments('Tried to get dep name for rule that does not have dependency file defined.')
          plainname = os.path.basename(inname)
          basename = os.path.splitext(plainname)[0]
          return self.depfile.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname)
  
      def get_arglist(self, inname):
          plainname = os.path.basename(inname)
          basename = os.path.splitext(plainname)[0]
          return [x.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname) for x in self.arglist]
  
      def is_parent_path(self, parent, trial):
          relpath = pathlib.PurePath(trial).relative_to(parent)
          return relpath.parts[0] != '..' # For subdirs we can only go "down".
  
      def process_files(self, name, files, state, preserve_path_from=None, extra_args=[]):
          output = GeneratedList(self, state.subdir, preserve_path_from, extra_args=extra_args)
          for f in files:
              if isinstance(f, str):
                  f = File.from_source_file(state.environment.source_dir, state.subdir, f)
              elif not isinstance(f, File):
                  raise InvalidArguments('{} arguments must be strings or files not {!r}.'.format(name, f))
              if preserve_path_from:
                  abs_f = f.absolute_path(state.environment.source_dir, state.environment.build_dir)
                  if not self.is_parent_path(preserve_path_from, abs_f):
                      raise InvalidArguments('When using preserve_path_from, all input files must be in a subdirectory of the given dir.')
              output.add_file(f, state)
          return output
  
  
  class GeneratedList:
      def __init__(self, generator, subdir, preserve_path_from=None, extra_args=[]):
          if hasattr(generator, 'held_object'):
              generator = generator.held_object
          self.generator = generator
          self.name = self.generator.exe
          self.subdir = subdir
          self.infilelist = []
          self.outfilelist = []
          self.outmap = {}
          self.extra_depends = []
          self.preserve_path_from = preserve_path_from
          self.extra_args = extra_args
  
      def add_preserved_path_segment(self, infile, outfiles, state):
          result = []
          in_abs = infile.absolute_path(state.environment.source_dir, state.environment.build_dir)
          assert(os.path.isabs(self.preserve_path_from))
          rel = os.path.relpath(in_abs, self.preserve_path_from)
          path_segment = os.path.dirname(rel)
          for of in outfiles:
              result.append(os.path.join(path_segment, of))
          return result
  
      def add_file(self, newfile, state):
          self.infilelist.append(newfile)
          outfiles = self.generator.get_base_outnames(newfile.fname)
          if self.preserve_path_from:
              outfiles = self.add_preserved_path_segment(newfile, outfiles, state)
          self.outfilelist += outfiles
          self.outmap[newfile] = outfiles
  
      def get_inputs(self):
          return self.infilelist
  
      def get_outputs(self):
          return self.outfilelist
  
      def get_outputs_for(self, filename):
          return self.outmap[filename]
  
      def get_generator(self):
          return self.generator
  
      def get_extra_args(self):
          return self.extra_args
  
  class Executable(BuildTarget):
      known_kwargs = known_exe_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          # Unless overridden, executables have no suffix or prefix. Except on
          # Windows and with C#/Mono executables where the suffix is 'exe'
          if not hasattr(self, 'prefix'):
              self.prefix = ''
          if not hasattr(self, 'suffix'):
              # Executable for Windows or C#/Mono
              if (for_windows(is_cross, environment) or
                      for_cygwin(is_cross, environment) or 'cs' in self.compilers):
                  self.suffix = 'exe'
              else:
                  if ('c' in self.compilers and self.compilers['c'].get_id().startswith('arm') or
                     'cpp' in self.compilers and self.compilers['cpp'].get_id().startswith('arm')):
                      self.suffix = 'axf'
                  else:
                      self.suffix = ''
          self.filename = self.name
          if self.suffix:
              self.filename += '.' + self.suffix
          self.outputs = [self.filename]
  
          # The import library this target will generate
          self.import_filename = None
          # The import library that Visual Studio would generate (and accept)
          self.vs_import_filename = None
          # The import library that GCC would generate (and prefer)
          self.gcc_import_filename = None
  
          # Check for export_dynamic
          self.export_dynamic = False
          if kwargs.get('export_dynamic'):
              if not isinstance(kwargs['export_dynamic'], bool):
                  raise InvalidArguments('"export_dynamic" keyword argument must be a boolean')
              self.export_dynamic = True
          if kwargs.get('implib'):
              self.export_dynamic = True
          if self.export_dynamic and kwargs.get('implib') is False:
              raise InvalidArguments('"implib" keyword argument must not be false for if "export_dynamic" is true')
  
          # If using export_dynamic, set the import library name
          if self.export_dynamic:
              implib_basename = self.name + '.exe'
              if not isinstance(kwargs.get('implib', False), bool):
                  implib_basename = kwargs['implib']
              if for_windows(is_cross, environment) or for_cygwin(is_cross, environment):
                  self.vs_import_filename = '{0}.lib'.format(implib_basename)
                  self.gcc_import_filename = 'lib{0}.a'.format(implib_basename)
                  if self.get_using_msvc():
                      self.import_filename = self.vs_import_filename
                  else:
                      self.import_filename = self.gcc_import_filename
  
          # Only linkwithable if using export_dynamic
          self.is_linkwithable = self.export_dynamic
  
      def type_suffix(self):
          return "@exe"
  
      def get_import_filename(self):
          """
          The name of the import library that will be outputted by the compiler
  
          Returns None if there is no import library required for this platform
          """
          return self.import_filename
  
      def get_import_filenameslist(self):
          if self.import_filename:
              return [self.vs_import_filename, self.gcc_import_filename]
          return []
  
      def is_linkable_target(self):
          return self.is_linkwithable
  
  class StaticLibrary(BuildTarget):
      known_kwargs = known_stlib_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          if 'pic' not in kwargs and 'b_staticpic' in environment.coredata.base_options:
              kwargs['pic'] = environment.coredata.base_options['b_staticpic'].value
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          if 'cs' in self.compilers:
              raise InvalidArguments('Static libraries not supported for C#.')
          if 'rust' in self.compilers:
              # If no crate type is specified, or it's the generic lib type, use rlib
              if not hasattr(self, 'rust_crate_type') or self.rust_crate_type == 'lib':
                  mlog.debug('Defaulting Rust static library target crate type to rlib')
                  self.rust_crate_type = 'rlib'
              # Don't let configuration proceed with a non-static crate type
              elif self.rust_crate_type not in ['rlib', 'staticlib']:
                  raise InvalidArguments('Crate type "{0}" invalid for static libraries; must be "rlib" or "staticlib"'.format(self.rust_crate_type))
          # By default a static library is named libfoo.a even on Windows because
          # MSVC does not have a consistent convention for what static libraries
          # are called. The MSVC CRT uses libfoo.lib syntax but nothing else uses
          # it and GCC only looks for static libraries called foo.lib and
          # libfoo.a. However, we cannot use foo.lib because that's the same as
          # the import library. Using libfoo.a is ok because people using MSVC
          # always pass the library filename while linking anyway.
          if not hasattr(self, 'prefix'):
              self.prefix = 'lib'
          if not hasattr(self, 'suffix'):
              if 'rust' in self.compilers:
                  if not hasattr(self, 'rust_crate_type') or self.rust_crate_type == 'rlib':
                      # default Rust static library suffix
                      self.suffix = 'rlib'
                  elif self.rust_crate_type == 'staticlib':
                      self.suffix = 'a'
              else:
                  self.suffix = 'a'
          self.filename = self.prefix + self.name + '.' + self.suffix
          self.outputs = [self.filename]
  
      def type_suffix(self):
          return "@sta"
  
      def process_kwargs(self, kwargs, environment):
          super().process_kwargs(kwargs, environment)
          if 'rust_crate_type' in kwargs:
              rust_crate_type = kwargs['rust_crate_type']
              if isinstance(rust_crate_type, str):
                  self.rust_crate_type = rust_crate_type
              else:
                  raise InvalidArguments('Invalid rust_crate_type "{0}": must be a string.'.format(rust_crate_type))
  
      def is_linkable_target(self):
          return True
  
  class SharedLibrary(BuildTarget):
      known_kwargs = known_shlib_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          self.soversion = None
          self.ltversion = None
          self.vs_module_defs = None
          # The import library this target will generate
          self.import_filename = None
          # The import library that Visual Studio would generate (and accept)
          self.vs_import_filename = None
          # The import library that GCC would generate (and prefer)
          self.gcc_import_filename = None
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          if 'rust' in self.compilers:
              # If no crate type is specified, or it's the generic lib type, use dylib
              if not hasattr(self, 'rust_crate_type') or self.rust_crate_type == 'lib':
                  mlog.debug('Defaulting Rust dynamic library target crate type to "dylib"')
                  self.rust_crate_type = 'dylib'
              # Don't let configuration proceed with a non-dynamic crate type
              elif self.rust_crate_type not in ['dylib', 'cdylib']:
                  raise InvalidArguments('Crate type "{0}" invalid for dynamic libraries; must be "dylib" or "cdylib"'.format(self.rust_crate_type))
          if not hasattr(self, 'prefix'):
              self.prefix = None
          if not hasattr(self, 'suffix'):
              self.suffix = None
          self.basic_filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          self.determine_filenames(is_cross, environment)
  
      def determine_filenames(self, is_cross, env):
          """
          See https://github.com/mesonbuild/meson/pull/417 for details.
  
          First we determine the filename template (self.filename_tpl), then we
          set the output filename (self.filename).
  
          The template is needed while creating aliases (self.get_aliases),
          which are needed while generating .so shared libraries for Linux.
  
          Besides this, there's also the import library name, which is only used
          on Windows since on that platform the linker uses a separate library
          called the "import library" during linking instead of the shared
          library (DLL). The toolchain will output an import library in one of
          two formats: GCC or Visual Studio.
  
          When we're building with Visual Studio, the import library that will be
          generated by the toolchain is self.vs_import_filename, and with
          MinGW/GCC, it's self.gcc_import_filename. self.import_filename will
          always contain the import library name this target will generate.
          """
          prefix = ''
          suffix = ''
          self.filename_tpl = self.basic_filename_tpl
          # If the user already provided the prefix and suffix to us, we don't
          # need to do any filename suffix/prefix detection.
          # NOTE: manual prefix/suffix override is currently only tested for C/C++
          if self.prefix is not None and self.suffix is not None:
              pass
          # C# and Mono
          elif 'cs' in self.compilers:
              prefix = ''
              suffix = 'dll'
              self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          # C, C++, Swift, Vala
          # Only Windows uses a separate import library for linking
          # For all other targets/platforms import_filename stays None
          elif for_windows(is_cross, env):
              suffix = 'dll'
              self.vs_import_filename = '{0}.lib'.format(self.name)
              self.gcc_import_filename = 'lib{0}.dll.a'.format(self.name)
              if self.get_using_msvc():
                  # Shared library is of the form foo.dll
                  prefix = ''
                  # Import library is called foo.lib
                  self.import_filename = self.vs_import_filename
              # Assume GCC-compatible naming
              else:
                  # Shared library is of the form libfoo.dll
                  prefix = 'lib'
                  # Import library is called libfoo.dll.a
                  self.import_filename = self.gcc_import_filename
              # Shared library has the soversion if it is defined
              if self.soversion:
                  self.filename_tpl = '{0.prefix}{0.name}-{0.soversion}.{0.suffix}'
              else:
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          elif for_cygwin(is_cross, env):
              suffix = 'dll'
              self.gcc_import_filename = 'lib{0}.dll.a'.format(self.name)
              # Shared library is of the form cygfoo.dll
              # (ld --dll-search-prefix=cyg is the default)
              prefix = 'cyg'
              # Import library is called libfoo.dll.a
              self.import_filename = self.gcc_import_filename
              if self.soversion:
                  self.filename_tpl = '{0.prefix}{0.name}-{0.soversion}.{0.suffix}'
              else:
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          elif for_darwin(is_cross, env):
              prefix = 'lib'
              suffix = 'dylib'
              # On macOS, the filename can only contain the major version
              if self.soversion:
                  # libfoo.X.dylib
                  self.filename_tpl = '{0.prefix}{0.name}.{0.soversion}.{0.suffix}'
              else:
                  # libfoo.dylib
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          elif for_android(is_cross, env):
              prefix = 'lib'
              suffix = 'so'
              # Android doesn't support shared_library versioning
              self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          else:
              prefix = 'lib'
              suffix = 'so'
              if self.ltversion:
                  # libfoo.so.X[.Y[.Z]] (.Y and .Z are optional)
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}.{0.ltversion}'
              elif self.soversion:
                  # libfoo.so.X
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}.{0.soversion}'
              else:
                  # No versioning, libfoo.so
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          if self.prefix is None:
              self.prefix = prefix
          if self.suffix is None:
              self.suffix = suffix
          self.filename = self.filename_tpl.format(self)
          self.outputs = [self.filename]
  
      def process_kwargs(self, kwargs, environment):
          super().process_kwargs(kwargs, environment)
  
          if not for_android(self.is_cross, self.environment):
              supports_versioning = True
          else:
              supports_versioning = False
  
          if supports_versioning:
              # Shared library version
              if 'version' in kwargs:
                  self.ltversion = kwargs['version']
                  if not isinstance(self.ltversion, str):
                      raise InvalidArguments('Shared library version needs to be a string, not ' + type(self.ltversion).__name__)
                  if not re.fullmatch(r'[0-9]+(\.[0-9]+){0,2}', self.ltversion):
                      raise InvalidArguments('Invalid Shared library version "{0}". Must be of the form X.Y.Z where all three are numbers. Y and Z are optional.'.format(self.ltversion))
              # Try to extract/deduce the soversion
              if 'soversion' in kwargs:
                  self.soversion = kwargs['soversion']
                  if isinstance(self.soversion, int):
                      self.soversion = str(self.soversion)
                  if not isinstance(self.soversion, str):
                      raise InvalidArguments('Shared library soversion is not a string or integer.')
              elif self.ltversion:
                  # library version is defined, get the soversion from that
                  # We replicate what Autotools does here and take the first
                  # number of the version by default.
                  self.soversion = self.ltversion.split('.')[0]
          # Visual Studio module-definitions file
          if 'vs_module_defs' in kwargs:
              path = kwargs['vs_module_defs']
              if hasattr(path, 'held_object'):
                  path = path.held_object
              if isinstance(path, str):
                  if os.path.isabs(path):
                      self.vs_module_defs = File.from_absolute_file(path)
                  else:
                      self.vs_module_defs = File.from_source_file(environment.source_dir, self.subdir, path)
                  self.link_depends.append(self.vs_module_defs)
              elif isinstance(path, File):
                  # When passing a generated file.
                  self.vs_module_defs = path
                  self.link_depends.append(path)
              elif hasattr(path, 'get_filename'):
                  # When passing output of a Custom Target
                  path = File.from_built_file(path.subdir, path.get_filename())
                  self.vs_module_defs = path
                  self.link_depends.append(path)
              else:
                  raise InvalidArguments(
                      'Shared library vs_module_defs must be either a string, '
                      'a file object or a Custom Target')
          if 'rust_crate_type' in kwargs:
              rust_crate_type = kwargs['rust_crate_type']
              if isinstance(rust_crate_type, str):
                  self.rust_crate_type = rust_crate_type
              else:
                  raise InvalidArguments('Invalid rust_crate_type "{0}": must be a string.'.format(rust_crate_type))
  
      def get_import_filename(self):
          """
          The name of the import library that will be outputted by the compiler
  
          Returns None if there is no import library required for this platform
          """
          return self.import_filename
  
      def get_import_filenameslist(self):
          if self.import_filename:
              return [self.vs_import_filename, self.gcc_import_filename]
          return []
  
      def get_all_link_deps(self):
          return [self] + self.get_transitive_link_deps()
  
      def get_aliases(self):
          """
          If the versioned library name is libfoo.so.0.100.0, aliases are:
          * libfoo.so.0 (soversion) -> libfoo.so.0.100.0
          * libfoo.so (unversioned; for linking) -> libfoo.so.0
          Same for dylib:
          * libfoo.dylib (unversioned; for linking) -> libfoo.0.dylib
          """
          aliases = {}
          # Aliases are only useful with .so and .dylib libraries. Also if
          # there's no self.soversion (no versioning), we don't need aliases.
          if self.suffix not in ('so', 'dylib') or not self.soversion:
              return {}
          # With .so libraries, the minor and micro versions are also in the
          # filename. If ltversion != soversion we create an soversion alias:
          # libfoo.so.0 -> libfoo.so.0.100.0
          # Where libfoo.so.0.100.0 is the actual library
          if self.suffix == 'so' and self.ltversion and self.ltversion != self.soversion:
              alias_tpl = self.filename_tpl.replace('ltversion', 'soversion')
              ltversion_filename = alias_tpl.format(self)
              aliases[ltversion_filename] = self.filename
          # libfoo.so.0/libfoo.0.dylib is the actual library
          else:
              ltversion_filename = self.filename
          # Unversioned alias:
          #  libfoo.so -> libfoo.so.0
          #  libfoo.dylib -> libfoo.0.dylib
          aliases[self.basic_filename_tpl.format(self)] = ltversion_filename
          return aliases
  
      def type_suffix(self):
          return "@sha"
  
      def is_linkable_target(self):
          return True
  
  # A shared library that is meant to be used with dlopen rather than linking
  # into something else.
  class SharedModule(SharedLibrary):
      known_kwargs = known_shmod_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          if 'version' in kwargs:
              raise MesonException('Shared modules must not specify the version kwarg.')
          if 'soversion' in kwargs:
              raise MesonException('Shared modules must not specify the soversion kwarg.')
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
  
  class CustomTarget(Target):
      known_kwargs = set([
          'input',
          'output',
          'command',
          'capture',
          'install',
          'install_dir',
          'install_mode',
          'build_always',
          'build_always_stale',
          'depends',
          'depend_files',
          'depfile',
          'build_by_default',
          'override_options',
      ])
  
      def __init__(self, name, subdir, subproject, kwargs, absolute_paths=False):
          super().__init__(name, subdir, subproject, False)
          self.dependencies = []
          self.extra_depends = []
          self.depend_files = [] # Files that this target depends on but are not on the command line.
          self.depfile = None
          self.process_kwargs(kwargs)
          self.extra_files = []
          # Whether to use absolute paths for all files on the commandline
          self.absolute_paths = absolute_paths
          unknowns = []
          for k in kwargs:
              if k not in CustomTarget.known_kwargs:
                  unknowns.append(k)
          if len(unknowns) > 0:
              mlog.warning('Unknown keyword arguments in target %s: %s' %
                           (self.name, ', '.join(unknowns)))
  
      def __lt__(self, other):
          return self.get_id() < other.get_id()
  
      def __repr__(self):
          repr_str = "<{0} {1}: {2}>"
          return repr_str.format(self.__class__.__name__, self.get_id(), self.command)
  
      def get_id(self):
          return self.name + self.type_suffix()
  
      def get_target_dependencies(self):
          deps = self.dependencies[:]
          deps += self.extra_depends
          for c in self.sources:
              if hasattr(c, 'held_object'):
                  c = c.held_object
              if isinstance(c, (BuildTarget, CustomTarget)):
                  deps.append(c)
          return deps
  
      def get_transitive_build_target_deps(self):
          '''
          Recursively fetch the build targets that this custom target depends on,
          whether through `command:`, `depends:`, or `sources:` The recursion is
          only performed on custom targets.
          This is useful for setting PATH on Windows for finding required DLLs.
          F.ex, if you have a python script that loads a C module that links to
          other DLLs in your project.
          '''
          bdeps = set()
          deps = self.get_target_dependencies()
          for d in deps:
              if isinstance(d, BuildTarget):
                  bdeps.add(d)
              elif isinstance(d, CustomTarget):
                  bdeps.update(d.get_transitive_build_target_deps())
          return bdeps
  
      def flatten_command(self, cmd):
          cmd = listify(cmd, unholder=True)
          final_cmd = []
          for c in cmd:
              if isinstance(c, str):
                  final_cmd.append(c)
              elif isinstance(c, File):
                  self.depend_files.append(c)
                  final_cmd.append(c)
              elif isinstance(c, dependencies.ExternalProgram):
                  if not c.found():
                      m = 'Tried to use not-found external program {!r} in "command"'
                      raise InvalidArguments(m.format(c.name))
                  self.depend_files.append(File.from_absolute_file(c.get_path()))
                  final_cmd += c.get_command()
              elif isinstance(c, (BuildTarget, CustomTarget)):
                  self.dependencies.append(c)
                  final_cmd.append(c)
              elif isinstance(c, list):
                  final_cmd += self.flatten_command(c)
              else:
                  raise InvalidArguments('Argument {!r} in "command" is invalid'.format(c))
          return final_cmd
  
      def process_kwargs(self, kwargs):
          super().process_kwargs(kwargs)
          self.sources = extract_as_list(kwargs, 'input', unholder=True)
          if 'output' not in kwargs:
              raise InvalidArguments('Missing keyword argument "output".')
          self.outputs = listify(kwargs['output'])
          # This will substitute values from the input into output and return it.
          inputs = get_sources_string_names(self.sources)
          values = get_filenames_templates_dict(inputs, [])
          for i in self.outputs:
              if not(isinstance(i, str)):
                  raise InvalidArguments('Output argument not a string.')
              if i == '':
                  raise InvalidArguments('Output must not be empty.')
              if i.strip() == '':
                  raise InvalidArguments('Output must not consist only of whitespace.')
              if has_path_sep(i):
                  raise InvalidArguments('Output must not contain a path segment.')
              if '@INPUT@' in i or '@INPUT0@' in i:
                  m = 'Output cannot contain @INPUT@ or @INPUT0@, did you ' \
                      'mean @PLAINNAME@ or @BASENAME@?'
                  raise InvalidArguments(m)
              # We already check this during substitution, but the error message
              # will be unclear/confusing, so check it here.
              if len(inputs) != 1 and ('@PLAINNAME@' in i or '@BASENAME@' in i):
                  m = "Output cannot contain @PLAINNAME@ or @BASENAME@ when " \
                      "there is more than one input (we can't know which to use)"
                  raise InvalidArguments(m)
          self.outputs = substitute_values(self.outputs, values)
          self.capture = kwargs.get('capture', False)
          if self.capture and len(self.outputs) != 1:
              raise InvalidArguments('Capturing can only output to a single file.')
          if 'command' not in kwargs:
              raise InvalidArguments('Missing keyword argument "command".')
          if 'depfile' in kwargs:
              depfile = kwargs['depfile']
              if not isinstance(depfile, str):
                  raise InvalidArguments('Depfile must be a string.')
              if os.path.basename(depfile) != depfile:
                  raise InvalidArguments('Depfile must be a plain filename without a subdirectory.')
              self.depfile = depfile
          self.command = self.flatten_command(kwargs['command'])
          if self.capture:
              for c in self.command:
                  if isinstance(c, str) and '@OUTPUT@' in c:
                      raise InvalidArguments('@OUTPUT@ is not allowed when capturing output.')
          if 'install' in kwargs:
              self.install = kwargs['install']
              if not isinstance(self.install, bool):
                  raise InvalidArguments('"install" must be boolean.')
              if self.install:
                  if 'install_dir' not in kwargs:
                      raise InvalidArguments('"install_dir" must be specified '
                                             'when installing a target')
  
                  if isinstance(kwargs['install_dir'], list):
                      FeatureNew('multiple install_dir for custom_target', '0.40.0').use()
                  # If an item in this list is False, the output corresponding to
                  # the list index of that item will not be installed
                  self.install_dir = typeslistify(kwargs['install_dir'], (str, bool))
                  self.install_mode = kwargs.get('install_mode', None)
          else:
              self.install = False
              self.install_dir = [None]
              self.install_mode = None
          if 'build_always' in kwargs and 'build_always_stale' in kwargs:
              raise InvalidArguments('build_always and build_always_stale are mutually exclusive. Combine build_by_default and build_always_stale.')
          elif 'build_always' in kwargs:
              mlog.warning('build_always is deprecated. Combine build_by_default and build_always_stale instead.')
              self.build_by_default = kwargs['build_always']
              self.build_always_stale = kwargs['build_always']
          elif 'build_always_stale' in kwargs:
              self.build_always_stale = kwargs['build_always_stale']
          if not isinstance(self.build_always_stale, bool):
              raise InvalidArguments('Argument build_always_stale must be a boolean.')
          extra_deps, depend_files = extract_as_list(kwargs, 'depends', 'depend_files', pop = False)
          for ed in extra_deps:
              while hasattr(ed, 'held_object'):
                  ed = ed.held_object
              if not isinstance(ed, (CustomTarget, BuildTarget)):
                  raise InvalidArguments('Can only depend on toplevel targets: custom_target or build_target (executable or a library)')
              self.extra_depends.append(ed)
          for i in depend_files:
              if isinstance(i, (File, str)):
                  self.depend_files.append(i)
              else:
                  mlog.debug(i)
                  raise InvalidArguments('Unknown type {!r} in depend_files.'.format(type(i).__name__))
  
      def get_dependencies(self):
          return self.dependencies
  
      def should_install(self):
          return self.install
  
      def get_custom_install_dir(self):
          return self.install_dir
  
      def get_custom_install_mode(self):
          return self.install_mode
  
      def get_outputs(self):
          return self.outputs
  
      def get_filename(self):
          return self.outputs[0]
  
      def get_sources(self):
          return self.sources
  
      def get_generated_lists(self):
          genlists = []
          for c in self.sources:
              if hasattr(c, 'held_object'):
                  c = c.held_object
              if isinstance(c, GeneratedList):
                  genlists.append(c)
          return genlists
  
      def get_generated_sources(self):
          return self.get_generated_lists()
  
      def get_dep_outname(self, infilenames):
          if self.depfile is None:
              raise InvalidArguments('Tried to get depfile name for custom_target that does not have depfile defined.')
          if len(infilenames):
              plainname = os.path.basename(infilenames[0])
              basename = os.path.splitext(plainname)[0]
              return self.depfile.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname)
          else:
              if '@BASENAME@' in self.depfile or '@PLAINNAME@' in self.depfile:
                  raise InvalidArguments('Substitution in depfile for custom_target that does not have an input file.')
              return self.depfile
  
      def type_suffix(self):
          return "@cus"
  
      def __getitem__(self, index):
          return CustomTargetIndex(self, self.outputs[index])
  
      def __setitem__(self, index, value):
          raise NotImplementedError
  
      def __delitem__(self, index):
          raise NotImplementedError
  
  class RunTarget(Target):
      def __init__(self, name, command, args, dependencies, subdir, subproject):
          super().__init__(name, subdir, subproject, False)
          self.command = command
          self.args = args
          self.dependencies = dependencies
  
      def __lt__(self, other):
          return self.get_id() < other.get_id()
  
      def __repr__(self):
          repr_str = "<{0} {1}: {2}>"
          return repr_str.format(self.__class__.__name__, self.get_id(), self.command)
  
      def get_dependencies(self):
          return self.dependencies
  
      def get_generated_sources(self):
          return []
  
      def get_sources(self):
          return []
  
      def should_install(self):
          return False
  
      def get_filename(self):
          return self.name
  
      def type_suffix(self):
          return "@run"
  
  class Jar(BuildTarget):
      known_kwargs = known_jar_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          for s in self.sources:
              if not s.endswith('.java'):
                  raise InvalidArguments('Jar source %s is not a java file.' % s)
          self.filename = self.name + '.jar'
          self.outputs = [self.filename]
          self.java_args = kwargs.get('java_args', [])
  
      def get_main_class(self):
          return self.main_class
  
      def type_suffix(self):
          return "@jar"
  
      def get_java_args(self):
          return self.java_args
  
      def validate_cross_install(self, environment):
          # All jar targets are installable.
          pass
  
  class CustomTargetIndex:
  
      """A special opaque object returned by indexing a CustomTarget. This object
      exists in meson, but acts as a proxy in the backends, making targets depend
      on the CustomTarget it's derived from, but only adding one source file to
      the sources.
      """
  
      def __init__(self, target, output):
          self.target = target
          self.output = output
  
      def __repr__(self):
          return '<CustomTargetIndex: {!r}[{}]>'.format(
              self.target, self.target.get_outputs().index(self.output))
  
      def get_outputs(self):
          return [self.output]
  
      def get_subdir(self):
          return self.target.get_subdir()
  
  
  class ConfigureFile:
  
      def __init__(self, subdir, sourcename, targetname, configuration_data):
          self.subdir = subdir
          self.sourcename = sourcename
          self.targetname = targetname
          self.configuration_data = configuration_data
  
      def __repr__(self):
          repr_str = "<{0}: {1} -> {2}>"
          src = os.path.join(self.subdir, self.sourcename)
          dst = os.path.join(self.subdir, self.targetname)
          return repr_str.format(self.__class__.__name__, src, dst)
  
      def get_configuration_data(self):
          return self.configuration_data
  
      def get_subdir(self):
          return self.subdir
  
      def get_source_name(self):
          return self.sourcename
  
      def get_target_name(self):
          return self.targetname
  
  class ConfigurationData:
      def __init__(self):
          super().__init__()
          self.values = {}
  
      def __repr__(self):
          return repr(self.values)
  
      def __contains__(self, value):
          return value in self.values
  
      def get(self, name):
          return self.values[name] # (val, desc)
  
      def keys(self):
          return self.values.keys()
  
  # A bit poorly named, but this represents plain data files to copy
  # during install.
  class Data:
      def __init__(self, sources, install_dir, install_mode=None, rename=None):
          self.sources = sources
          self.install_dir = install_dir
          self.install_mode = install_mode
          self.sources = listify(self.sources)
          for s in self.sources:
              assert(isinstance(s, File))
          if rename is None:
              self.rename = [os.path.basename(f.fname) for f in self.sources]
          else:
              self.rename = stringlistify(rename)
              if len(self.rename) != len(self.sources):
                  raise MesonException('Size of rename argument is different from number of sources')
  
  class RunScript(dict):
      def __init__(self, script, args):
          super().__init__()
          assert(isinstance(script, list))
          assert(isinstance(args, list))
          self['exe'] = script
          self['args'] = args
  
  class TestSetup:
      def __init__(self, *, exe_wrapper=None, gdb=None, timeout_multiplier=None, env=None):
          self.exe_wrapper = exe_wrapper
          self.gdb = gdb
          self.timeout_multiplier = timeout_multiplier
          self.env = env
  
  def get_sources_string_names(sources):
      '''
      For the specified list of @sources which can be strings, Files, or targets,
      get all the output basenames.
      '''
      names = []
      for s in sources:
          if hasattr(s, 'held_object'):
              s = s.held_object
          if isinstance(s, str):
              names.append(s)
          elif isinstance(s, (BuildTarget, CustomTarget, CustomTargetIndex, GeneratedList)):
              names += s.get_outputs()
          elif isinstance(s, File):
              names.append(s.fname)
          else:
              raise AssertionError('Unknown source type: {!r}'.format(s))
      return names
  
  def load(build_dir):
      filename = os.path.join(build_dir, 'meson-private', 'build.dat')
      load_fail_msg = 'Build data file {!r} is corrupted. Try with a fresh build tree.'.format(filename)
      nonexisting_fail_msg = 'No such build data file as "{!r}".'.format(filename)
      try:
          with open(filename, 'rb') as f:
              obj = pickle.load(f)
      except FileNotFoundError:
          raise MesonException(nonexisting_fail_msg)
      except pickle.UnpicklingError:
          raise MesonException(load_fail_msg)
      if not isinstance(obj, Build):
          raise MesonException(load_fail_msg)
      return obj
  
  def save(obj, filename):
      with open(filename, 'wb') as f:
          pickle.dump(obj, f)
  
files: mesonbuild/build.py
files: # Copyright 2012-2017 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 copy, os, re
  from collections import OrderedDict
  import itertools, pathlib
  import pickle
  
  from . import environment
  from . import dependencies
  from . import mlog
  from .mesonlib import File, MesonException, listify, extract_as_list
  from .mesonlib import typeslistify, stringlistify, classify_unity_sources
  from .mesonlib import get_filenames_templates_dict, substitute_values
  from .mesonlib import for_windows, for_darwin, for_cygwin, for_android, has_path_sep
  from .compilers import is_object, clike_langs, sort_clike, lang_suffixes
  from .interpreterbase import FeatureNew, FeatureNewKwargs
  
  pch_kwargs = set(['c_pch', 'cpp_pch'])
  
  lang_arg_kwargs = set([
      'c_args',
      'cpp_args',
      'd_args',
      'd_import_dirs',
      'd_unittest',
      'd_module_versions',
      'fortran_args',
      'java_args',
      'objc_args',
      'objcpp_args',
      'rust_args',
      'vala_args',
      'cs_args',
  ])
  
  vala_kwargs = set(['vala_header', 'vala_gir', 'vala_vapi'])
  rust_kwargs = set(['rust_crate_type'])
  cs_kwargs = set(['resources', 'cs_args'])
  
  buildtarget_kwargs = set([
      'build_by_default',
      'build_rpath',
      'dependencies',
      'extra_files',
      'gui_app',
      'link_with',
      'link_whole',
      'link_args',
      'link_depends',
      'implicit_include_directories',
      'include_directories',
      'install',
      'install_rpath',
      'install_dir',
      'install_mode',
      'name_prefix',
      'name_suffix',
      'native',
      'objects',
      'override_options',
      'sources',
  ])
  
  known_build_target_kwargs = (
      buildtarget_kwargs |
      lang_arg_kwargs |
      pch_kwargs |
      vala_kwargs |
      rust_kwargs |
      cs_kwargs)
  
  known_exe_kwargs = known_build_target_kwargs | {'implib', 'export_dynamic'}
  known_shlib_kwargs = known_build_target_kwargs | {'version', 'soversion', 'vs_module_defs'}
  known_shmod_kwargs = known_build_target_kwargs
  known_stlib_kwargs = known_build_target_kwargs | {'pic'}
  known_jar_kwargs = known_exe_kwargs | {'main_class'}
  
  class InvalidArguments(MesonException):
      pass
  
  class Build:
      """A class that holds the status of one build including
      all dependencies and so on.
      """
  
      def __init__(self, environment):
          self.project_name = 'name of master project'
          self.project_version = None
          self.environment = environment
          self.projects = {}
          self.targets = OrderedDict()
          self.compilers = OrderedDict()
          self.cross_compilers = OrderedDict()
          self.global_args = {}
          self.projects_args = {}
          self.global_link_args = {}
          self.projects_link_args = {}
          self.tests = []
          self.benchmarks = []
          self.headers = []
          self.man = []
          self.data = []
          self.static_linker = None
          self.static_cross_linker = None
          self.subprojects = {}
          self.subproject_dir = ''
          self.install_scripts = []
          self.postconf_scripts = []
          self.install_dirs = []
          self.dep_manifest_name = None
          self.dep_manifest = {}
          self.cross_stdlibs = {}
          self.test_setups = {}
          self.find_overrides = {}
          self.searched_programs = set() # The list of all programs that have been searched for.
  
      def add_compiler(self, compiler):
          if self.static_linker is None and compiler.needs_static_linker():
              self.static_linker = self.environment.detect_static_linker(compiler)
          lang = compiler.get_language()
          if lang not in self.compilers:
              self.compilers[lang] = compiler
  
      def add_cross_compiler(self, compiler):
          if not self.cross_compilers:
              self.static_cross_linker = self.environment.detect_static_linker(compiler)
          lang = compiler.get_language()
          if lang not in self.cross_compilers:
              self.cross_compilers[lang] = compiler
  
      def get_project(self):
          return self.projects['']
  
      def get_subproject_dir(self):
          return self.subproject_dir
  
      def get_targets(self):
          return self.targets
  
      def get_tests(self):
          return self.tests
  
      def get_benchmarks(self):
          return self.benchmarks
  
      def get_headers(self):
          return self.headers
  
      def get_man(self):
          return self.man
  
      def get_data(self):
          return self.data
  
      def get_install_subdirs(self):
          return self.install_dirs
  
      def get_global_args(self, compiler):
          return self.global_args.get(compiler.get_language(), [])
  
      def get_project_args(self, compiler, project):
          args = self.projects_args.get(project)
          if not args:
              return []
          return args.get(compiler.get_language(), [])
  
      def get_global_link_args(self, compiler):
          return self.global_link_args.get(compiler.get_language(), [])
  
      def get_project_link_args(self, compiler, project):
          link_args = self.projects_link_args.get(project)
          if not link_args:
              return []
  
          return link_args.get(compiler.get_language(), [])
  
  class IncludeDirs:
      def __init__(self, curdir, dirs, is_system, extra_build_dirs=None):
          self.curdir = curdir
          self.incdirs = dirs
          self.is_system = is_system
          # Interpreter has validated that all given directories
          # actually exist.
          if extra_build_dirs is None:
              self.extra_build_dirs = []
          else:
              self.extra_build_dirs = extra_build_dirs
  
      def __repr__(self):
          r = '<{} {}/{}>'
          return r.format(self.__class__.__name__, self.curdir, self.incdirs)
  
      def get_curdir(self):
          return self.curdir
  
      def get_incdirs(self):
          return self.incdirs
  
      def get_extra_build_dirs(self):
          return self.extra_build_dirs
  
  class ExtractedObjects:
      '''
      Holds a list of sources for which the objects must be extracted
      '''
      def __init__(self, target, srclist=[], genlist=[], objlist=[], recursive=True):
          self.target = target
          self.recursive = recursive
          self.srclist = srclist
          self.genlist = genlist
          self.objlist = objlist
          if self.target.is_unity:
              self.check_unity_compatible()
  
      def __repr__(self):
          r = '<{0} {1!r}: {2}>'
          return r.format(self.__class__.__name__, self.target.name, self.srclist)
  
      def classify_all_sources(self, sources, generated_sources):
          # Merge sources and generated sources
          sources = list(sources)
          for gensrc in generated_sources:
              for s in gensrc.get_outputs():
                  # We cannot know the path where this source will be generated,
                  # but all we need here is the file extension to determine the
                  # compiler.
                  sources.append(s)
  
          # Filter out headers and all non-source files
          sources = [s for s in sources if environment.is_source(s) and not environment.is_header(s)]
  
          return classify_unity_sources(self.target.compilers.values(), sources)
  
      def check_unity_compatible(self):
          # Figure out if the extracted object list is compatible with a Unity
          # build. When we're doing a Unified build, we go through the sources,
          # and create a single source file from each subset of the sources that
          # can be compiled with a specific compiler. Then we create one object
          # from each unified source file. So for each compiler we can either
          # extra all its sources or none.
          cmpsrcs = self.classify_all_sources(self.target.sources, self.target.generated)
          extracted_cmpsrcs = self.classify_all_sources(self.srclist, self.genlist)
  
          for comp, srcs in extracted_cmpsrcs.items():
              if set(srcs) != set(cmpsrcs[comp]):
                  raise MesonException('Single object files can not be extracted '
                                       'in Unity builds. You can only extract all '
                                       'the object files for each compiler at once.')
  
  class EnvironmentVariables:
      def __init__(self):
          self.envvars = []
  
      def __repr__(self):
          repr_str = "<{0}: {1}>"
          return repr_str.format(self.__class__.__name__, self.envvars)
  
      def get_value(self, values, kwargs):
          separator = kwargs.get('separator', os.pathsep)
  
          value = ''
          for var in values:
              value += separator + var
          return separator, value.strip(separator)
  
      def set(self, env, name, values, kwargs):
          return self.get_value(values, kwargs)[1]
  
      def append(self, env, name, values, kwargs):
          sep, value = self.get_value(values, kwargs)
          if name in env:
              return env[name] + sep + value
          return value
  
      def prepend(self, env, name, values, kwargs):
          sep, value = self.get_value(values, kwargs)
          if name in env:
              return value + sep + env[name]
  
          return value
  
      def get_env(self, full_env):
          env = full_env.copy()
          for method, name, values, kwargs in self.envvars:
              env[name] = method(full_env, name, values, kwargs)
          return env
  
  class Target:
      def __init__(self, name, subdir, subproject, build_by_default):
          if has_path_sep(name):
              # Fix failing test 53 when this becomes an error.
              mlog.warning('''Target "%s" has a path separator in its name.
  This is not supported, it can cause unexpected failures and will become
  a hard error in the future.''' % name)
          self.name = name
          self.subdir = subdir
          self.subproject = subproject
          self.build_by_default = build_by_default
          self.install = False
          self.build_always_stale = False
          self.option_overrides = {}
  
      def get_basename(self):
          return self.name
  
      def get_subdir(self):
          return self.subdir
  
      def get_id(self):
          # This ID must also be a valid file name on all OSs.
          # It should also avoid shell metacharacters for obvious
          # reasons. '@' is not used as often as '_' in source code names.
          # In case of collisions consider using checksums.
          # FIXME replace with assert when slash in names is prohibited
          name_part = self.name.replace('/', '@').replace('\\', '@')
          assert not has_path_sep(self.type_suffix())
          myid = name_part + self.type_suffix()
          if self.subdir:
              subdir_part = self.subdir.replace('/', '@').replace('\\', '@')
              myid = subdir_part + '@@' + myid
          return myid
  
      @FeatureNewKwargs('build target', '0.42.0', ['rust_crate_type', 'build_rpath', 'implicit_include_directories'])
      @FeatureNewKwargs('build target', '0.41.0', ['rust_args'])
      @FeatureNewKwargs('build target', '0.40.0', ['build_by_default'])
      def process_kwargs(self, kwargs):
          if 'build_by_default' in kwargs:
              self.build_by_default = kwargs['build_by_default']
              if not isinstance(self.build_by_default, bool):
                  raise InvalidArguments('build_by_default must be a boolean value.')
          self.option_overrides = self.parse_overrides(kwargs)
  
      def parse_overrides(self, kwargs):
          result = {}
          overrides = stringlistify(kwargs.get('override_options', []))
          for o in overrides:
              if '=' not in o:
                  raise InvalidArguments('Overrides must be of form "key=value"')
              k, v = o.split('=', 1)
              k = k.strip()
              v = v.strip()
              result[k] = v
          return result
  
  
  class BuildTarget(Target):
      known_kwargs = known_build_target_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          super().__init__(name, subdir, subproject, True)
          self.is_cross = is_cross
          unity_opt = environment.coredata.get_builtin_option('unity')
          self.is_unity = unity_opt == 'on' or (unity_opt == 'subprojects' and subproject != '')
          self.environment = environment
          self.sources = []
          self.compilers = OrderedDict()
          self.objects = []
          self.external_deps = []
          self.include_dirs = []
          self.link_targets = []
          self.link_whole_targets = []
          self.link_depends = []
          self.name_prefix_set = False
          self.name_suffix_set = False
          self.filename = 'no_name'
          # The list of all files outputted by this target. Useful in cases such
          # as Vala which generates .vapi and .h besides the compiled output.
          self.outputs = [self.filename]
          self.need_install = False
          self.pch = {}
          self.extra_args = {}
          self.generated = []
          self.extra_files = []
          self.d_features = {}
          # Sources can be:
          # 1. Pre-existing source files in the source tree
          # 2. Pre-existing sources generated by configure_file in the build tree
          # 3. Sources files generated by another target or a Generator
          self.process_sourcelist(sources)
          # Objects can be:
          # 1. Pre-existing objects provided by the user with the `objects:` kwarg
          # 2. Compiled objects created by and extracted from another target
          self.process_objectlist(objects)
          self.process_kwargs(kwargs, environment)
          self.check_unknown_kwargs(kwargs)
          self.process_compilers()
          if not any([self.sources, self.generated, self.objects, self.link_whole]):
              raise InvalidArguments('Build target %s has no sources.' % name)
          self.process_compilers_late()
          self.validate_sources()
          self.validate_cross_install(environment)
          self.check_module_linking()
  
      def __lt__(self, other):
          return self.get_id() < other.get_id()
  
      def __repr__(self):
          repr_str = "<{0} {1}: {2}>"
          return repr_str.format(self.__class__.__name__, self.get_id(), self.filename)
  
      def validate_cross_install(self, environment):
          if environment.is_cross_build() and not self.is_cross and self.install:
              raise InvalidArguments('Tried to install a natively built target in a cross build.')
  
      def check_unknown_kwargs(self, kwargs):
          # Override this method in derived classes that have more
          # keywords.
          self.check_unknown_kwargs_int(kwargs, self.known_kwargs)
  
      def check_unknown_kwargs_int(self, kwargs, known_kwargs):
          unknowns = []
          for k in kwargs:
              if k not in known_kwargs:
                  unknowns.append(k)
          if len(unknowns) > 0:
              mlog.warning('Unknown keyword argument(s) in target %s: %s.' %
                           (self.name, ', '.join(unknowns)))
  
      def process_objectlist(self, objects):
          assert(isinstance(objects, list))
          for s in objects:
              if hasattr(s, 'held_object'):
                  s = s.held_object
              if isinstance(s, (str, File, ExtractedObjects)):
                  self.objects.append(s)
              elif isinstance(s, (GeneratedList, CustomTarget)):
                  msg = 'Generated files are not allowed in the \'objects\' kwarg ' + \
                      'for target {!r}.\nIt is meant only for '.format(self.name) + \
                      'pre-built object files that are shipped with the\nsource ' + \
                      'tree. Try adding it in the list of sources.'
                  raise InvalidArguments(msg)
              else:
                  msg = 'Bad object of type {!r} in target {!r}.'.format(type(s).__name__, self.name)
                  raise InvalidArguments(msg)
  
      def process_sourcelist(self, sources):
          sources = listify(sources)
          added_sources = {} # If the same source is defined multiple times, use it only once.
          for s in sources:
              # Holder unpacking. Ugly.
              if hasattr(s, 'held_object'):
                  s = s.held_object
              if isinstance(s, File):
                  if s not in added_sources:
                      self.sources.append(s)
                      added_sources[s] = True
              elif isinstance(s, (GeneratedList, CustomTarget, CustomTargetIndex)):
                  self.generated.append(s)
              else:
                  msg = 'Bad source of type {!r} in target {!r}.'.format(type(s).__name__, self.name)
                  raise InvalidArguments(msg)
  
      @staticmethod
      def can_compile_remove_sources(compiler, sources):
          removed = False
          for s in sources[:]:
              if compiler.can_compile(s):
                  sources.remove(s)
                  removed = True
          return removed
  
      def process_compilers_late(self):
          """Processes additional compilers after kwargs have been evaluated.
  
          This can add extra compilers that might be required by keyword
          arguments, such as link_with or dependencies. It will also try to guess
          which compiler to use if one hasn't been selected already.
          """
          # Populate list of compilers
          if self.is_cross:
              compilers = self.environment.coredata.cross_compilers
          else:
              compilers = self.environment.coredata.compilers
  
          # If this library is linked against another library we need to consider
          # the languages of those libraries as well.
          if self.link_targets or self.link_whole_targets:
              extra = set()
              for t in itertools.chain(self.link_targets, self.link_whole_targets):
                  for name, compiler in t.compilers.items():
                      if name in clike_langs:
                          extra.add((name, compiler))
              for name, compiler in sorted(extra, key=lambda p: sort_clike(p[0])):
                  self.compilers[name] = compiler
  
          if not self.compilers:
              # No source files or parent targets, target consists of only object
              # files of unknown origin. Just add the first clike compiler
              # that we have and hope that it can link these objects
              for lang in clike_langs:
                  if lang in compilers:
                      self.compilers[lang] = compilers[lang]
                      break
  
      def process_compilers(self):
          '''
          Populate self.compilers, which is the list of compilers that this
          target will use for compiling all its sources.
          We also add compilers that were used by extracted objects to simplify
          dynamic linker determination.
          '''
          if not self.sources and not self.generated and not self.objects:
              return
          # Populate list of compilers
          if self.is_cross:
              compilers = self.environment.coredata.cross_compilers
          else:
              compilers = self.environment.coredata.compilers
          # Pre-existing sources
          sources = list(self.sources)
          # All generated sources
          for gensrc in self.generated:
              for s in gensrc.get_outputs():
                  # Generated objects can't be compiled, so don't use them for
                  # compiler detection. If our target only has generated objects,
                  # we will fall back to using the first c-like compiler we find,
                  # which is what we need.
                  if not is_object(s):
                      sources.append(s)
          for d in self.external_deps:
              if hasattr(d, 'held_object'):
                  d = d.held_object
              for s in d.sources:
                  if isinstance(s, (str, File)):
                      sources.append(s)
  
          # Sources that were used to create our extracted objects
          for o in self.objects:
              if not isinstance(o, ExtractedObjects):
                  continue
              for s in o.srclist:
                  # Don't add Vala sources since that will pull in the Vala
                  # compiler even though we will never use it since we are
                  # dealing with compiled C code.
                  if not s.endswith(lang_suffixes['vala']):
                      sources.append(s)
          if sources:
              # For each source, try to add one compiler that can compile it.
              # It's ok if no compilers can do so, because users are expected to
              # be able to add arbitrary non-source files to the sources list.
              for s in sources:
                  for lang, compiler in compilers.items():
                      if compiler.can_compile(s):
                          if lang not in self.compilers:
                              self.compilers[lang] = compiler
                          break
              # Re-sort according to clike_langs
              self.compilers = OrderedDict(sorted(self.compilers.items(),
                                                  key=lambda t: sort_clike(t[0])))
  
          # If all our sources are Vala, our target also needs the C compiler but
          # it won't get added above.
          if 'vala' in self.compilers and 'c' not in self.compilers:
              self.compilers['c'] = compilers['c']
  
      def validate_sources(self):
          if not self.sources:
              return
          for lang in ('cs', 'java'):
              if lang in self.compilers:
                  check_sources = list(self.sources)
                  compiler = self.compilers[lang]
                  if not self.can_compile_remove_sources(compiler, check_sources):
                      m = 'No {} sources found in target {!r}'.format(lang, self.name)
                      raise InvalidArguments(m)
                  if check_sources:
                      m = '{0} targets can only contain {0} files:\n'.format(lang.capitalize())
                      m += '\n'.join([repr(c) for c in check_sources])
                      raise InvalidArguments(m)
                  # CSharp and Java targets can't contain any other file types
                  assert(len(self.compilers) == 1)
                  return
  
      def process_link_depends(self, sources, environment):
          """Process the link_depends keyword argument.
  
          This is designed to handle strings, Files, and the output of Custom
          Targets. Notably it doesn't handle generator() returned objects, since
          adding them as a link depends would inherently cause them to be
          generated twice, since the output needs to be passed to the ld_args and
          link_depends.
          """
          sources = listify(sources)
          for s in sources:
              if hasattr(s, 'held_object'):
                  s = s.held_object
  
              if isinstance(s, File):
                  self.link_depends.append(s)
              elif isinstance(s, str):
                  self.link_depends.append(
                      File.from_source_file(environment.source_dir, self.subdir, s))
              elif hasattr(s, 'get_outputs'):
                  self.link_depends.extend(
                      [File.from_built_file(s.subdir, p) for p in s.get_outputs()])
              else:
                  raise InvalidArguments(
                      'Link_depends arguments must be strings, Files, '
                      'or a Custom Target, or lists thereof.')
  
      def get_original_kwargs(self):
          return self.kwargs
  
      def unpack_holder(self, d):
          d = listify(d)
          newd = []
          for i in d:
              if isinstance(i, list):
                  i = self.unpack_holder(i)
              elif hasattr(i, 'held_object'):
                  i = i.held_object
              for t in ['dependencies', 'link_with', 'include_directories', 'sources']:
                  if hasattr(i, t):
                      setattr(i, t, self.unpack_holder(getattr(i, t)))
              newd.append(i)
          return newd
  
      def copy_kwargs(self, kwargs):
          self.kwargs = copy.copy(kwargs)
          # This sucks quite badly. Arguments
          # are holders but they can't be pickled
          # so unpack those known.
          for k, v in self.kwargs.items():
              if isinstance(v, list):
                  self.kwargs[k] = self.unpack_holder(v)
              if hasattr(v, 'held_object'):
                  self.kwargs[k] = v.held_object
          for t in ['dependencies', 'link_with', 'include_directories', 'sources']:
              if t in self.kwargs:
                  self.kwargs[t] = self.unpack_holder(self.kwargs[t])
  
      def extract_objects(self, srclist):
          obj_src = []
          for src in srclist:
              if not isinstance(src, str):
                  raise MesonException('Object extraction arguments must be strings.')
              src = File(False, self.subdir, src)
              # FIXME: It could be a generated source
              if src not in self.sources:
                  raise MesonException('Tried to extract unknown source %s.' % src)
              obj_src.append(src)
          return ExtractedObjects(self, obj_src)
  
      def extract_all_objects(self, recursive=True):
          return ExtractedObjects(self, self.sources, self.generated, self.objects,
                                  recursive)
  
      def get_all_link_deps(self):
          return self.get_transitive_link_deps()
  
      def get_transitive_link_deps(self):
          result = []
          for i in self.link_targets:
              result += i.get_all_link_deps()
          return result
  
      def get_custom_install_dir(self):
          return self.install_dir
  
      def get_custom_install_mode(self):
          return self.install_mode
  
      def process_kwargs(self, kwargs, environment):
          super().process_kwargs(kwargs)
          self.copy_kwargs(kwargs)
          kwargs.get('modules', [])
          self.need_install = kwargs.get('install', self.need_install)
          llist = extract_as_list(kwargs, 'link_with')
          for linktarget in llist:
              # Sorry for this hack. Keyword targets are kept in holders
              # in kwargs. Unpack here without looking at the exact type.
              if hasattr(linktarget, "held_object"):
                  linktarget = linktarget.held_object
              if isinstance(linktarget, dependencies.ExternalLibrary):
                  raise MesonException('''An external library was used in link_with keyword argument, which
  is reserved for libraries built as part of this project. External
  libraries must be passed using the dependencies keyword argument
  instead, because they are conceptually "external dependencies",
  just like those detected with the dependency() function.''')
              self.link(linktarget)
          lwhole = extract_as_list(kwargs, 'link_whole')
          for linktarget in lwhole:
              self.link_whole(linktarget)
  
          c_pchlist, cpp_pchlist, clist, cpplist, cslist, valalist,  objclist, objcpplist, fortranlist, rustlist \
              = extract_as_list(kwargs, 'c_pch', 'cpp_pch', 'c_args', 'cpp_args', 'cs_args', 'vala_args', 'objc_args',
                                'objcpp_args', 'fortran_args', 'rust_args')
  
          self.add_pch('c', c_pchlist)
          self.add_pch('cpp', cpp_pchlist)
          compiler_args = {'c': clist, 'cpp': cpplist, 'cs': cslist, 'vala': valalist, 'objc': objclist, 'objcpp': objcpplist,
                           'fortran': fortranlist, 'rust': rustlist
                           }
          for key, value in compiler_args.items():
              self.add_compiler_args(key, value)
  
          if not isinstance(self, Executable) or 'export_dynamic' in kwargs:
              self.vala_header = kwargs.get('vala_header', self.name + '.h')
              self.vala_vapi = kwargs.get('vala_vapi', self.name + '.vapi')
              self.vala_gir = kwargs.get('vala_gir', None)
  
          dlist = stringlistify(kwargs.get('d_args', []))
          self.add_compiler_args('d', dlist)
          dfeatures = dict()
          dfeature_unittest = kwargs.get('d_unittest', False)
          if dfeature_unittest:
              dfeatures['unittest'] = dfeature_unittest
          dfeature_versions = kwargs.get('d_module_versions', None)
          if dfeature_versions:
              dfeatures['versions'] = dfeature_versions
          if 'd_import_dirs' in kwargs:
              dfeature_import_dirs = extract_as_list(kwargs, 'd_import_dirs', unholder=True)
              for d in dfeature_import_dirs:
                  if not isinstance(d, IncludeDirs):
                      raise InvalidArguments('Arguments to d_import_dirs must be include_directories.')
              dfeatures['import_dirs'] = dfeature_import_dirs
          if dfeatures:
              self.d_features = dfeatures
  
          self.link_args = extract_as_list(kwargs, 'link_args')
          for i in self.link_args:
              if not isinstance(i, str):
                  raise InvalidArguments('Link_args arguments must be strings.')
          for l in self.link_args:
              if '-Wl,-rpath' in l or l.startswith('-rpath'):
                  mlog.warning('''Please do not define rpath with a linker argument, use install_rpath or build_rpath properties instead.
  This will become a hard error in a future Meson release.''')
          self.process_link_depends(kwargs.get('link_depends', []), environment)
          # Target-specific include dirs must be added BEFORE include dirs from
          # internal deps (added inside self.add_deps()) to override them.
          inclist = extract_as_list(kwargs, 'include_directories')
          self.add_include_dirs(inclist)
          # Add dependencies (which also have include_directories)
          deplist = extract_as_list(kwargs, 'dependencies')
          self.add_deps(deplist)
          # If an item in this list is False, the output corresponding to
          # the list index of that item will not be installed
          self.install_dir = typeslistify(kwargs.get('install_dir', [None]),
                                          (str, bool))
          self.install_mode = kwargs.get('install_mode', None)
          main_class = kwargs.get('main_class', '')
          if not isinstance(main_class, str):
              raise InvalidArguments('Main class must be a string')
          self.main_class = main_class
          if isinstance(self, Executable):
              self.gui_app = kwargs.get('gui_app', False)
              if not isinstance(self.gui_app, bool):
                  raise InvalidArguments('Argument gui_app must be boolean.')
          elif 'gui_app' in kwargs:
              raise InvalidArguments('Argument gui_app can only be used on executables.')
          extra_files = extract_as_list(kwargs, 'extra_files')
          for i in extra_files:
              assert(isinstance(i, File))
              trial = os.path.join(environment.get_source_dir(), i.subdir, i.fname)
              if not(os.path.isfile(trial)):
                  raise InvalidArguments('Tried to add non-existing extra file %s.' % i)
          self.extra_files = extra_files
          self.install_rpath = kwargs.get('install_rpath', '')
          if not isinstance(self.install_rpath, str):
              raise InvalidArguments('Install_rpath is not a string.')
          self.build_rpath = kwargs.get('build_rpath', '')
          if not isinstance(self.build_rpath, str):
              raise InvalidArguments('Build_rpath is not a string.')
          resources = extract_as_list(kwargs, 'resources')
          for r in resources:
              if not isinstance(r, str):
                  raise InvalidArguments('Resource argument is not a string.')
              trial = os.path.join(environment.get_source_dir(), self.subdir, r)
              if not os.path.isfile(trial):
                  raise InvalidArguments('Tried to add non-existing resource %s.' % r)
          self.resources = resources
          if 'name_prefix' in kwargs:
              name_prefix = kwargs['name_prefix']
              if isinstance(name_prefix, list):
                  if name_prefix:
                      raise InvalidArguments('name_prefix array must be empty to signify null.')
              elif not isinstance(name_prefix, str):
                  raise InvalidArguments('name_prefix must be a string.')
              self.prefix = name_prefix
              self.name_prefix_set = True
          if 'name_suffix' in kwargs:
              name_suffix = kwargs['name_suffix']
              if isinstance(name_suffix, list):
                  if name_suffix:
                      raise InvalidArguments('name_suffix array must be empty to signify null.')
              else:
                  if not isinstance(name_suffix, str):
                      raise InvalidArguments('name_suffix must be a string.')
                  if name_suffix == '':
                      raise InvalidArguments('name_suffix should not be an empty string. '
                                             'If you want meson to use the default behaviour '
                                             'for each platform pass `[]` (empty array)')
                  self.suffix = name_suffix
                  self.name_suffix_set = True
          if isinstance(self, StaticLibrary):
              # You can't disable PIC on OS X. The compiler ignores -fno-PIC.
              # PIC is always on for Windows (all code is position-independent
              # since library loading is done differently)
              if for_darwin(self.is_cross, self.environment) or for_windows(self.is_cross, self.environment):
                  self.pic = True
              elif '-fPIC' in clist + cpplist:
                  mlog.warning("Use the 'pic' kwarg instead of passing -fPIC manually to static library {!r}".format(self.name))
                  self.pic = True
              else:
                  self.pic = kwargs.get('pic', False)
                  if not isinstance(self.pic, bool):
                      raise InvalidArguments('Argument pic to static library {!r} must be boolean'.format(self.name))
          self.implicit_include_directories = kwargs.get('implicit_include_directories', True)
          if not isinstance(self.implicit_include_directories, bool):
              raise InvalidArguments('Implicit_include_directories must be a boolean.')
  
      def get_filename(self):
          return self.filename
  
      def get_outputs(self):
          return self.outputs
  
      def get_extra_args(self, language):
          return self.extra_args.get(language, [])
  
      def get_dependencies(self, exclude=None, internal=True):
          transitive_deps = []
          if exclude is None:
              exclude = []
          if internal:
              link_targets = itertools.chain(self.link_targets, self.link_whole_targets)
          else:
              # We don't want the 'internal' libraries when generating the
              # `Libs:` and `Libs.private:` lists in pkg-config files.
              link_targets = self.link_targets
          for t in link_targets:
              if t in transitive_deps or t in exclude:
                  continue
              transitive_deps.append(t)
              if isinstance(t, StaticLibrary):
                  transitive_deps += t.get_dependencies(transitive_deps + exclude, internal)
          return transitive_deps
  
      def get_source_subdir(self):
          return self.subdir
  
      def get_sources(self):
          return self.sources
  
      def get_objects(self):
          return self.objects
  
      def get_generated_sources(self):
          return self.generated
  
      def should_install(self):
          return self.need_install
  
      def has_pch(self):
          return len(self.pch) > 0
  
      def get_pch(self, language):
          try:
              return self.pch[language]
          except KeyError:
              return[]
  
      def get_include_dirs(self):
          return self.include_dirs
  
      def add_deps(self, deps):
          deps = listify(deps)
          for dep in deps:
              if hasattr(dep, 'held_object'):
                  dep = dep.held_object
              if isinstance(dep, dependencies.InternalDependency):
                  # Those parts that are internal.
                  self.process_sourcelist(dep.sources)
                  self.add_include_dirs(dep.include_directories)
                  for l in dep.libraries:
                      self.link(l)
                  for l in dep.whole_libraries:
                      self.link_whole(l)
                  if dep.compile_args or dep.link_args:
                      # Those parts that are external.
                      extpart = dependencies.InternalDependency('undefined',
                                                                [],
                                                                dep.compile_args,
                                                                dep.link_args,
                                                                [], [], [], [])
                      self.external_deps.append(extpart)
                  # Deps of deps.
                  self.add_deps(dep.ext_deps)
              elif isinstance(dep, dependencies.Dependency):
                  self.external_deps.append(dep)
                  self.process_sourcelist(dep.get_sources())
              elif isinstance(dep, BuildTarget):
                  raise InvalidArguments('''Tried to use a build target as a dependency.
  You probably should put it in link_with instead.''')
              else:
                  # This is a bit of a hack. We do not want Build to know anything
                  # about the interpreter so we can't import it and use isinstance.
                  # This should be reliable enough.
                  if hasattr(dep, 'project_args_frozen') or hasattr(dep, 'global_args_frozen'):
                      raise InvalidArguments('Tried to use subproject object as a dependency.\n'
                                             'You probably wanted to use a dependency declared in it instead.\n'
                                             'Access it by calling get_variable() on the subproject object.')
                  raise InvalidArguments('Argument is of an unacceptable type {!r}.\nMust be '
                                         'either an external dependency (returned by find_library() or '
                                         'dependency()) or an internal dependency (returned by '
                                         'declare_dependency()).'.format(type(dep).__name__))
  
      def get_external_deps(self):
          return self.external_deps
  
      def link(self, target):
          for t in listify(target, unholder=True):
              if not isinstance(t, Target):
                  raise InvalidArguments('{!r} is not a target.'.format(t))
              if not t.is_linkable_target():
                  raise InvalidArguments('Link target {!r} is not linkable.'.format(t))
              if isinstance(self, SharedLibrary) and isinstance(t, StaticLibrary) and not t.pic:
                  msg = "Can't link non-PIC static library {!r} into shared library {!r}. ".format(t.name, self.name)
                  msg += "Use the 'pic' option to static_library to build with PIC."
                  raise InvalidArguments(msg)
              if self.is_cross != t.is_cross:
                  raise InvalidArguments('Tried to mix cross built and native libraries in target {!r}'.format(self.name))
              self.link_targets.append(t)
  
      def link_whole(self, target):
          for t in listify(target, unholder=True):
              if not isinstance(t, StaticLibrary):
                  raise InvalidArguments('{!r} is not a static library.'.format(t))
              if isinstance(self, SharedLibrary) and not t.pic:
                  msg = "Can't link non-PIC static library {!r} into shared library {!r}. ".format(t.name, self.name)
                  msg += "Use the 'pic' option to static_library to build with PIC."
                  raise InvalidArguments(msg)
              if self.is_cross != t.is_cross:
                  raise InvalidArguments('Tried to mix cross built and native libraries in target {!r}'.format(self.name))
              self.link_whole_targets.append(t)
  
      def add_pch(self, language, pchlist):
          if not pchlist:
              return
          elif len(pchlist) == 1:
              if not environment.is_header(pchlist[0]):
                  raise InvalidArguments('PCH argument %s is not a header.' % pchlist[0])
          elif len(pchlist) == 2:
              if environment.is_header(pchlist[0]):
                  if not environment.is_source(pchlist[1]):
                      raise InvalidArguments('PCH definition must contain one header and at most one source.')
              elif environment.is_source(pchlist[0]):
                  if not environment.is_header(pchlist[1]):
                      raise InvalidArguments('PCH definition must contain one header and at most one source.')
                  pchlist = [pchlist[1], pchlist[0]]
              else:
                  raise InvalidArguments('PCH argument %s is of unknown type.' % pchlist[0])
          elif len(pchlist) > 2:
              raise InvalidArguments('PCH definition may have a maximum of 2 files.')
          self.pch[language] = pchlist
  
      def add_include_dirs(self, args):
          ids = []
          for a in args:
              # FIXME same hack, forcibly unpack from holder.
              if hasattr(a, 'held_object'):
                  a = a.held_object
              if not isinstance(a, IncludeDirs):
                  raise InvalidArguments('Include directory to be added is not an include directory object.')
              ids.append(a)
          self.include_dirs += ids
  
      def add_compiler_args(self, language, args):
          args = listify(args)
          for a in args:
              if not isinstance(a, (str, File)):
                  raise InvalidArguments('A non-string passed to compiler args.')
          if language in self.extra_args:
              self.extra_args[language] += args
          else:
              self.extra_args[language] = args
  
      def get_aliases(self):
          return {}
  
      def get_langs_used_by_deps(self):
          '''
          Sometimes you want to link to a C++ library that exports C API, which
          means the linker must link in the C++ stdlib, and we must use a C++
          compiler for linking. The same is also applicable for objc/objc++, etc,
          so we can keep using clike_langs for the priority order.
  
          See: https://github.com/mesonbuild/meson/issues/1653
          '''
          langs = []
          # Check if any of the external libraries were written in this language
          for dep in self.external_deps:
              if dep.language is None:
                  continue
              if dep.language not in langs:
                  langs.append(dep.language)
          # Check if any of the internal libraries this target links to were
          # written in this language
          for link_target in itertools.chain(self.link_targets, self.link_whole_targets):
              for language in link_target.compilers:
                  if language not in langs:
                      langs.append(language)
          return langs
  
      def get_clike_dynamic_linker_and_stdlibs(self):
          '''
          We use the order of languages in `clike_langs` to determine which
          linker to use in case the target has sources compiled with multiple
          compilers. All languages other than those in this list have their own
          linker.
          Note that Vala outputs C code, so Vala sources can use any linker
          that can link compiled C. We don't actually need to add an exception
          for Vala here because of that.
          '''
          # Populate list of all compilers, not just those being used to compile
          # sources in this target
          if self.is_cross:
              all_compilers = self.environment.coredata.cross_compilers
          else:
              all_compilers = self.environment.coredata.compilers
          # Languages used by dependencies
          dep_langs = self.get_langs_used_by_deps()
          # Pick a compiler based on the language priority-order
          for l in clike_langs:
              if l in self.compilers or l in dep_langs:
                  try:
                      linker = all_compilers[l]
                  except KeyError:
                      raise MesonException(
                          'Could not get a dynamic linker for build target {!r}. '
                          'Requires a linker for language "{}", but that is not '
                          'a project language.'.format(self.name, l))
                  stdlib_args = []
                  added_languages = set()
                  for dl in itertools.chain(self.compilers, dep_langs):
                      if dl != linker.language:
                          stdlib_args += all_compilers[dl].language_stdlib_only_link_flags()
                          added_languages.add(dl)
                  return linker, stdlib_args
  
          m = 'Could not get a dynamic linker for build target {!r}'
          raise AssertionError(m.format(self.name))
  
      def get_using_msvc(self):
          '''
          Check if the dynamic linker is MSVC. Used by Executable, StaticLibrary,
          and SharedLibrary for deciding when to use MSVC-specific file naming
          and debug filenames.
  
          If at least some code is built with MSVC and the final library is
          linked with MSVC, we can be sure that some debug info will be
          generated. We only check the dynamic linker here because the static
          linker is guaranteed to be of the same type.
  
          Interesting cases:
          1. The Vala compiler outputs C code to be compiled by whatever
             C compiler we're using, so all objects will still be created by the
             MSVC compiler.
          2. If the target contains only objects, process_compilers guesses and
             picks the first compiler that smells right.
          '''
          linker, _ = self.get_clike_dynamic_linker_and_stdlibs()
          # Mixing many languages with MSVC is not supported yet so ignore stdlibs.
          if linker and linker.get_id() == 'msvc':
              return True
          return False
  
      def is_linkable_target(self):
          return False
  
      def check_module_linking(self):
          '''
          Warn if shared modules are linked with target: (link_with) #2865
          '''
          for link_target in self.link_targets:
              if isinstance(link_target, SharedModule):
                  if for_darwin(self.is_cross, self.environment):
                      raise MesonException('''target links against shared modules.
  This is not permitted on OSX''')
                  else:
                      mlog.warning('''target links against shared modules. This is not
  recommended as it is not supported on some platforms''')
                  return
  
  class Generator:
      @FeatureNewKwargs('generator', '0.43.0', ['capture'])
      def __init__(self, args, kwargs):
          if len(args) != 1:
              raise InvalidArguments('Generator requires exactly one positional argument: the executable')
          exe = args[0]
          if hasattr(exe, 'held_object'):
              exe = exe.held_object
          if not isinstance(exe, (Executable, dependencies.ExternalProgram)):
              raise InvalidArguments('First generator argument must be an executable.')
          self.exe = exe
          self.depfile = None
          self.capture = False
          self.process_kwargs(kwargs)
  
      def __repr__(self):
          repr_str = "<{0}: {1}>"
          return repr_str.format(self.__class__.__name__, self.exe)
  
      def get_exe(self):
          return self.exe
  
      def process_kwargs(self, kwargs):
          if 'arguments' not in kwargs:
              raise InvalidArguments('Generator must have "arguments" keyword argument.')
          args = kwargs['arguments']
          if isinstance(args, str):
              args = [args]
          if not isinstance(args, list):
              raise InvalidArguments('"Arguments" keyword argument must be a string or a list of strings.')
          for a in args:
              if not isinstance(a, str):
                  raise InvalidArguments('A non-string object in "arguments" keyword argument.')
          self.arglist = args
          if 'output' not in kwargs:
              raise InvalidArguments('Generator must have "output" keyword argument.')
          outputs = listify(kwargs['output'])
          for rule in outputs:
              if not isinstance(rule, str):
                  raise InvalidArguments('"output" may only contain strings.')
              if '@BASENAME@' not in rule and '@PLAINNAME@' not in rule:
                  raise InvalidArguments('Every element of "output" must contain @BASENAME@ or @PLAINNAME@.')
              if has_path_sep(rule):
                  raise InvalidArguments('"outputs" must not contain a directory separator.')
          if len(outputs) > 1:
              for o in outputs:
                  if '@OUTPUT@' in o:
                      raise InvalidArguments('Tried to use @OUTPUT@ in a rule with more than one output.')
          self.outputs = outputs
          if 'depfile' in kwargs:
              depfile = kwargs['depfile']
              if not isinstance(depfile, str):
                  raise InvalidArguments('Depfile must be a string.')
              if os.path.basename(depfile) != depfile:
                  raise InvalidArguments('Depfile must be a plain filename without a subdirectory.')
              self.depfile = depfile
          if 'capture' in kwargs:
              capture = kwargs['capture']
              if not isinstance(capture, bool):
                  raise InvalidArguments('Capture must be boolean.')
              self.capture = capture
  
      def get_base_outnames(self, inname):
          plainname = os.path.basename(inname)
          basename = os.path.splitext(plainname)[0]
          bases = [x.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname) for x in self.outputs]
          return bases
  
      def get_dep_outname(self, inname):
          if self.depfile is None:
              raise InvalidArguments('Tried to get dep name for rule that does not have dependency file defined.')
          plainname = os.path.basename(inname)
          basename = os.path.splitext(plainname)[0]
          return self.depfile.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname)
  
      def get_arglist(self, inname):
          plainname = os.path.basename(inname)
          basename = os.path.splitext(plainname)[0]
          return [x.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname) for x in self.arglist]
  
      def is_parent_path(self, parent, trial):
          relpath = pathlib.PurePath(trial).relative_to(parent)
          return relpath.parts[0] != '..' # For subdirs we can only go "down".
  
      def process_files(self, name, files, state, preserve_path_from=None, extra_args=[]):
          output = GeneratedList(self, state.subdir, preserve_path_from, extra_args=extra_args)
          for f in files:
              if isinstance(f, str):
                  f = File.from_source_file(state.environment.source_dir, state.subdir, f)
              elif not isinstance(f, File):
                  raise InvalidArguments('{} arguments must be strings or files not {!r}.'.format(name, f))
              if preserve_path_from:
                  abs_f = f.absolute_path(state.environment.source_dir, state.environment.build_dir)
                  if not self.is_parent_path(preserve_path_from, abs_f):
                      raise InvalidArguments('When using preserve_path_from, all input files must be in a subdirectory of the given dir.')
              output.add_file(f, state)
          return output
  
  
  class GeneratedList:
      def __init__(self, generator, subdir, preserve_path_from=None, extra_args=[]):
          if hasattr(generator, 'held_object'):
              generator = generator.held_object
          self.generator = generator
          self.name = self.generator.exe
          self.subdir = subdir
          self.infilelist = []
          self.outfilelist = []
          self.outmap = {}
          self.extra_depends = []
          self.preserve_path_from = preserve_path_from
          self.extra_args = extra_args
  
      def add_preserved_path_segment(self, infile, outfiles, state):
          result = []
          in_abs = infile.absolute_path(state.environment.source_dir, state.environment.build_dir)
          assert(os.path.isabs(self.preserve_path_from))
          rel = os.path.relpath(in_abs, self.preserve_path_from)
          path_segment = os.path.dirname(rel)
          for of in outfiles:
              result.append(os.path.join(path_segment, of))
          return result
  
      def add_file(self, newfile, state):
          self.infilelist.append(newfile)
          outfiles = self.generator.get_base_outnames(newfile.fname)
          if self.preserve_path_from:
              outfiles = self.add_preserved_path_segment(newfile, outfiles, state)
          self.outfilelist += outfiles
          self.outmap[newfile] = outfiles
  
      def get_inputs(self):
          return self.infilelist
  
      def get_outputs(self):
          return self.outfilelist
  
      def get_outputs_for(self, filename):
          return self.outmap[filename]
  
      def get_generator(self):
          return self.generator
  
      def get_extra_args(self):
          return self.extra_args
  
  class Executable(BuildTarget):
      known_kwargs = known_exe_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          # Unless overridden, executables have no suffix or prefix. Except on
          # Windows and with C#/Mono executables where the suffix is 'exe'
          if not hasattr(self, 'prefix'):
              self.prefix = ''
          if not hasattr(self, 'suffix'):
              # Executable for Windows or C#/Mono
              if (for_windows(is_cross, environment) or
                      for_cygwin(is_cross, environment) or 'cs' in self.compilers):
                  self.suffix = 'exe'
              else:
                  if ('c' in self.compilers and self.compilers['c'].get_id().startswith('arm') or
                     'cpp' in self.compilers and self.compilers['cpp'].get_id().startswith('arm')):
                      self.suffix = 'axf'
                  else:
                      self.suffix = ''
          self.filename = self.name
          if self.suffix:
              self.filename += '.' + self.suffix
          self.outputs = [self.filename]
  
          # The import library this target will generate
          self.import_filename = None
          # The import library that Visual Studio would generate (and accept)
          self.vs_import_filename = None
          # The import library that GCC would generate (and prefer)
          self.gcc_import_filename = None
  
          # Check for export_dynamic
          self.export_dynamic = False
          if kwargs.get('export_dynamic'):
              if not isinstance(kwargs['export_dynamic'], bool):
                  raise InvalidArguments('"export_dynamic" keyword argument must be a boolean')
              self.export_dynamic = True
          if kwargs.get('implib'):
              self.export_dynamic = True
          if self.export_dynamic and kwargs.get('implib') is False:
              raise InvalidArguments('"implib" keyword argument must not be false for if "export_dynamic" is true')
  
          # If using export_dynamic, set the import library name
          if self.export_dynamic:
              implib_basename = self.name + '.exe'
              if not isinstance(kwargs.get('implib', False), bool):
                  implib_basename = kwargs['implib']
              if for_windows(is_cross, environment) or for_cygwin(is_cross, environment):
                  self.vs_import_filename = '{0}.lib'.format(implib_basename)
                  self.gcc_import_filename = 'lib{0}.a'.format(implib_basename)
                  if self.get_using_msvc():
                      self.import_filename = self.vs_import_filename
                  else:
                      self.import_filename = self.gcc_import_filename
  
          # Only linkwithable if using export_dynamic
          self.is_linkwithable = self.export_dynamic
  
      def type_suffix(self):
          return "@exe"
  
      def get_import_filename(self):
          """
          The name of the import library that will be outputted by the compiler
  
          Returns None if there is no import library required for this platform
          """
          return self.import_filename
  
      def get_import_filenameslist(self):
          if self.import_filename:
              return [self.vs_import_filename, self.gcc_import_filename]
          return []
  
      def is_linkable_target(self):
          return self.is_linkwithable
  
  class StaticLibrary(BuildTarget):
      known_kwargs = known_stlib_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          if 'pic' not in kwargs and 'b_staticpic' in environment.coredata.base_options:
              kwargs['pic'] = environment.coredata.base_options['b_staticpic'].value
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          if 'cs' in self.compilers:
              raise InvalidArguments('Static libraries not supported for C#.')
          if 'rust' in self.compilers:
              # If no crate type is specified, or it's the generic lib type, use rlib
              if not hasattr(self, 'rust_crate_type') or self.rust_crate_type == 'lib':
                  mlog.debug('Defaulting Rust static library target crate type to rlib')
                  self.rust_crate_type = 'rlib'
              # Don't let configuration proceed with a non-static crate type
              elif self.rust_crate_type not in ['rlib', 'staticlib']:
                  raise InvalidArguments('Crate type "{0}" invalid for static libraries; must be "rlib" or "staticlib"'.format(self.rust_crate_type))
          # By default a static library is named libfoo.a even on Windows because
          # MSVC does not have a consistent convention for what static libraries
          # are called. The MSVC CRT uses libfoo.lib syntax but nothing else uses
          # it and GCC only looks for static libraries called foo.lib and
          # libfoo.a. However, we cannot use foo.lib because that's the same as
          # the import library. Using libfoo.a is ok because people using MSVC
          # always pass the library filename while linking anyway.
          if not hasattr(self, 'prefix'):
              self.prefix = 'lib'
          if not hasattr(self, 'suffix'):
              if 'rust' in self.compilers:
                  if not hasattr(self, 'rust_crate_type') or self.rust_crate_type == 'rlib':
                      # default Rust static library suffix
                      self.suffix = 'rlib'
                  elif self.rust_crate_type == 'staticlib':
                      self.suffix = 'a'
              else:
                  self.suffix = 'a'
          self.filename = self.prefix + self.name + '.' + self.suffix
          self.outputs = [self.filename]
  
      def type_suffix(self):
          return "@sta"
  
      def process_kwargs(self, kwargs, environment):
          super().process_kwargs(kwargs, environment)
          if 'rust_crate_type' in kwargs:
              rust_crate_type = kwargs['rust_crate_type']
              if isinstance(rust_crate_type, str):
                  self.rust_crate_type = rust_crate_type
              else:
                  raise InvalidArguments('Invalid rust_crate_type "{0}": must be a string.'.format(rust_crate_type))
  
      def is_linkable_target(self):
          return True
  
  class SharedLibrary(BuildTarget):
      known_kwargs = known_shlib_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          self.soversion = None
          self.ltversion = None
          self.vs_module_defs = None
          # The import library this target will generate
          self.import_filename = None
          # The import library that Visual Studio would generate (and accept)
          self.vs_import_filename = None
          # The import library that GCC would generate (and prefer)
          self.gcc_import_filename = None
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          if 'rust' in self.compilers:
              # If no crate type is specified, or it's the generic lib type, use dylib
              if not hasattr(self, 'rust_crate_type') or self.rust_crate_type == 'lib':
                  mlog.debug('Defaulting Rust dynamic library target crate type to "dylib"')
                  self.rust_crate_type = 'dylib'
              # Don't let configuration proceed with a non-dynamic crate type
              elif self.rust_crate_type not in ['dylib', 'cdylib']:
                  raise InvalidArguments('Crate type "{0}" invalid for dynamic libraries; must be "dylib" or "cdylib"'.format(self.rust_crate_type))
          if not hasattr(self, 'prefix'):
              self.prefix = None
          if not hasattr(self, 'suffix'):
              self.suffix = None
          self.basic_filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          self.determine_filenames(is_cross, environment)
  
      def determine_filenames(self, is_cross, env):
          """
          See https://github.com/mesonbuild/meson/pull/417 for details.
  
          First we determine the filename template (self.filename_tpl), then we
          set the output filename (self.filename).
  
          The template is needed while creating aliases (self.get_aliases),
          which are needed while generating .so shared libraries for Linux.
  
          Besides this, there's also the import library name, which is only used
          on Windows since on that platform the linker uses a separate library
          called the "import library" during linking instead of the shared
          library (DLL). The toolchain will output an import library in one of
          two formats: GCC or Visual Studio.
  
          When we're building with Visual Studio, the import library that will be
          generated by the toolchain is self.vs_import_filename, and with
          MinGW/GCC, it's self.gcc_import_filename. self.import_filename will
          always contain the import library name this target will generate.
          """
          prefix = ''
          suffix = ''
          self.filename_tpl = self.basic_filename_tpl
          # If the user already provided the prefix and suffix to us, we don't
          # need to do any filename suffix/prefix detection.
          # NOTE: manual prefix/suffix override is currently only tested for C/C++
          if self.prefix is not None and self.suffix is not None:
              pass
          # C# and Mono
          elif 'cs' in self.compilers:
              prefix = ''
              suffix = 'dll'
              self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          # C, C++, Swift, Vala
          # Only Windows uses a separate import library for linking
          # For all other targets/platforms import_filename stays None
          elif for_windows(is_cross, env):
              suffix = 'dll'
              self.vs_import_filename = '{0}.lib'.format(self.name)
              self.gcc_import_filename = 'lib{0}.dll.a'.format(self.name)
              if self.get_using_msvc():
                  # Shared library is of the form foo.dll
                  prefix = ''
                  # Import library is called foo.lib
                  self.import_filename = self.vs_import_filename
              # Assume GCC-compatible naming
              else:
                  # Shared library is of the form libfoo.dll
                  prefix = 'lib'
                  # Import library is called libfoo.dll.a
                  self.import_filename = self.gcc_import_filename
              # Shared library has the soversion if it is defined
              if self.soversion:
                  self.filename_tpl = '{0.prefix}{0.name}-{0.soversion}.{0.suffix}'
              else:
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          elif for_cygwin(is_cross, env):
              suffix = 'dll'
              self.gcc_import_filename = 'lib{0}.dll.a'.format(self.name)
              # Shared library is of the form cygfoo.dll
              # (ld --dll-search-prefix=cyg is the default)
              prefix = 'cyg'
              # Import library is called libfoo.dll.a
              self.import_filename = self.gcc_import_filename
              if self.soversion:
                  self.filename_tpl = '{0.prefix}{0.name}-{0.soversion}.{0.suffix}'
              else:
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          elif for_darwin(is_cross, env):
              prefix = 'lib'
              suffix = 'dylib'
              # On macOS, the filename can only contain the major version
              if self.soversion:
                  # libfoo.X.dylib
                  self.filename_tpl = '{0.prefix}{0.name}.{0.soversion}.{0.suffix}'
              else:
                  # libfoo.dylib
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          elif for_android(is_cross, env):
              prefix = 'lib'
              suffix = 'so'
              # Android doesn't support shared_library versioning
              self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          else:
              prefix = 'lib'
              suffix = 'so'
              if self.ltversion:
                  # libfoo.so.X[.Y[.Z]] (.Y and .Z are optional)
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}.{0.ltversion}'
              elif self.soversion:
                  # libfoo.so.X
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}.{0.soversion}'
              else:
                  # No versioning, libfoo.so
                  self.filename_tpl = '{0.prefix}{0.name}.{0.suffix}'
          if self.prefix is None:
              self.prefix = prefix
          if self.suffix is None:
              self.suffix = suffix
          self.filename = self.filename_tpl.format(self)
          self.outputs = [self.filename]
  
      def process_kwargs(self, kwargs, environment):
          super().process_kwargs(kwargs, environment)
  
          if not for_android(self.is_cross, self.environment):
              supports_versioning = True
          else:
              supports_versioning = False
  
          if supports_versioning:
              # Shared library version
              if 'version' in kwargs:
                  self.ltversion = kwargs['version']
                  if not isinstance(self.ltversion, str):
                      raise InvalidArguments('Shared library version needs to be a string, not ' + type(self.ltversion).__name__)
                  if not re.fullmatch(r'[0-9]+(\.[0-9]+){0,2}', self.ltversion):
                      raise InvalidArguments('Invalid Shared library version "{0}". Must be of the form X.Y.Z where all three are numbers. Y and Z are optional.'.format(self.ltversion))
              # Try to extract/deduce the soversion
              if 'soversion' in kwargs:
                  self.soversion = kwargs['soversion']
                  if isinstance(self.soversion, int):
                      self.soversion = str(self.soversion)
                  if not isinstance(self.soversion, str):
                      raise InvalidArguments('Shared library soversion is not a string or integer.')
              elif self.ltversion:
                  # library version is defined, get the soversion from that
                  # We replicate what Autotools does here and take the first
                  # number of the version by default.
                  self.soversion = self.ltversion.split('.')[0]
          # Visual Studio module-definitions file
          if 'vs_module_defs' in kwargs:
              path = kwargs['vs_module_defs']
              if hasattr(path, 'held_object'):
                  path = path.held_object
              if isinstance(path, str):
                  if os.path.isabs(path):
                      self.vs_module_defs = File.from_absolute_file(path)
                  else:
                      self.vs_module_defs = File.from_source_file(environment.source_dir, self.subdir, path)
                  self.link_depends.append(self.vs_module_defs)
              elif isinstance(path, File):
                  # When passing a generated file.
                  self.vs_module_defs = path
                  self.link_depends.append(path)
              elif hasattr(path, 'get_filename'):
                  # When passing output of a Custom Target
                  path = File.from_built_file(path.subdir, path.get_filename())
                  self.vs_module_defs = path
                  self.link_depends.append(path)
              else:
                  raise InvalidArguments(
                      'Shared library vs_module_defs must be either a string, '
                      'a file object or a Custom Target')
          if 'rust_crate_type' in kwargs:
              rust_crate_type = kwargs['rust_crate_type']
              if isinstance(rust_crate_type, str):
                  self.rust_crate_type = rust_crate_type
              else:
                  raise InvalidArguments('Invalid rust_crate_type "{0}": must be a string.'.format(rust_crate_type))
  
      def get_import_filename(self):
          """
          The name of the import library that will be outputted by the compiler
  
          Returns None if there is no import library required for this platform
          """
          return self.import_filename
  
      def get_import_filenameslist(self):
          if self.import_filename:
              return [self.vs_import_filename, self.gcc_import_filename]
          return []
  
      def get_all_link_deps(self):
          return [self] + self.get_transitive_link_deps()
  
      def get_aliases(self):
          """
          If the versioned library name is libfoo.so.0.100.0, aliases are:
          * libfoo.so.0 (soversion) -> libfoo.so.0.100.0
          * libfoo.so (unversioned; for linking) -> libfoo.so.0
          Same for dylib:
          * libfoo.dylib (unversioned; for linking) -> libfoo.0.dylib
          """
          aliases = {}
          # Aliases are only useful with .so and .dylib libraries. Also if
          # there's no self.soversion (no versioning), we don't need aliases.
          if self.suffix not in ('so', 'dylib') or not self.soversion:
              return {}
          # With .so libraries, the minor and micro versions are also in the
          # filename. If ltversion != soversion we create an soversion alias:
          # libfoo.so.0 -> libfoo.so.0.100.0
          # Where libfoo.so.0.100.0 is the actual library
          if self.suffix == 'so' and self.ltversion and self.ltversion != self.soversion:
              alias_tpl = self.filename_tpl.replace('ltversion', 'soversion')
              ltversion_filename = alias_tpl.format(self)
              aliases[ltversion_filename] = self.filename
          # libfoo.so.0/libfoo.0.dylib is the actual library
          else:
              ltversion_filename = self.filename
          # Unversioned alias:
          #  libfoo.so -> libfoo.so.0
          #  libfoo.dylib -> libfoo.0.dylib
          aliases[self.basic_filename_tpl.format(self)] = ltversion_filename
          return aliases
  
      def type_suffix(self):
          return "@sha"
  
      def is_linkable_target(self):
          return True
  
  # A shared library that is meant to be used with dlopen rather than linking
  # into something else.
  class SharedModule(SharedLibrary):
      known_kwargs = known_shmod_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          if 'version' in kwargs:
              raise MesonException('Shared modules must not specify the version kwarg.')
          if 'soversion' in kwargs:
              raise MesonException('Shared modules must not specify the soversion kwarg.')
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
  
  class CustomTarget(Target):
      known_kwargs = set([
          'input',
          'output',
          'command',
          'capture',
          'install',
          'install_dir',
          'install_mode',
          'build_always',
          'build_always_stale',
          'depends',
          'depend_files',
          'depfile',
          'build_by_default',
          'override_options',
      ])
  
      def __init__(self, name, subdir, subproject, kwargs, absolute_paths=False):
          super().__init__(name, subdir, subproject, False)
          self.dependencies = []
          self.extra_depends = []
          self.depend_files = [] # Files that this target depends on but are not on the command line.
          self.depfile = None
          self.process_kwargs(kwargs)
          self.extra_files = []
          # Whether to use absolute paths for all files on the commandline
          self.absolute_paths = absolute_paths
          unknowns = []
          for k in kwargs:
              if k not in CustomTarget.known_kwargs:
                  unknowns.append(k)
          if len(unknowns) > 0:
              mlog.warning('Unknown keyword arguments in target %s: %s' %
                           (self.name, ', '.join(unknowns)))
  
      def __lt__(self, other):
          return self.get_id() < other.get_id()
  
      def __repr__(self):
          repr_str = "<{0} {1}: {2}>"
          return repr_str.format(self.__class__.__name__, self.get_id(), self.command)
  
      def get_id(self):
          return self.name + self.type_suffix()
  
      def get_target_dependencies(self):
          deps = self.dependencies[:]
          deps += self.extra_depends
          for c in self.sources:
              if hasattr(c, 'held_object'):
                  c = c.held_object
              if isinstance(c, (BuildTarget, CustomTarget)):
                  deps.append(c)
          return deps
  
      def get_transitive_build_target_deps(self):
          '''
          Recursively fetch the build targets that this custom target depends on,
          whether through `command:`, `depends:`, or `sources:` The recursion is
          only performed on custom targets.
          This is useful for setting PATH on Windows for finding required DLLs.
          F.ex, if you have a python script that loads a C module that links to
          other DLLs in your project.
          '''
          bdeps = set()
          deps = self.get_target_dependencies()
          for d in deps:
              if isinstance(d, BuildTarget):
                  bdeps.add(d)
              elif isinstance(d, CustomTarget):
                  bdeps.update(d.get_transitive_build_target_deps())
          return bdeps
  
      def flatten_command(self, cmd):
          cmd = listify(cmd, unholder=True)
          final_cmd = []
          for c in cmd:
              if isinstance(c, str):
                  final_cmd.append(c)
              elif isinstance(c, File):
                  self.depend_files.append(c)
                  final_cmd.append(c)
              elif isinstance(c, dependencies.ExternalProgram):
                  if not c.found():
                      m = 'Tried to use not-found external program {!r} in "command"'
                      raise InvalidArguments(m.format(c.name))
                  self.depend_files.append(File.from_absolute_file(c.get_path()))
                  final_cmd += c.get_command()
              elif isinstance(c, (BuildTarget, CustomTarget)):
                  self.dependencies.append(c)
                  final_cmd.append(c)
              elif isinstance(c, list):
                  final_cmd += self.flatten_command(c)
              else:
                  raise InvalidArguments('Argument {!r} in "command" is invalid'.format(c))
          return final_cmd
  
      def process_kwargs(self, kwargs):
          super().process_kwargs(kwargs)
          self.sources = extract_as_list(kwargs, 'input', unholder=True)
          if 'output' not in kwargs:
              raise InvalidArguments('Missing keyword argument "output".')
          self.outputs = listify(kwargs['output'])
          # This will substitute values from the input into output and return it.
          inputs = get_sources_string_names(self.sources)
          values = get_filenames_templates_dict(inputs, [])
          for i in self.outputs:
              if not(isinstance(i, str)):
                  raise InvalidArguments('Output argument not a string.')
              if i == '':
                  raise InvalidArguments('Output must not be empty.')
              if i.strip() == '':
                  raise InvalidArguments('Output must not consist only of whitespace.')
              if has_path_sep(i):
                  raise InvalidArguments('Output must not contain a path segment.')
              if '@INPUT@' in i or '@INPUT0@' in i:
                  m = 'Output cannot contain @INPUT@ or @INPUT0@, did you ' \
                      'mean @PLAINNAME@ or @BASENAME@?'
                  raise InvalidArguments(m)
              # We already check this during substitution, but the error message
              # will be unclear/confusing, so check it here.
              if len(inputs) != 1 and ('@PLAINNAME@' in i or '@BASENAME@' in i):
                  m = "Output cannot contain @PLAINNAME@ or @BASENAME@ when " \
                      "there is more than one input (we can't know which to use)"
                  raise InvalidArguments(m)
          self.outputs = substitute_values(self.outputs, values)
          self.capture = kwargs.get('capture', False)
          if self.capture and len(self.outputs) != 1:
              raise InvalidArguments('Capturing can only output to a single file.')
          if 'command' not in kwargs:
              raise InvalidArguments('Missing keyword argument "command".')
          if 'depfile' in kwargs:
              depfile = kwargs['depfile']
              if not isinstance(depfile, str):
                  raise InvalidArguments('Depfile must be a string.')
              if os.path.basename(depfile) != depfile:
                  raise InvalidArguments('Depfile must be a plain filename without a subdirectory.')
              self.depfile = depfile
          self.command = self.flatten_command(kwargs['command'])
          if self.capture:
              for c in self.command:
                  if isinstance(c, str) and '@OUTPUT@' in c:
                      raise InvalidArguments('@OUTPUT@ is not allowed when capturing output.')
          if 'install' in kwargs:
              self.install = kwargs['install']
              if not isinstance(self.install, bool):
                  raise InvalidArguments('"install" must be boolean.')
              if self.install:
                  if 'install_dir' not in kwargs:
                      raise InvalidArguments('"install_dir" must be specified '
                                             'when installing a target')
  
                  if isinstance(kwargs['install_dir'], list):
                      FeatureNew('multiple install_dir for custom_target', '0.40.0').use()
                  # If an item in this list is False, the output corresponding to
                  # the list index of that item will not be installed
                  self.install_dir = typeslistify(kwargs['install_dir'], (str, bool))
                  self.install_mode = kwargs.get('install_mode', None)
          else:
              self.install = False
              self.install_dir = [None]
              self.install_mode = None
          if 'build_always' in kwargs and 'build_always_stale' in kwargs:
              raise InvalidArguments('build_always and build_always_stale are mutually exclusive. Combine build_by_default and build_always_stale.')
          elif 'build_always' in kwargs:
              mlog.warning('build_always is deprecated. Combine build_by_default and build_always_stale instead.')
              self.build_by_default = kwargs['build_always']
              self.build_always_stale = kwargs['build_always']
          elif 'build_always_stale' in kwargs:
              self.build_always_stale = kwargs['build_always_stale']
          if not isinstance(self.build_always_stale, bool):
              raise InvalidArguments('Argument build_always_stale must be a boolean.')
          extra_deps, depend_files = extract_as_list(kwargs, 'depends', 'depend_files', pop = False)
          for ed in extra_deps:
              while hasattr(ed, 'held_object'):
                  ed = ed.held_object
              if not isinstance(ed, (CustomTarget, BuildTarget)):
                  raise InvalidArguments('Can only depend on toplevel targets: custom_target or build_target (executable or a library)')
              self.extra_depends.append(ed)
          for i in depend_files:
              if isinstance(i, (File, str)):
                  self.depend_files.append(i)
              else:
                  mlog.debug(i)
                  raise InvalidArguments('Unknown type {!r} in depend_files.'.format(type(i).__name__))
  
      def get_dependencies(self):
          return self.dependencies
  
      def should_install(self):
          return self.install
  
      def get_custom_install_dir(self):
          return self.install_dir
  
      def get_custom_install_mode(self):
          return self.install_mode
  
      def get_outputs(self):
          return self.outputs
  
      def get_filename(self):
          return self.outputs[0]
  
      def get_sources(self):
          return self.sources
  
      def get_generated_lists(self):
          genlists = []
          for c in self.sources:
              if hasattr(c, 'held_object'):
                  c = c.held_object
              if isinstance(c, GeneratedList):
                  genlists.append(c)
          return genlists
  
      def get_generated_sources(self):
          return self.get_generated_lists()
  
      def get_dep_outname(self, infilenames):
          if self.depfile is None:
              raise InvalidArguments('Tried to get depfile name for custom_target that does not have depfile defined.')
          if len(infilenames):
              plainname = os.path.basename(infilenames[0])
              basename = os.path.splitext(plainname)[0]
              return self.depfile.replace('@BASENAME@', basename).replace('@PLAINNAME@', plainname)
          else:
              if '@BASENAME@' in self.depfile or '@PLAINNAME@' in self.depfile:
                  raise InvalidArguments('Substitution in depfile for custom_target that does not have an input file.')
              return self.depfile
  
      def type_suffix(self):
          return "@cus"
  
      def __getitem__(self, index):
          return CustomTargetIndex(self, self.outputs[index])
  
      def __setitem__(self, index, value):
          raise NotImplementedError
  
      def __delitem__(self, index):
          raise NotImplementedError
  
  class RunTarget(Target):
      def __init__(self, name, command, args, dependencies, subdir, subproject):
          super().__init__(name, subdir, subproject, False)
          self.command = command
          self.args = args
          self.dependencies = dependencies
  
      def __lt__(self, other):
          return self.get_id() < other.get_id()
  
      def __repr__(self):
          repr_str = "<{0} {1}: {2}>"
          return repr_str.format(self.__class__.__name__, self.get_id(), self.command)
  
      def get_dependencies(self):
          return self.dependencies
  
      def get_generated_sources(self):
          return []
  
      def get_sources(self):
          return []
  
      def should_install(self):
          return False
  
      def get_filename(self):
          return self.name
  
      def type_suffix(self):
          return "@run"
  
  class Jar(BuildTarget):
      known_kwargs = known_jar_kwargs
  
      def __init__(self, name, subdir, subproject, is_cross, sources, objects, environment, kwargs):
          super().__init__(name, subdir, subproject, is_cross, sources, objects, environment, kwargs)
          for s in self.sources:
              if not s.endswith('.java'):
                  raise InvalidArguments('Jar source %s is not a java file.' % s)
          self.filename = self.name + '.jar'
          self.outputs = [self.filename]
          self.java_args = kwargs.get('java_args', [])
  
      def get_main_class(self):
          return self.main_class
  
      def type_suffix(self):
          return "@jar"
  
      def get_java_args(self):
          return self.java_args
  
      def validate_cross_install(self, environment):
          # All jar targets are installable.
          pass
  
  class CustomTargetIndex:
  
      """A special opaque object returned by indexing a CustomTarget. This object
      exists in meson, but acts as a proxy in the backends, making targets depend
      on the CustomTarget it's derived from, but only adding one source file to
      the sources.
      """
  
      def __init__(self, target, output):
          self.target = target
          self.output = output
  
      def __repr__(self):
          return '<CustomTargetIndex: {!r}[{}]>'.format(
              self.target, self.target.get_outputs().index(self.output))
  
      def get_outputs(self):
          return [self.output]
  
      def get_subdir(self):
          return self.target.get_subdir()
  
  
  class ConfigureFile:
  
      def __init__(self, subdir, sourcename, targetname, configuration_data):
          self.subdir = subdir
          self.sourcename = sourcename
          self.targetname = targetname
          self.configuration_data = configuration_data
  
      def __repr__(self):
          repr_str = "<{0}: {1} -> {2}>"
          src = os.path.join(self.subdir, self.sourcename)
          dst = os.path.join(self.subdir, self.targetname)
          return repr_str.format(self.__class__.__name__, src, dst)
  
      def get_configuration_data(self):
          return self.configuration_data
  
      def get_subdir(self):
          return self.subdir
  
      def get_source_name(self):
          return self.sourcename
  
      def get_target_name(self):
          return self.targetname
  
  class ConfigurationData:
      def __init__(self):
          super().__init__()
          self.values = {}
  
      def __repr__(self):
          return repr(self.values)
  
      def __contains__(self, value):
          return value in self.values
  
      def get(self, name):
          return self.values[name] # (val, desc)
  
      def keys(self):
          return self.values.keys()
  
  # A bit poorly named, but this represents plain data files to copy
  # during install.
  class Data:
      def __init__(self, sources, install_dir, install_mode=None, rename=None):
          self.sources = sources
          self.install_dir = install_dir
          self.install_mode = install_mode
          self.sources = listify(self.sources)
          for s in self.sources:
              assert(isinstance(s, File))
          if rename is None:
              self.rename = [os.path.basename(f.fname) for f in self.sources]
          else:
              self.rename = stringlistify(rename)
              if len(self.rename) != len(self.sources):
                  raise MesonException('Size of rename argument is different from number of sources')
  
  class RunScript(dict):
      def __init__(self, script, args):
          super().__init__()
          assert(isinstance(script, list))
          assert(isinstance(args, list))
          self['exe'] = script
          self['args'] = args
  
  class TestSetup:
      def __init__(self, *, exe_wrapper=None, gdb=None, timeout_multiplier=None, env=None):
          self.exe_wrapper = exe_wrapper
          self.gdb = gdb
          self.timeout_multiplier = timeout_multiplier
          self.env = env
  
  def get_sources_string_names(sources):
      '''
      For the specified list of @sources which can be strings, Files, or targets,
      get all the output basenames.
      '''
      names = []
      for s in sources:
          if hasattr(s, 'held_object'):
              s = s.held_object
          if isinstance(s, str):
              names.append(s)
          elif isinstance(s, (BuildTarget, CustomTarget, CustomTargetIndex, GeneratedList)):
              names += s.get_outputs()
          elif isinstance(s, File):
              names.append(s.fname)
          else:
              raise AssertionError('Unknown source type: {!r}'.format(s))
      return names
  
  def load(build_dir):
      filename = os.path.join(build_dir, 'meson-private', 'build.dat')
      load_fail_msg = 'Build data file {!r} is corrupted. Try with a fresh build tree.'.format(filename)
      nonexisting_fail_msg = 'No such build data file as "{!r}".'.format(filename)
      try:
          with open(filename, 'rb') as f:
              obj = pickle.load(f)
      except FileNotFoundError:
          raise MesonException(nonexisting_fail_msg)
      except pickle.UnpicklingError:
          raise MesonException(load_fail_msg)
      if not isinstance(obj, Build):
          raise MesonException(load_fail_msg)
      return obj
  
  def save(obj, filename):
      with open(filename, 'wb') as f:
          pickle.dump(obj, f)
  
files: mesonbuild/build.py
files: # Copyright 2017 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.
  
  # Public symbols for compilers sub-package when using 'from . import compilers'
  __all__ = [
      'CLANG_OSX',
      'CLANG_STANDARD',
      'CLANG_WIN',
      'GCC_CYGWIN',
      'GCC_MINGW',
      'GCC_OSX',
      'GCC_STANDARD',
      'ICC_OSX',
      'ICC_STANDARD',
      'ICC_WIN',
  
      'all_languages',
      'base_options',
      'clib_langs',
      'clink_langs',
      'c_suffixes',
      'cpp_suffixes',
      'get_macos_dylib_install_name',
      'get_base_compile_args',
      'get_base_link_args',
      'is_assembly',
      'is_header',
      'is_library',
      'is_llvm_ir',
      'is_object',
      'is_source',
      'lang_suffixes',
      'sanitizer_compile_args',
      'sort_clink',
  
      'ArmCCompiler',
      'ArmCPPCompiler',
      'CCompiler',
      'ClangCCompiler',
      'ClangCompiler',
      'ClangCPPCompiler',
      'ClangObjCCompiler',
      'ClangObjCPPCompiler',
      'CompilerArgs',
      'CPPCompiler',
      'DCompiler',
      'DmdDCompiler',
      'FortranCompiler',
      'G95FortranCompiler',
      'GnuCCompiler',
      'ElbrusCCompiler',
      'GnuCompiler',
      'GnuCPPCompiler',
      'ElbrusCPPCompiler',
      'GnuDCompiler',
      'GnuFortranCompiler',
      'ElbrusFortranCompiler',
      'GnuObjCCompiler',
      'GnuObjCPPCompiler',
      'IntelCompiler',
      'IntelCCompiler',
      'IntelCPPCompiler',
      'IntelFortranCompiler',
      'JavaCompiler',
      'LLVMDCompiler',
      'MonoCompiler',
      'VisualStudioCsCompiler',
      'NAGFortranCompiler',
      'ObjCCompiler',
      'ObjCPPCompiler',
      'Open64FortranCompiler',
      'PathScaleFortranCompiler',
      'PGIFortranCompiler',
      'RustCompiler',
      'SunFortranCompiler',
      'SwiftCompiler',
      'ValaCompiler',
      'VisualStudioCCompiler',
      'VisualStudioCPPCompiler',
  ]
  
  # Bring symbols from each module into compilers sub-package namespace
  from .compilers import (
      GCC_OSX,
      GCC_MINGW,
      GCC_CYGWIN,
      GCC_STANDARD,
      CLANG_OSX,
      CLANG_WIN,
      CLANG_STANDARD,
      ICC_OSX,
      ICC_WIN,
      ICC_STANDARD,
      all_languages,
      base_options,
      clib_langs,
      clink_langs,
      c_suffixes,
      cpp_suffixes,
      get_macos_dylib_install_name,
      get_base_compile_args,
      get_base_link_args,
      is_header,
      is_source,
      is_assembly,
      is_llvm_ir,
      is_object,
      is_library,
      lang_suffixes,
      sanitizer_compile_args,
      sort_clink,
      ClangCompiler,
      CompilerArgs,
      GnuCompiler,
      IntelCompiler,
  )
  from .c import (
      ArmCCompiler,
      CCompiler,
      ClangCCompiler,
      GnuCCompiler,
      ElbrusCCompiler,
      IntelCCompiler,
      VisualStudioCCompiler,
  )
  from .cpp import (
      ArmCPPCompiler,
      CPPCompiler,
      ClangCPPCompiler,
      GnuCPPCompiler,
      ElbrusCPPCompiler,
      IntelCPPCompiler,
      VisualStudioCPPCompiler,
  )
  from .cs import MonoCompiler, VisualStudioCsCompiler
  from .d import (
      DCompiler,
      DmdDCompiler,
      GnuDCompiler,
      LLVMDCompiler,
  )
  from .fortran import (
      FortranCompiler,
      G95FortranCompiler,
      GnuFortranCompiler,
      ElbrusFortranCompiler,
      IntelFortranCompiler,
      NAGFortranCompiler,
      Open64FortranCompiler,
      PathScaleFortranCompiler,
      PGIFortranCompiler,
      SunFortranCompiler,
  )
  from .java import JavaCompiler
  from .objc import (
      ObjCCompiler,
      ClangObjCCompiler,
      GnuObjCCompiler,
  )
  from .objcpp import (
      ObjCPPCompiler,
      ClangObjCPPCompiler,
      GnuObjCPPCompiler,
  )
  from .rust import RustCompiler
  from .swift import SwiftCompiler
  from .vala import ValaCompiler
  
files: mesonbuild/compilers/__init__.py
files: # Copyright 2017 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.
  
  # Public symbols for compilers sub-package when using 'from . import compilers'
  __all__ = [
      'CLANG_OSX',
      'CLANG_STANDARD',
      'CLANG_WIN',
      'GCC_CYGWIN',
      'GCC_MINGW',
      'GCC_OSX',
      'GCC_STANDARD',
      'ICC_OSX',
      'ICC_STANDARD',
      'ICC_WIN',
  
      'all_languages',
      'base_options',
      'clib_langs',
      'clike_langs',
      'c_suffixes',
      'cpp_suffixes',
      'get_macos_dylib_install_name',
      'get_base_compile_args',
      'get_base_link_args',
      'is_assembly',
      'is_header',
      'is_library',
      'is_llvm_ir',
      'is_object',
      'is_source',
      'lang_suffixes',
      'sanitizer_compile_args',
      'sort_clike',
  
      'ArmCCompiler',
      'ArmCPPCompiler',
      'CCompiler',
      'ClangCCompiler',
      'ClangCompiler',
      'ClangCPPCompiler',
      'ClangObjCCompiler',
      'ClangObjCPPCompiler',
      'CompilerArgs',
      'CPPCompiler',
      'DCompiler',
      'DmdDCompiler',
      'FortranCompiler',
      'G95FortranCompiler',
      'GnuCCompiler',
      'ElbrusCCompiler',
      'GnuCompiler',
      'GnuCPPCompiler',
      'ElbrusCPPCompiler',
      'GnuDCompiler',
      'GnuFortranCompiler',
      'ElbrusFortranCompiler',
      'GnuObjCCompiler',
      'GnuObjCPPCompiler',
      'IntelCompiler',
      'IntelCCompiler',
      'IntelCPPCompiler',
      'IntelFortranCompiler',
      'JavaCompiler',
      'LLVMDCompiler',
      'MonoCompiler',
      'VisualStudioCsCompiler',
      'NAGFortranCompiler',
      'ObjCCompiler',
      'ObjCPPCompiler',
      'Open64FortranCompiler',
      'PathScaleFortranCompiler',
      'PGIFortranCompiler',
      'RustCompiler',
      'SunFortranCompiler',
      'SwiftCompiler',
      'ValaCompiler',
      'VisualStudioCCompiler',
      'VisualStudioCPPCompiler',
  ]
  
  # Bring symbols from each module into compilers sub-package namespace
  from .compilers import (
      GCC_OSX,
      GCC_MINGW,
      GCC_CYGWIN,
      GCC_STANDARD,
      CLANG_OSX,
      CLANG_WIN,
      CLANG_STANDARD,
      ICC_OSX,
      ICC_WIN,
      ICC_STANDARD,
      all_languages,
      base_options,
      clib_langs,
      clike_langs,
      c_suffixes,
      cpp_suffixes,
      get_macos_dylib_install_name,
      get_base_compile_args,
      get_base_link_args,
      is_header,
      is_source,
      is_assembly,
      is_llvm_ir,
      is_object,
      is_library,
      lang_suffixes,
      sanitizer_compile_args,
      sort_clike,
      ClangCompiler,
      CompilerArgs,
      GnuCompiler,
      IntelCompiler,
  )
  from .c import (
      ArmCCompiler,
      CCompiler,
      ClangCCompiler,
      GnuCCompiler,
      ElbrusCCompiler,
      IntelCCompiler,
      VisualStudioCCompiler,
  )
  from .cpp import (
      ArmCPPCompiler,
      CPPCompiler,
      ClangCPPCompiler,
      GnuCPPCompiler,
      ElbrusCPPCompiler,
      IntelCPPCompiler,
      VisualStudioCPPCompiler,
  )
  from .cs import MonoCompiler, VisualStudioCsCompiler
  from .d import (
      DCompiler,
      DmdDCompiler,
      GnuDCompiler,
      LLVMDCompiler,
  )
  from .fortran import (
      FortranCompiler,
      G95FortranCompiler,
      GnuFortranCompiler,
      ElbrusFortranCompiler,
      IntelFortranCompiler,
      NAGFortranCompiler,
      Open64FortranCompiler,
      PathScaleFortranCompiler,
      PGIFortranCompiler,
      SunFortranCompiler,
  )
  from .java import JavaCompiler
  from .objc import (
      ObjCCompiler,
      ClangObjCCompiler,
      GnuObjCCompiler,
  )
  from .objcpp import (
      ObjCPPCompiler,
      ClangObjCPPCompiler,
      GnuObjCPPCompiler,
  )
  from .rust import RustCompiler
  from .swift import SwiftCompiler
  from .vala import ValaCompiler
  
files: mesonbuild/compilers/__init__.py
files: # Copyright 2012-2017 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 contextlib, os.path, re, tempfile, shlex
  import subprocess
  
  from ..linkers import StaticLinker
  from .. import coredata
  from .. import mlog
  from .. import mesonlib
  from ..mesonlib import EnvironmentException, MesonException, version_compare, Popen_safe
  
  """This file contains the data files of all compilers Meson knows
  about. To support a new compiler, add its information below.
  Also add corresponding autodetection code in environment.py."""
  
  header_suffixes = ('h', 'hh', 'hpp', 'hxx', 'H', 'ipp', 'moc', 'vapi', 'di')
  obj_suffixes = ('o', 'obj', 'res')
  lib_suffixes = ('a', 'lib', 'dll', 'dylib', 'so')
  # Mapping of language to suffixes of files that should always be in that language
  # This means we can't include .h headers here since they could be C, C++, ObjC, etc.
  lang_suffixes = {
      'c': ('c',),
      'cpp': ('cpp', 'cc', 'cxx', 'c++', 'hh', 'hpp', 'ipp', 'hxx'),
      # f90, f95, f03, f08 are for free-form fortran ('f90' recommended)
      # f, for, ftn, fpp are for fixed-form fortran ('f' or 'for' recommended)
      'fortran': ('f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp'),
      'd': ('d', 'di'),
      'objc': ('m',),
      'objcpp': ('mm',),
      'rust': ('rs',),
      'vala': ('vala', 'vapi', 'gs'),
      'cs': ('cs',),
      'swift': ('swift',),
      'java': ('java',),
  }
  all_languages = lang_suffixes.keys()
  cpp_suffixes = lang_suffixes['cpp'] + ('h',)
  c_suffixes = lang_suffixes['c'] + ('h',)
  # List of languages that by default consume and output libraries following the
  # C ABI; these can generally be used interchangebly
  clib_langs = ('objcpp', 'cpp', 'objc', 'c', 'fortran',)
  # List of languages that can be linked with C code directly by the linker
  # used in build.py:process_compilers() and build.py:get_dynamic_linker()
  # XXX: Add Rust to this?
  clink_langs = ('d',) + clib_langs
  clink_suffixes = ()
  for _l in clink_langs + ('vala',):
      clink_suffixes += lang_suffixes[_l]
  clink_suffixes += ('h', 'll', 's')
  
  soregex = re.compile(r'.*\.so(\.[0-9]+)?(\.[0-9]+)?(\.[0-9]+)?$')
  
  # Environment variables that each lang uses.
  cflags_mapping = {'c': 'CFLAGS',
                    'cpp': 'CXXFLAGS',
                    'objc': 'OBJCFLAGS',
                    'objcpp': 'OBJCXXFLAGS',
                    'fortran': 'FFLAGS',
                    'd': 'DFLAGS',
                    'vala': 'VALAFLAGS',
                    'rust': 'RUSTFLAGS'}
  
  # All these are only for C-linkable languages; see `clink_langs` above.
  
  def sort_clink(lang):
      '''
      Sorting function to sort the list of languages according to
      reversed(compilers.clink_langs) and append the unknown langs in the end.
      The purpose is to prefer C over C++ for files that can be compiled by
      both such as assembly, C, etc. Also applies to ObjC, ObjC++, etc.
      '''
      if lang not in clink_langs:
          return 1
      return -clink_langs.index(lang)
  
  def is_header(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      suffix = fname.split('.')[-1]
      return suffix in header_suffixes
  
  def is_source(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      suffix = fname.split('.')[-1].lower()
      return suffix in clink_suffixes
  
  def is_assembly(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      return fname.split('.')[-1].lower() == 's'
  
  def is_llvm_ir(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      return fname.split('.')[-1] == 'll'
  
  def is_object(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      suffix = fname.split('.')[-1]
      return suffix in obj_suffixes
  
  def is_library(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
  
      if soregex.match(fname):
          return True
  
      suffix = fname.split('.')[-1]
      return suffix in lib_suffixes
  
  gnulike_buildtype_args = {'plain': [],
                            # -O0 is passed for improved debugging information with gcc
                            # See https://github.com/mesonbuild/meson/pull/509
                            'debug': ['-O0', '-g'],
                            'debugoptimized': ['-O2', '-g'],
                            'release': ['-O3'],
                            'minsize': ['-Os', '-g']}
  
  arm_buildtype_args = {'plain': [],
                        'debug': ['-O0', '--debug'],
                        'debugoptimized': ['-O1', '--debug'],
                        'release': ['-O3', '-Otime'],
                        'minsize': ['-O3', '-Ospace'],
                        }
  
  msvc_buildtype_args = {'plain': [],
                         'debug': ["/MDd", "/ZI", "/Ob0", "/Od", "/RTC1"],
                         'debugoptimized': ["/MD", "/Zi", "/O2", "/Ob1"],
                         'release': ["/MD", "/O2", "/Ob2"],
                         'minsize': ["/MD", "/Zi", "/Os", "/Ob1"],
                         }
  
  apple_buildtype_linker_args = {'plain': [],
                                 'debug': [],
                                 'debugoptimized': [],
                                 'release': [],
                                 'minsize': [],
                                 }
  
  gnulike_buildtype_linker_args = {'plain': [],
                                   'debug': [],
                                   'debugoptimized': [],
                                   'release': ['-Wl,-O1'],
                                   'minsize': [],
                                   }
  
  arm_buildtype_linker_args = {'plain': [],
                               'debug': [],
                               'debugoptimized': [],
                               'release': [],
                               'minsize': [],
                               }
  
  msvc_buildtype_linker_args = {'plain': [],
                                'debug': [],
                                'debugoptimized': [],
                                # The otherwise implicit REF and ICF linker
                                # optimisations are disabled by /DEBUG.
                                # REF implies ICF.
                                'release': ['/OPT:REF'],
                                'minsize': ['/INCREMENTAL:NO', '/OPT:REF'],
                                }
  
  java_buildtype_args = {'plain': [],
                         'debug': ['-g'],
                         'debugoptimized': ['-g'],
                         'release': [],
                         'minsize': [],
                         }
  
  rust_buildtype_args = {'plain': [],
                         'debug': ['-C', 'debuginfo=2'],
                         'debugoptimized': ['-C', 'debuginfo=2', '-C', 'opt-level=2'],
                         'release': ['-C', 'opt-level=3'],
                         'minsize': [], # In a future release: ['-C', 'opt-level=s'],
                         }
  
  d_gdc_buildtype_args = {'plain': [],
                          'debug': ['-g', '-O0'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O3', '-frelease'],
                          'minsize': [],
                          }
  
  d_ldc_buildtype_args = {'plain': [],
                          'debug': ['-g', '-O0'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O3', '-release'],
                          'minsize': [],
                          }
  
  d_dmd_buildtype_args = {'plain': [],
                          'debug': ['-g'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O', '-release'],
                          'minsize': [],
                          }
  
  mono_buildtype_args = {'plain': [],
                         'debug': ['-debug'],
                         'debugoptimized': ['-debug', '-optimize+'],
                         'release': ['-optimize+'],
                         'minsize': [],
                         }
  
  swift_buildtype_args = {'plain': [],
                          'debug': ['-g'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O'],
                          'minsize': [],
                          }
  
  gnu_winlibs = ['-lkernel32', '-luser32', '-lgdi32', '-lwinspool', '-lshell32',
                 '-lole32', '-loleaut32', '-luuid', '-lcomdlg32', '-ladvapi32']
  
  msvc_winlibs = ['kernel32.lib', 'user32.lib', 'gdi32.lib',
                  'winspool.lib', 'shell32.lib', 'ole32.lib', 'oleaut32.lib',
                  'uuid.lib', 'comdlg32.lib', 'advapi32.lib']
  
  gnu_color_args = {'auto': ['-fdiagnostics-color=auto'],
                    'always': ['-fdiagnostics-color=always'],
                    'never': ['-fdiagnostics-color=never'],
                    }
  
  clang_color_args = {'auto': ['-Xclang', '-fcolor-diagnostics'],
                      'always': ['-Xclang', '-fcolor-diagnostics'],
                      'never': ['-Xclang', '-fno-color-diagnostics'],
                      }
  
  base_options = {'b_pch': coredata.UserBooleanOption('b_pch', 'Use precompiled headers', True),
                  'b_lto': coredata.UserBooleanOption('b_lto', 'Use link time optimization', False),
                  'b_sanitize': coredata.UserComboOption('b_sanitize',
                                                         'Code sanitizer to use',
                                                         ['none', 'address', 'thread', 'undefined', 'memory', 'address,undefined'],
                                                         'none'),
                  'b_lundef': coredata.UserBooleanOption('b_lundef', 'Use -Wl,--no-undefined when linking', True),
                  'b_asneeded': coredata.UserBooleanOption('b_asneeded', 'Use -Wl,--as-needed when linking', True),
                  'b_pgo': coredata.UserComboOption('b_pgo', 'Use profile guided optimization',
                                                    ['off', 'generate', 'use'],
                                                    'off'),
                  'b_coverage': coredata.UserBooleanOption('b_coverage',
                                                           'Enable coverage tracking.',
                                                           False),
                  'b_colorout': coredata.UserComboOption('b_colorout', 'Use colored output',
                                                         ['auto', 'always', 'never'],
                                                         'always'),
                  'b_ndebug': coredata.UserComboOption('b_ndebug', 'Disable asserts',
                                                       ['true', 'false', 'if-release'], 'false'),
                  'b_staticpic': coredata.UserBooleanOption('b_staticpic',
                                                            'Build static libraries as position independent',
                                                            True),
                  'b_bitcode': coredata.UserBooleanOption('b_bitcode',
                                                          'Generate and embed bitcode (only macOS and iOS)',
                                                          False),
                  }
  
  gnulike_instruction_set_args = {'mmx': ['-mmmx'],
                                  'sse': ['-msse'],
                                  'sse2': ['-msse2'],
                                  'sse3': ['-msse3'],
                                  'ssse3': ['-mssse3'],
                                  'sse41': ['-msse4.1'],
                                  'sse42': ['-msse4.2'],
                                  'avx': ['-mavx'],
                                  'avx2': ['-mavx2'],
                                  'neon': ['-mfpu=neon'],
                                  }
  
  vs32_instruction_set_args = {'mmx': ['/arch:SSE'], # There does not seem to be a flag just for MMX
                               'sse': ['/arch:SSE'],
                               'sse2': ['/arch:SSE2'],
                               'sse3': ['/arch:AVX'], # VS leaped from SSE2 directly to AVX.
                               'sse41': ['/arch:AVX'],
                               'sse42': ['/arch:AVX'],
                               'avx': ['/arch:AVX'],
                               'avx2': ['/arch:AVX2'],
                               'neon': None,
                               }
  
  # The 64 bit compiler defaults to /arch:avx.
  vs64_instruction_set_args = {'mmx': ['/arch:AVX'],
                               'sse': ['/arch:AVX'],
                               'sse2': ['/arch:AVX'],
                               'sse3': ['/arch:AVX'],
                               'ssse3': ['/arch:AVX'],
                               'sse41': ['/arch:AVX'],
                               'sse42': ['/arch:AVX'],
                               'avx': ['/arch:AVX'],
                               'avx2': ['/arch:AVX2'],
                               'neon': None,
                               }
  
  def sanitizer_compile_args(value):
      if value == 'none':
          return []
      args = ['-fsanitize=' + value]
      if 'address' in value: # For -fsanitize=address,undefined
          args.append('-fno-omit-frame-pointer')
      return args
  
  def sanitizer_link_args(value):
      if value == 'none':
          return []
      args = ['-fsanitize=' + value]
      return args
  
  def option_enabled(boptions, options, option):
      try:
          if option not in boptions:
              return False
          return options[option].value
      except KeyError:
          return False
  
  def get_base_compile_args(options, compiler):
      args = []
      # FIXME, gcc/clang specific.
      try:
          if options['b_lto'].value:
              args.append('-flto')
      except KeyError:
          pass
      try:
          args += compiler.get_colorout_args(options['b_colorout'].value)
      except KeyError:
          pass
      try:
          args += sanitizer_compile_args(options['b_sanitize'].value)
      except KeyError:
          pass
      try:
          pgo_val = options['b_pgo'].value
          if pgo_val == 'generate':
              args.append('-fprofile-generate')
          elif pgo_val == 'use':
              args.append('-fprofile-use')
      except KeyError:
          pass
      try:
          if options['b_coverage'].value:
              args += compiler.get_coverage_args()
      except KeyError:
          pass
      try:
          if (options['b_ndebug'].value == 'true' or
                  (options['b_ndebug'].value == 'if-release' and
                   options['buildtype'].value == 'release')):
              args += ['-DNDEBUG']
      except KeyError:
          pass
      # This does not need a try...except
      if option_enabled(compiler.base_options, options, 'b_bitcode'):
          args.append('-fembed-bitcode')
      return args
  
  def get_base_link_args(options, linker, is_shared_module):
      args = []
      # FIXME, gcc/clang specific.
      try:
          if options['b_lto'].value:
              args.append('-flto')
      except KeyError:
          pass
      try:
          args += sanitizer_link_args(options['b_sanitize'].value)
      except KeyError:
          pass
      try:
          pgo_val = options['b_pgo'].value
          if pgo_val == 'generate':
              args.append('-fprofile-generate')
          elif pgo_val == 'use':
              args.append('-fprofile-use')
      except KeyError:
          pass
      try:
          if options['b_coverage'].value:
              args += linker.get_coverage_link_args()
      except KeyError:
          pass
      # These do not need a try...except
      if not is_shared_module and option_enabled(linker.base_options, options, 'b_lundef'):
          args.append('-Wl,--no-undefined')
      as_needed = option_enabled(linker.base_options, options, 'b_asneeded')
      bitcode = option_enabled(linker.base_options, options, 'b_bitcode')
      # Shared modules cannot be built with bitcode_bundle because
      # -bitcode_bundle is incompatible with -undefined and -bundle
      if bitcode and not is_shared_module:
          args.append('-Wl,-bitcode_bundle')
      elif as_needed:
          # -Wl,-dead_strip_dylibs is incompatible with bitcode
          args.append(linker.get_asneeded_args())
      return args
  
  class CrossNoRunException(MesonException):
      pass
  
  class RunResult:
      def __init__(self, compiled, returncode=999, stdout='UNDEFINED', stderr='UNDEFINED'):
          self.compiled = compiled
          self.returncode = returncode
          self.stdout = stdout
          self.stderr = stderr
  
  class CompilerArgs(list):
      '''
      Class derived from list() that manages a list of compiler arguments. Should
      be used while constructing compiler arguments from various sources. Can be
      operated with ordinary lists, so this does not need to be used everywhere.
  
      All arguments must be inserted and stored in GCC-style (-lfoo, -Idir, etc)
      and can converted to the native type of each compiler by using the
      .to_native() method to which you must pass an instance of the compiler or
      the compiler class.
  
      New arguments added to this class (either with .append(), .extend(), or +=)
      are added in a way that ensures that they override previous arguments.
      For example:
  
      >>> a = ['-Lfoo', '-lbar']
      >>> a += ['-Lpho', '-lbaz']
      >>> print(a)
      ['-Lpho', '-Lfoo', '-lbar', '-lbaz']
  
      Arguments will also be de-duped if they can be de-duped safely.
  
      Note that because of all this, this class is not commutative and does not
      preserve the order of arguments if it is safe to not. For example:
      >>> ['-Ifoo', '-Ibar'] + ['-Ifez', '-Ibaz', '-Werror']
      ['-Ifez', '-Ibaz', '-Ifoo', '-Ibar', '-Werror']
      >>> ['-Ifez', '-Ibaz', '-Werror'] + ['-Ifoo', '-Ibar']
      ['-Ifoo', '-Ibar', '-Ifez', '-Ibaz', '-Werror']
  
      '''
      # NOTE: currently this class is only for C-like compilers, but it can be
      # extended to other languages easily. Just move the following to the
      # compiler class and initialize when self.compiler is set.
  
      # Arg prefixes that override by prepending instead of appending
      prepend_prefixes = ('-I', '-L')
      # Arg prefixes and args that must be de-duped by returning 2
      dedup2_prefixes = ('-I', '-L', '-D', '-U')
      dedup2_suffixes = ()
      dedup2_args = ()
      # Arg prefixes and args that must be de-duped by returning 1
      dedup1_prefixes = ('-l',)
      dedup1_suffixes = ('.lib', '.dll', '.so', '.dylib', '.a')
      # Match a .so of the form path/to/libfoo.so.0.1.0
      # Only UNIX shared libraries require this. Others have a fixed extension.
      dedup1_regex = re.compile(r'([\/\\]|\A)lib.*\.so(\.[0-9]+)?(\.[0-9]+)?(\.[0-9]+)?$')
      dedup1_args = ('-c', '-S', '-E', '-pipe', '-pthread')
      compiler = None
  
      def _check_args(self, args):
          cargs = []
          if len(args) > 2:
              raise TypeError("CompilerArgs() only accepts at most 2 arguments: "
                              "The compiler, and optionally an initial list")
          elif not args:
              return cargs
          elif len(args) == 1:
              if isinstance(args[0], (Compiler, StaticLinker)):
                  self.compiler = args[0]
              else:
                  raise TypeError("you must pass a Compiler instance as one of "
                                  "the arguments")
          elif len(args) == 2:
              if isinstance(args[0], (Compiler, StaticLinker)):
                  self.compiler = args[0]
                  cargs = args[1]
              elif isinstance(args[1], (Compiler, StaticLinker)):
                  cargs = args[0]
                  self.compiler = args[1]
              else:
                  raise TypeError("you must pass a Compiler instance as one of "
                                  "the two arguments")
          else:
              raise AssertionError('Not reached')
          return cargs
  
      def __init__(self, *args):
          super().__init__(self._check_args(args))
  
      @classmethod
      def _can_dedup(cls, arg):
          '''
          Returns whether the argument can be safely de-duped. This is dependent
          on three things:
  
          a) Whether an argument can be 'overridden' by a later argument.  For
             example, -DFOO defines FOO and -UFOO undefines FOO. In this case, we
             can safely remove the previous occurrence and add a new one. The same
             is true for include paths and library paths with -I and -L. For
             these we return `2`. See `dedup2_prefixes` and `dedup2_args`.
          b) Arguments that once specified cannot be undone, such as `-c` or
             `-pipe`. New instances of these can be completely skipped. For these
             we return `1`. See `dedup1_prefixes` and `dedup1_args`.
          c) Whether it matters where or how many times on the command-line
             a particular argument is present. This can matter for symbol
             resolution in static or shared libraries, so we cannot de-dup or
             reorder them. For these we return `0`. This is the default.
  
          In addition to these, we handle library arguments specially.
          With GNU ld, we surround library arguments with -Wl,--start/end-group
          to recursively search for symbols in the libraries. This is not needed
          with other linkers.
          '''
  
          # A standalone argument must never be deduplicated because it is
          # defined by what comes _after_ it. Thus dedupping this:
          # -D FOO -D BAR
          # would yield either
          # -D FOO BAR
          # or
          # FOO -D BAR
          # both of which are invalid.
          if arg in cls.dedup2_prefixes:
              return 0
          if arg in cls.dedup2_args or \
             arg.startswith(cls.dedup2_prefixes) or \
             arg.endswith(cls.dedup2_suffixes):
              return 2
          if arg in cls.dedup1_args or \
             arg.startswith(cls.dedup1_prefixes) or \
             arg.endswith(cls.dedup1_suffixes) or \
             re.search(cls.dedup1_regex, arg):
              return 1
          return 0
  
      @classmethod
      def _should_prepend(cls, arg):
          if arg.startswith(cls.prepend_prefixes):
              return True
          return False
  
      def to_native(self):
          # Check if we need to add --start/end-group for circular dependencies
          # between static libraries, and for recursively searching for symbols
          # needed by static libraries that are provided by object files or
          # shared libraries.
          if get_compiler_uses_gnuld(self.compiler):
              global soregex
              group_start = -1
              for each in self:
                  if not each.startswith('-l') and not each.endswith('.a') and \
                     not soregex.match(each):
                      continue
                  i = self.index(each)
                  if group_start < 0:
                      # First occurrence of a library
                      group_start = i
              if group_start >= 0:
                  # Last occurrence of a library
                  self.insert(i + 1, '-Wl,--end-group')
                  self.insert(group_start, '-Wl,--start-group')
          return self.compiler.unix_args_to_native(self)
  
      def append_direct(self, arg):
          '''
          Append the specified argument without any reordering or de-dup
          except for absolute paths where the order of include search directories
          is not relevant
          '''
          if os.path.isabs(arg):
              self.append(arg)
          else:
              super().append(arg)
  
      def extend_direct(self, iterable):
          '''
          Extend using the elements in the specified iterable without any
          reordering or de-dup except for absolute paths where the order of
          include search directories is not relevant
          '''
          for elem in iterable:
              self.append_direct(elem)
  
      def __add__(self, args):
          new = CompilerArgs(self, self.compiler)
          new += args
          return new
  
      def __iadd__(self, args):
          '''
          Add two CompilerArgs while taking into account overriding of arguments
          and while preserving the order of arguments as much as possible
          '''
          pre = []
          post = []
          if not isinstance(args, list):
              raise TypeError('can only concatenate list (not "{}") to list'.format(args))
          for arg in args:
              # If the argument can be de-duped, do it either by removing the
              # previous occurrence of it and adding a new one, or not adding the
              # new occurrence.
              dedup = self._can_dedup(arg)
              if dedup == 1:
                  # Argument already exists and adding a new instance is useless
                  if arg in self or arg in pre or arg in post:
                      continue
              if dedup == 2:
                  # Remove all previous occurrences of the arg and add it anew
                  if arg in self:
                      self.remove(arg)
                  if arg in pre:
                      pre.remove(arg)
                  if arg in post:
                      post.remove(arg)
              if self._should_prepend(arg):
                  pre.append(arg)
              else:
                  post.append(arg)
          # Insert at the beginning
          self[:0] = pre
          # Append to the end
          super().__iadd__(post)
          return self
  
      def __radd__(self, args):
          new = CompilerArgs(args, self.compiler)
          new += self
          return new
  
      def __mul__(self, args):
          raise TypeError("can't multiply compiler arguments")
  
      def __imul__(self, args):
          raise TypeError("can't multiply compiler arguments")
  
      def __rmul__(self, args):
          raise TypeError("can't multiply compiler arguments")
  
      def append(self, arg):
          self.__iadd__([arg])
  
      def extend(self, args):
          self.__iadd__(args)
  
  class Compiler:
      # Libraries to ignore in find_library() since they are provided by the
      # compiler or the C library. Currently only used for MSVC.
      ignore_libs = ()
      # Cache for the result of compiler checks which can be cached
      compiler_check_cache = {}
  
      def __init__(self, exelist, version, **kwargs):
          if isinstance(exelist, str):
              self.exelist = [exelist]
          elif isinstance(exelist, list):
              self.exelist = exelist
          else:
              raise TypeError('Unknown argument to Compiler')
          # In case it's been overridden by a child class already
          if not hasattr(self, 'file_suffixes'):
              self.file_suffixes = lang_suffixes[self.language]
          if not hasattr(self, 'can_compile_suffixes'):
              self.can_compile_suffixes = set(self.file_suffixes)
          self.default_suffix = self.file_suffixes[0]
          self.version = version
          if 'full_version' in kwargs:
              self.full_version = kwargs['full_version']
          else:
              self.full_version = None
          self.base_options = []
  
      def __repr__(self):
          repr_str = "<{0}: v{1} `{2}`>"
          return repr_str.format(self.__class__.__name__, self.version,
                                 ' '.join(self.exelist))
  
      def can_compile(self, src):
          if hasattr(src, 'fname'):
              src = src.fname
          suffix = os.path.splitext(src)[1].lower()
          if suffix and suffix[1:] in self.can_compile_suffixes:
              return True
          return False
  
      def get_id(self):
          return self.id
  
      def get_language(self):
          return self.language
  
      def get_display_language(self):
          return self.language.capitalize()
  
      def get_default_suffix(self):
          return self.default_suffix
  
      def get_define(self, dname, prefix, env, extra_args, dependencies):
          raise EnvironmentException('%s does not support get_define ' % self.get_id())
  
      def compute_int(self, expression, low, high, guess, prefix, env, extra_args, dependencies):
          raise EnvironmentException('%s does not support compute_int ' % self.get_id())
  
      def has_members(self, typename, membernames, prefix, env, extra_args=None, dependencies=None):
          raise EnvironmentException('%s does not support has_member(s) ' % self.get_id())
  
      def has_type(self, typename, prefix, env, extra_args, dependencies=None):
          raise EnvironmentException('%s does not support has_type ' % self.get_id())
  
      def symbols_have_underscore_prefix(self, env):
          raise EnvironmentException('%s does not support symbols_have_underscore_prefix ' % self.get_id())
  
      def get_exelist(self):
          return self.exelist[:]
  
      def get_builtin_define(self, *args, **kwargs):
          raise EnvironmentException('%s does not support get_builtin_define.' % self.id)
  
      def has_builtin_define(self, *args, **kwargs):
          raise EnvironmentException('%s does not support has_builtin_define.' % self.id)
  
      def get_always_args(self):
          return []
  
      def can_linker_accept_rsp(self):
          """
          Determines whether the linker can accept arguments using the @rsp syntax.
          """
          return mesonlib.is_windows()
  
      def get_linker_always_args(self):
          return []
  
      def gen_import_library_args(self, implibname):
          """
          Used only on Windows for libraries that need an import library.
          This currently means C, C++, Fortran.
          """
          return []
  
      def get_preproc_flags(self):
          if self.get_language() in ('c', 'cpp', 'objc', 'objcpp'):
              return os.environ.get('CPPFLAGS', '')
          return ''
  
      def get_args_from_envvars(self):
          """
          Returns a tuple of (compile_flags, link_flags) for the specified language
          from the inherited environment
          """
          def log_var(var, val):
              if val:
                  mlog.log('Appending {} from environment: {!r}'.format(var, val))
  
          lang = self.get_language()
          compiler_is_linker = False
          if hasattr(self, 'get_linker_exelist'):
              compiler_is_linker = (self.get_exelist() == self.get_linker_exelist())
  
          if lang not in cflags_mapping:
              return [], []
  
          compile_flags = os.environ.get(cflags_mapping[lang], '')
          log_var(cflags_mapping[lang], compile_flags)
          compile_flags = shlex.split(compile_flags)
  
          # Link flags (same for all languages)
          link_flags = os.environ.get('LDFLAGS', '')
          log_var('LDFLAGS', link_flags)
          link_flags = shlex.split(link_flags)
          if compiler_is_linker:
              # When the compiler is used as a wrapper around the linker (such as
              # with GCC and Clang), the compile flags can be needed while linking
              # too. This is also what Autotools does. However, we don't want to do
              # this when the linker is stand-alone such as with MSVC C/C++, etc.
              link_flags = compile_flags + link_flags
  
          # Pre-processor flags (not for fortran or D)
          preproc_flags = self.get_preproc_flags()
          log_var('CPPFLAGS', preproc_flags)
          preproc_flags = shlex.split(preproc_flags)
          compile_flags += preproc_flags
  
          return compile_flags, link_flags
  
      def get_options(self):
          opts = {} # build afresh every time
  
          # Take default values from env variables.
          compile_args, link_args = self.get_args_from_envvars()
          description = 'Extra arguments passed to the {}'.format(self.get_display_language())
          opts.update({
              self.language + '_args': coredata.UserArrayOption(
                  self.language + '_args',
                  description + ' compiler',
                  compile_args, shlex_split=True, user_input=True),
              self.language + '_link_args': coredata.UserArrayOption(
                  self.language + '_link_args',
                  description + ' linker',
                  link_args, shlex_split=True, user_input=True),
          })
  
          return opts
  
      def get_option_compile_args(self, options):
          return []
  
      def get_option_link_args(self, options):
          return []
  
      def check_header(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support header checks.' % self.get_display_language())
  
      def has_header(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support header checks.' % self.get_display_language())
  
      def has_header_symbol(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support header symbol checks.' % self.get_display_language())
  
      def compiles(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support compile checks.' % self.get_display_language())
  
      def links(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support link checks.' % self.get_display_language())
  
      def run(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support run checks.' % self.get_display_language())
  
      def sizeof(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support sizeof checks.' % self.get_display_language())
  
      def alignment(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support alignment checks.' % self.get_display_language())
  
      def has_function(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support function checks.' % self.get_display_language())
  
      @classmethod
      def unix_args_to_native(cls, args):
          "Always returns a copy that can be independently mutated"
          return args[:]
  
      def find_library(self, *args, **kwargs):
          raise EnvironmentException('Language {} does not support library finding.'.format(self.get_display_language()))
  
      def get_library_dirs(self):
          return []
  
      def has_multi_arguments(self, args, env):
          raise EnvironmentException(
              'Language {} does not support has_multi_arguments.'.format(
                  self.get_display_language()))
  
      def has_multi_link_arguments(self, args, env):
          raise EnvironmentException(
              'Language {} does not support has_multi_link_arguments.'.format(
                  self.get_display_language()))
  
      def get_cross_extra_flags(self, environment, link):
          extra_flags = []
          if self.is_cross and environment:
              if 'properties' in environment.cross_info.config:
                  props = environment.cross_info.config['properties']
                  lang_args_key = self.language + '_args'
                  extra_flags += props.get(lang_args_key, [])
                  lang_link_args_key = self.language + '_link_args'
                  if link:
                      extra_flags += props.get(lang_link_args_key, [])
          return extra_flags
  
      def _get_compile_output(self, dirname, mode):
          # In pre-processor mode, the output is sent to stdout and discarded
          if mode == 'preprocess':
              return None
          # Extension only matters if running results; '.exe' is
          # guaranteed to be executable on every platform.
          if mode == 'link':
              suffix = 'exe'
          else:
              suffix = 'obj'
          return os.path.join(dirname, 'output.' + suffix)
  
      @contextlib.contextmanager
      def compile(self, code, extra_args=None, mode='link', want_output=False):
          if extra_args is None:
              textra_args = None
              extra_args = []
          else:
              textra_args = tuple(extra_args)
          key = (code, textra_args, mode)
          if not want_output:
              if key in self.compiler_check_cache:
                  p = self.compiler_check_cache[key]
                  mlog.debug('Using cached compile:')
                  mlog.debug('Cached command line: ', ' '.join(p.commands), '\n')
                  mlog.debug('Code:\n', code)
                  mlog.debug('Cached compiler stdout:\n', p.stdo)
                  mlog.debug('Cached compiler stderr:\n', p.stde)
                  yield p
                  return
          try:
              with tempfile.TemporaryDirectory() as tmpdirname:
                  if isinstance(code, str):
                      srcname = os.path.join(tmpdirname,
                                             'testfile.' + self.default_suffix)
                      with open(srcname, 'w') as ofile:
                          ofile.write(code)
                  elif isinstance(code, mesonlib.File):
                      srcname = code.fname
  
                  # Construct the compiler command-line
                  commands = CompilerArgs(self)
                  commands.append(srcname)
                  commands += self.get_always_args()
                  if mode == 'compile':
                      commands += self.get_compile_only_args()
                  # Preprocess mode outputs to stdout, so no output args
                  if mode == 'preprocess':
                      commands += self.get_preprocess_only_args()
                  else:
                      output = self._get_compile_output(tmpdirname, mode)
                      commands += self.get_output_args(output)
                  # extra_args must be last because it could contain '/link' to
                  # pass args to VisualStudio's linker. In that case everything
                  # in the command line after '/link' is given to the linker.
                  commands += extra_args
                  # Generate full command-line with the exelist
                  commands = self.get_exelist() + commands.to_native()
                  mlog.debug('Running compile:')
                  mlog.debug('Working directory: ', tmpdirname)
                  mlog.debug('Command line: ', ' '.join(commands), '\n')
                  mlog.debug('Code:\n', code)
                  p, p.stdo, p.stde = Popen_safe(commands, cwd=tmpdirname)
                  mlog.debug('Compiler stdout:\n', p.stdo)
                  mlog.debug('Compiler stderr:\n', p.stde)
                  p.commands = commands
                  p.input_name = srcname
                  if want_output:
                      p.output_name = output
                  else:
                      self.compiler_check_cache[key] = p
                  yield p
          except (PermissionError, OSError):
              # On Windows antivirus programs and the like hold on to files so
              # they can't be deleted. There's not much to do in this case. Also,
              # catch OSError because the directory is then no longer empty.
              pass
  
      def get_colorout_args(self, colortype):
          return []
  
      # Some compilers (msvc) write debug info to a separate file.
      # These args specify where it should be written.
      def get_compile_debugfile_args(self, rel_obj, **kwargs):
          return []
  
      def get_link_debugfile_args(self, rel_obj):
          return []
  
      def get_std_shared_lib_link_args(self):
          return []
  
      def get_std_shared_module_link_args(self, options):
          return self.get_std_shared_lib_link_args()
  
      def get_link_whole_for(self, args):
          if isinstance(args, list) and not args:
              return []
          raise EnvironmentException('Language %s does not support linking whole archives.' % self.get_display_language())
  
      # Compiler arguments needed to enable the given instruction set.
      # May be [] meaning nothing needed or None meaning the given set
      # is not supported.
      def get_instruction_set_args(self, instruction_set):
          return None
  
      def build_osx_rpath_args(self, build_dir, rpath_paths, build_rpath):
          if not rpath_paths and not build_rpath:
              return []
          # On OSX, rpaths must be absolute.
          abs_rpaths = [os.path.join(build_dir, p) for p in rpath_paths]
          if build_rpath != '':
              abs_rpaths.append(build_rpath)
          # Ensure that there is enough space for large RPATHs
          args = ['-Wl,-headerpad_max_install_names']
          args += ['-Wl,-rpath,' + rp for rp in abs_rpaths]
          return args
  
      def build_unix_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
          if not rpath_paths and not install_rpath and not build_rpath:
              return []
          # The rpaths we write must be relative, because otherwise
          # they have different length depending on the build
          # directory. This breaks reproducible builds.
          rel_rpaths = []
          for p in rpath_paths:
              if p == from_dir:
                  relative = '' # relpath errors out in this case
              else:
                  relative = os.path.relpath(os.path.join(build_dir, p), os.path.join(build_dir, from_dir))
              rel_rpaths.append(relative)
          paths = ':'.join([os.path.join('$ORIGIN', p) for p in rel_rpaths])
          # Build_rpath is used as-is (it is usually absolute).
          if build_rpath != '':
              if paths != '':
                  paths += ':'
              paths += build_rpath
          if len(paths) < len(install_rpath):
              padding = 'X' * (len(install_rpath) - len(paths))
              if not paths:
                  paths = padding
              else:
                  paths = paths + ':' + padding
          args = []
          if mesonlib.is_dragonflybsd() or mesonlib.is_openbsd():
              # This argument instructs the compiler to record the value of
              # ORIGIN in the .dynamic section of the elf. On Linux this is done
              # by default, but is not on dragonfly/openbsd for some reason. Without this
              # $ORIGIN in the runtime path will be undefined and any binaries
              # linked against local libraries will fail to resolve them.
              args.append('-Wl,-z,origin')
          args.append('-Wl,-rpath,' + paths)
          if get_compiler_is_linuxlike(self):
              # Rpaths to use while linking must be absolute. These are not
              # written to the binary. Needed only with GNU ld:
              # https://sourceware.org/bugzilla/show_bug.cgi?id=16936
              # Not needed on Windows or other platforms that don't use RPATH
              # https://github.com/mesonbuild/meson/issues/1897
              lpaths = ':'.join([os.path.join(build_dir, p) for p in rpath_paths])
  
              # clang expands '-Wl,rpath-link,' to ['-rpath-link'] instead of ['-rpath-link','']
              # This eats the next argument, which happens to be 'ldstdc++', causing link failures.
              # We can dodge this problem by not adding any rpath_paths if the argument is empty.
              if lpaths.strip() != '':
                  args += ['-Wl,-rpath-link,' + lpaths]
          return args
  
      def thread_flags(self, env):
          return []
  
      def openmp_flags(self):
          raise EnvironmentException('Language %s does not support OpenMP flags.' % self.get_display_language())
  
      def language_stdlib_only_link_flags(self):
          # The linker flags needed to link the standard library of the current
          # language in. This is needed in cases where you e.g. combine D and C++
          # and both of which need to link their runtime library in or otherwise
          # building fails with undefined symbols.
          return []
  
  GCC_STANDARD = 0
  GCC_OSX = 1
  GCC_MINGW = 2
  GCC_CYGWIN = 3
  
  CLANG_STANDARD = 0
  CLANG_OSX = 1
  CLANG_WIN = 2
  # Possibly clang-cl?
  
  ICC_STANDARD = 0
  ICC_OSX = 1
  ICC_WIN = 2
  
  # GNU ld cannot be installed on macOS
  # https://github.com/Homebrew/homebrew-core/issues/17794#issuecomment-328174395
  # Hence, we don't need to differentiate between OS and ld
  # for the sake of adding as-needed support
  GNU_LD_AS_NEEDED = '-Wl,--as-needed'
  APPLE_LD_AS_NEEDED = '-Wl,-dead_strip_dylibs'
  
  def get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion):
      install_name = prefix + shlib_name
      if soversion is not None:
          install_name += '.' + soversion
      install_name += '.dylib'
      return '@rpath/' + install_name
  
  def get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module):
      if soversion is None:
          sostr = ''
      else:
          sostr = '.' + soversion
      if gcc_type == GCC_STANDARD:
          return ['-Wl,-soname,%s%s.%s%s' % (prefix, shlib_name, suffix, sostr)]
      elif gcc_type in (GCC_MINGW, GCC_CYGWIN):
          # For PE/COFF the soname argument has no effect with GNU LD
          return []
      elif gcc_type == GCC_OSX:
          if is_shared_module:
              return []
          name = get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion)
          return ['-install_name', name]
      else:
          raise RuntimeError('Not implemented yet.')
  
  def get_compiler_is_linuxlike(compiler):
      if (getattr(compiler, 'gcc_type', None) == GCC_STANDARD) or \
         (getattr(compiler, 'clang_type', None) == CLANG_STANDARD) or \
         (getattr(compiler, 'icc_type', None) == ICC_STANDARD):
          return True
      return False
  
  def get_compiler_uses_gnuld(c):
      # FIXME: Perhaps we should detect the linker in the environment?
      # FIXME: Assumes that *BSD use GNU ld, but they might start using lld soon
      if (getattr(c, 'gcc_type', None) in (GCC_STANDARD, GCC_MINGW, GCC_CYGWIN)) or \
         (getattr(c, 'clang_type', None) in (CLANG_STANDARD, CLANG_WIN)) or \
         (getattr(c, 'icc_type', None) in (ICC_STANDARD, ICC_WIN)):
          return True
      return False
  
  def get_largefile_args(compiler):
      '''
      Enable transparent large-file-support for 32-bit UNIX systems
      '''
      if get_compiler_is_linuxlike(compiler):
          # Enable large-file support unconditionally on all platforms other
          # than macOS and Windows. macOS is now 64-bit-only so it doesn't
          # need anything special, and Windows doesn't have automatic LFS.
          # You must use the 64-bit counterparts explicitly.
          # glibc, musl, and uclibc, and all BSD libcs support this. On Android,
          # support for transparent LFS is available depending on the version of
          # Bionic: https://github.com/android/platform_bionic#32-bit-abi-bugs
          # https://code.google.com/p/android/issues/detail?id=64613
          #
          # If this breaks your code, fix it! It's been 20+ years!
          return ['-D_FILE_OFFSET_BITS=64']
          # We don't enable -D_LARGEFILE64_SOURCE since that enables
          # transitionary features and must be enabled by programs that use
          # those features explicitly.
      return []
  
  # TODO: The result from calling compiler should be cached. So that calling this
  # function multiple times don't add latency.
  def gnulike_default_include_dirs(compiler, lang):
      if lang == 'cpp':
          lang = 'c++'
      env = os.environ.copy()
      env["LC_ALL"] = 'C'
      cmd = compiler + ['-x{}'.format(lang), '-E', '-v', '-']
      p = subprocess.Popen(
          cmd,
          stdin=subprocess.DEVNULL,
          stderr=subprocess.PIPE,
          stdout=subprocess.PIPE,
          env=env
      )
      stderr = p.stderr.read().decode('utf-8', errors='replace')
      parse_state = 0
      paths = []
      for line in stderr.split('\n'):
          if parse_state == 0:
              if line == '#include "..." search starts here:':
                  parse_state = 1
          elif parse_state == 1:
              if line == '#include <...> search starts here:':
                  parse_state = 2
              else:
                  paths.append(line[1:])
          elif parse_state == 2:
              if line == 'End of search list.':
                  break
              else:
                  paths.append(line[1:])
      if len(paths) == 0:
          mlog.warning('No include directory found parsing "{cmd}" output'.format(cmd=" ".join(cmd)))
      return paths
  
  class GnuCompiler:
      # Functionality that is common to all GNU family compilers.
      def __init__(self, gcc_type, defines):
          self.id = 'gcc'
          self.gcc_type = gcc_type
          self.defines = defines or {}
          self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
                               'b_colorout', 'b_ndebug', 'b_staticpic']
          if self.gcc_type == GCC_OSX:
              self.base_options.append('b_bitcode')
          else:
              self.base_options.append('b_lundef')
          self.base_options.append('b_asneeded')
          # All GCC backends can do assembly
          self.can_compile_suffixes.add('s')
  
      # TODO: centralise this policy more globally, instead
      # of fragmenting it into GnuCompiler and ClangCompiler
      def get_asneeded_args(self):
          if self.gcc_type == GCC_OSX:
              return APPLE_LD_AS_NEEDED
          else:
              return GNU_LD_AS_NEEDED
  
      def get_colorout_args(self, colortype):
          if mesonlib.version_compare(self.version, '>=4.9.0'):
              return gnu_color_args[colortype][:]
          return []
  
      def get_warn_args(self, level):
          args = super().get_warn_args(level)
          if mesonlib.version_compare(self.version, '<4.8.0') and '-Wpedantic' in args:
              # -Wpedantic was added in 4.8.0
              # https://gcc.gnu.org/gcc-4.8/changes.html
              args[args.index('-Wpedantic')] = '-pedantic'
          return args
  
      def has_builtin_define(self, define):
          return define in self.defines
  
      def get_builtin_define(self, define):
          if define in self.defines:
              return self.defines[define]
  
      def get_pic_args(self):
          if self.gcc_type in (GCC_CYGWIN, GCC_MINGW, GCC_OSX):
              return [] # On Window and OS X, pic is always on.
          return ['-fPIC']
  
      def get_buildtype_args(self, buildtype):
          return gnulike_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          if self.gcc_type == GCC_OSX:
              return apple_buildtype_linker_args[buildtype]
          return gnulike_buildtype_linker_args[buildtype]
  
      def get_pch_suffix(self):
          return 'gch'
  
      def split_shlib_to_parts(self, fname):
          return os.path.dirname(fname), fname
  
      def get_soname_args(self, prefix, shlib_name, suffix, soversion, is_shared_module):
          return get_gcc_soname_args(self.gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module)
  
      def get_std_shared_lib_link_args(self):
          return ['-shared']
  
      def get_link_whole_for(self, args):
          return ['-Wl,--whole-archive'] + args + ['-Wl,--no-whole-archive']
  
      def gen_vs_module_defs_args(self, defsfile):
          if not isinstance(defsfile, str):
              raise RuntimeError('Module definitions file should be str')
          # On Windows targets, .def files may be specified on the linker command
          # line like an object file.
          if self.gcc_type in (GCC_CYGWIN, GCC_MINGW):
              return [defsfile]
          # For other targets, discard the .def file.
          return []
  
      def get_gui_app_args(self):
          if self.gcc_type in (GCC_CYGWIN, GCC_MINGW):
              return ['-mwindows']
          return []
  
      def get_instruction_set_args(self, instruction_set):
          return gnulike_instruction_set_args.get(instruction_set, None)
  
      def get_default_include_dirs(self):
          return gnulike_default_include_dirs(self.exelist, self.language)
  
      def openmp_flags(self):
          return ['-fopenmp']
  
  
  class ElbrusCompiler(GnuCompiler):
      # Elbrus compiler is nearly like GCC, but does not support
      # PCH, LTO, sanitizers and color output as of version 1.21.x.
      def __init__(self, gcc_type, defines):
          GnuCompiler.__init__(self, gcc_type, defines)
          self.id = 'lcc'
          self.base_options = ['b_pgo', 'b_coverage',
                               'b_ndebug', 'b_staticpic',
                               'b_lundef', 'b_asneeded']
  
      def get_library_dirs(self):
          env = os.environ.copy()
          env['LC_ALL'] = 'C'
          stdo = Popen_safe(self.exelist + ['--print-search-dirs'], env=env)[1]
          paths = []
          for line in stdo.split('\n'):
              if line.startswith('libraries:'):
                  # lcc does not include '=' in --print-search-dirs output.
                  libstr = line.split(' ', 1)[1]
                  paths = [os.path.realpath(p) for p in libstr.split(':')]
                  break
          return paths
  
      def get_program_dirs(self):
          env = os.environ.copy()
          env['LC_ALL'] = 'C'
          stdo = Popen_safe(self.exelist + ['--print-search-dirs'], env=env)[1]
          paths = []
          for line in stdo.split('\n'):
              if line.startswith('programs:'):
                  # lcc does not include '=' in --print-search-dirs output.
                  libstr = line.split(' ', 1)[1]
                  paths = [os.path.realpath(p) for p in libstr.split(':')]
                  break
          return paths
  
  class ClangCompiler:
      def __init__(self, clang_type):
          self.id = 'clang'
          self.clang_type = clang_type
          self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
                               'b_ndebug', 'b_staticpic', 'b_colorout']
          if self.clang_type == CLANG_OSX:
              self.base_options.append('b_bitcode')
          else:
              self.base_options.append('b_lundef')
          self.base_options.append('b_asneeded')
          # All Clang backends can do assembly and LLVM IR
          self.can_compile_suffixes.update(['ll', 's'])
  
      # TODO: centralise this policy more globally, instead
      # of fragmenting it into GnuCompiler and ClangCompiler
      def get_asneeded_args(self):
          if self.clang_type == CLANG_OSX:
              return APPLE_LD_AS_NEEDED
          else:
              return GNU_LD_AS_NEEDED
  
      def get_pic_args(self):
          if self.clang_type in (CLANG_WIN, CLANG_OSX):
              return [] # On Window and OS X, pic is always on.
          return ['-fPIC']
  
      def get_colorout_args(self, colortype):
          return clang_color_args[colortype][:]
  
      def get_buildtype_args(self, buildtype):
          return gnulike_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          if self.clang_type == CLANG_OSX:
              return apple_buildtype_linker_args[buildtype]
          return gnulike_buildtype_linker_args[buildtype]
  
      def get_pch_suffix(self):
          return 'pch'
  
      def get_pch_use_args(self, pch_dir, header):
          # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
          # This flag is internal to Clang (or at least not documented on the man page)
          # so it might change semantics at any time.
          return ['-include-pch', os.path.join(pch_dir, self.get_pch_name(header))]
  
      def get_soname_args(self, prefix, shlib_name, suffix, soversion, is_shared_module):
          if self.clang_type == CLANG_STANDARD:
              gcc_type = GCC_STANDARD
          elif self.clang_type == CLANG_OSX:
              gcc_type = GCC_OSX
          elif self.clang_type == CLANG_WIN:
              gcc_type = GCC_MINGW
          else:
              raise MesonException('Unreachable code when converting clang type to gcc type.')
          return get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module)
  
      def has_multi_arguments(self, args, env):
          myargs = ['-Werror=unknown-warning-option', '-Werror=unused-command-line-argument']
          if mesonlib.version_compare(self.version, '>=3.6.0'):
              myargs.append('-Werror=ignored-optimization-argument')
          return super().has_multi_arguments(
              myargs + args,
              env)
  
      def has_function(self, funcname, prefix, env, extra_args=None, dependencies=None):
          if extra_args is None:
              extra_args = []
          # Starting with XCode 8, we need to pass this to force linker
          # visibility to obey OS X and iOS minimum version targets with
          # -mmacosx-version-min, -miphoneos-version-min, etc.
          # https://github.com/Homebrew/homebrew-core/issues/3727
          if self.clang_type == CLANG_OSX and version_compare(self.version, '>=8.0'):
              extra_args.append('-Wl,-no_weak_imports')
          return super().has_function(funcname, prefix, env, extra_args, dependencies)
  
      def get_std_shared_module_link_args(self, options):
          if self.clang_type == CLANG_OSX:
              return ['-bundle', '-Wl,-undefined,dynamic_lookup']
          return ['-shared']
  
      def get_link_whole_for(self, args):
          if self.clang_type == CLANG_OSX:
              result = []
              for a in args:
                  result += ['-Wl,-force_load', a]
              return result
          return ['-Wl,--whole-archive'] + args + ['-Wl,--no-whole-archive']
  
      def get_instruction_set_args(self, instruction_set):
          return gnulike_instruction_set_args.get(instruction_set, None)
  
      def get_default_include_dirs(self):
          return gnulike_default_include_dirs(self.exelist, self.language)
  
      def openmp_flags(self):
          if version_compare(self.version, '>=3.8.0'):
              return ['-fopenmp']
          elif version_compare(self.version, '>=3.7.0'):
              return ['-fopenmp=libomp']
          else:
              # Shouldn't work, but it'll be checked explicitly in the OpenMP dependency.
              return []
  
  
  # Tested on linux for ICC 14.0.3, 15.0.6, 16.0.4, 17.0.1
  class IntelCompiler:
      def __init__(self, icc_type):
          self.id = 'intel'
          self.icc_type = icc_type
          self.lang_header = 'none'
          self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
                               'b_colorout', 'b_ndebug', 'b_staticpic', 'b_lundef', 'b_asneeded']
          # Assembly
          self.can_compile_suffixes.add('s')
  
      def get_pic_args(self):
          return ['-fPIC']
  
      def get_buildtype_args(self, buildtype):
          return gnulike_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          return gnulike_buildtype_linker_args[buildtype]
  
      def get_pch_suffix(self):
          return 'pchi'
  
      def get_pch_use_args(self, pch_dir, header):
          return ['-pch', '-pch_dir', os.path.join(pch_dir), '-x',
                  self.lang_header, '-include', header, '-x', 'none']
  
      def get_pch_name(self, header_name):
          return os.path.basename(header_name) + '.' + self.get_pch_suffix()
  
      def split_shlib_to_parts(self, fname):
          return os.path.dirname(fname), fname
  
      def get_soname_args(self, prefix, shlib_name, suffix, soversion, is_shared_module):
          if self.icc_type == ICC_STANDARD:
              gcc_type = GCC_STANDARD
          elif self.icc_type == ICC_OSX:
              gcc_type = GCC_OSX
          elif self.icc_type == ICC_WIN:
              gcc_type = GCC_MINGW
          else:
              raise MesonException('Unreachable code when converting icc type to gcc type.')
          return get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module)
  
      # TODO: centralise this policy more globally, instead
      # of fragmenting it into GnuCompiler and ClangCompiler
      def get_asneeded_args(self):
          if self.icc_type == CLANG_OSX:
              return APPLE_LD_AS_NEEDED
          else:
              return GNU_LD_AS_NEEDED
  
      def get_std_shared_lib_link_args(self):
          # FIXME: Don't know how icc works on OSX
          # if self.icc_type == ICC_OSX:
          #     return ['-bundle']
          return ['-shared']
  
      def get_default_include_dirs(self):
          return gnulike_default_include_dirs(self.exelist, self.language)
  
      def openmp_flags(self):
          if version_compare(self.version, '>=15.0.0'):
              return ['-qopenmp']
          else:
              return ['-openmp']
  
  
  class ArmCompiler:
      # Functionality that is common to all ARM family compilers.
      def __init__(self):
          if not self.is_cross:
              raise EnvironmentException('armcc supports only cross-compilation.')
          self.id = 'arm'
          default_warn_args = []
          self.warn_args = {'1': default_warn_args,
                            '2': default_warn_args + [],
                            '3': default_warn_args + []}
          # Assembly
          self.can_compile_suffixes.add('s')
  
      def can_linker_accept_rsp(self):
          return False
  
      def get_pic_args(self):
          # FIXME: Add /ropi, /rwpi, /fpic etc. qualifiers to --apcs
          return []
  
      def get_buildtype_args(self, buildtype):
          return arm_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          return arm_buildtype_linker_args[buildtype]
  
      # Override CCompiler.get_always_args
      def get_always_args(self):
          return []
  
      # Override CCompiler.get_dependency_gen_args
      def get_dependency_gen_args(self, outtarget, outfile):
          return []
  
      # Override CCompiler.get_std_shared_lib_link_args
      def get_std_shared_lib_link_args(self):
          return []
  
      def get_pch_use_args(self, pch_dir, header):
          # FIXME: Add required arguments
          # NOTE from armcc user guide:
          # "Support for Precompiled Header (PCH) files is deprecated from ARM Compiler 5.05
          # onwards on all platforms. Note that ARM Compiler on Windows 8 never supported
          # PCH files."
          return []
  
      def get_pch_suffix(self):
          # NOTE from armcc user guide:
          # "Support for Precompiled Header (PCH) files is deprecated from ARM Compiler 5.05
          # onwards on all platforms. Note that ARM Compiler on Windows 8 never supported
          # PCH files."
          return 'pch'
  
      def thread_flags(self, env):
          return []
  
      def thread_link_flags(self, env):
          return []
  
      def get_linker_exelist(self):
          args = ['armlink']
          return args
  
      def get_coverage_args(self):
          return []
  
      def get_coverage_link_args(self):
          return []
  
files: mesonbuild/compilers/compilers.py
files: # Copyright 2012-2017 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 contextlib, os.path, re, tempfile, shlex
  import subprocess
  
  from ..linkers import StaticLinker
  from .. import coredata
  from .. import mlog
  from .. import mesonlib
  from ..mesonlib import EnvironmentException, MesonException, version_compare, Popen_safe
  
  """This file contains the data files of all compilers Meson knows
  about. To support a new compiler, add its information below.
  Also add corresponding autodetection code in environment.py."""
  
  header_suffixes = ('h', 'hh', 'hpp', 'hxx', 'H', 'ipp', 'moc', 'vapi', 'di')
  obj_suffixes = ('o', 'obj', 'res')
  lib_suffixes = ('a', 'lib', 'dll', 'dylib', 'so')
  # Mapping of language to suffixes of files that should always be in that language
  # This means we can't include .h headers here since they could be C, C++, ObjC, etc.
  lang_suffixes = {
      'c': ('c',),
      'cpp': ('cpp', 'cc', 'cxx', 'c++', 'hh', 'hpp', 'ipp', 'hxx'),
      # f90, f95, f03, f08 are for free-form fortran ('f90' recommended)
      # f, for, ftn, fpp are for fixed-form fortran ('f' or 'for' recommended)
      'fortran': ('f90', 'f95', 'f03', 'f08', 'f', 'for', 'ftn', 'fpp'),
      'd': ('d', 'di'),
      'objc': ('m',),
      'objcpp': ('mm',),
      'rust': ('rs',),
      'vala': ('vala', 'vapi', 'gs'),
      'cs': ('cs',),
      'swift': ('swift',),
      'java': ('java',),
  }
  all_languages = lang_suffixes.keys()
  cpp_suffixes = lang_suffixes['cpp'] + ('h',)
  c_suffixes = lang_suffixes['c'] + ('h',)
  # List of languages that by default consume and output libraries following the
  # C ABI; these can generally be used interchangebly
  clib_langs = ('objcpp', 'cpp', 'objc', 'c', 'fortran',)
  # List of languages that can be linked with C code directly by the linker
  # used in build.py:process_compilers() and build.py:get_dynamic_linker()
  # XXX: Add Rust to this?
  clike_langs = ('d',) + clib_langs
  clike_suffixes = ()
  for _l in clike_langs + ('vala',):
      clike_suffixes += lang_suffixes[_l]
  clike_suffixes += ('h', 'll', 's')
  
  soregex = re.compile(r'.*\.so(\.[0-9]+)?(\.[0-9]+)?(\.[0-9]+)?$')
  
  # Environment variables that each lang uses.
  cflags_mapping = {'c': 'CFLAGS',
                    'cpp': 'CXXFLAGS',
                    'objc': 'OBJCFLAGS',
                    'objcpp': 'OBJCXXFLAGS',
                    'fortran': 'FFLAGS',
                    'd': 'DFLAGS',
                    'vala': 'VALAFLAGS',
                    'rust': 'RUSTFLAGS'}
  
  # All these are only for C-like languages; see `clike_langs` above.
  
  def sort_clike(lang):
      '''
      Sorting function to sort the list of languages according to
      reversed(compilers.clike_langs) and append the unknown langs in the end.
      The purpose is to prefer C over C++ for files that can be compiled by
      both such as assembly, C, etc. Also applies to ObjC, ObjC++, etc.
      '''
      if lang not in clike_langs:
          return 1
      return -clike_langs.index(lang)
  
  def is_header(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      suffix = fname.split('.')[-1]
      return suffix in header_suffixes
  
  def is_source(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      suffix = fname.split('.')[-1].lower()
      return suffix in clike_suffixes
  
  def is_assembly(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      return fname.split('.')[-1].lower() == 's'
  
  def is_llvm_ir(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      return fname.split('.')[-1] == 'll'
  
  def is_object(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
      suffix = fname.split('.')[-1]
      return suffix in obj_suffixes
  
  def is_library(fname):
      if hasattr(fname, 'fname'):
          fname = fname.fname
  
      if soregex.match(fname):
          return True
  
      suffix = fname.split('.')[-1]
      return suffix in lib_suffixes
  
  gnulike_buildtype_args = {'plain': [],
                            # -O0 is passed for improved debugging information with gcc
                            # See https://github.com/mesonbuild/meson/pull/509
                            'debug': ['-O0', '-g'],
                            'debugoptimized': ['-O2', '-g'],
                            'release': ['-O3'],
                            'minsize': ['-Os', '-g']}
  
  arm_buildtype_args = {'plain': [],
                        'debug': ['-O0', '--debug'],
                        'debugoptimized': ['-O1', '--debug'],
                        'release': ['-O3', '-Otime'],
                        'minsize': ['-O3', '-Ospace'],
                        }
  
  msvc_buildtype_args = {'plain': [],
                         'debug': ["/MDd", "/ZI", "/Ob0", "/Od", "/RTC1"],
                         'debugoptimized': ["/MD", "/Zi", "/O2", "/Ob1"],
                         'release': ["/MD", "/O2", "/Ob2"],
                         'minsize': ["/MD", "/Zi", "/Os", "/Ob1"],
                         }
  
  apple_buildtype_linker_args = {'plain': [],
                                 'debug': [],
                                 'debugoptimized': [],
                                 'release': [],
                                 'minsize': [],
                                 }
  
  gnulike_buildtype_linker_args = {'plain': [],
                                   'debug': [],
                                   'debugoptimized': [],
                                   'release': ['-Wl,-O1'],
                                   'minsize': [],
                                   }
  
  arm_buildtype_linker_args = {'plain': [],
                               'debug': [],
                               'debugoptimized': [],
                               'release': [],
                               'minsize': [],
                               }
  
  msvc_buildtype_linker_args = {'plain': [],
                                'debug': [],
                                'debugoptimized': [],
                                # The otherwise implicit REF and ICF linker
                                # optimisations are disabled by /DEBUG.
                                # REF implies ICF.
                                'release': ['/OPT:REF'],
                                'minsize': ['/INCREMENTAL:NO', '/OPT:REF'],
                                }
  
  java_buildtype_args = {'plain': [],
                         'debug': ['-g'],
                         'debugoptimized': ['-g'],
                         'release': [],
                         'minsize': [],
                         }
  
  rust_buildtype_args = {'plain': [],
                         'debug': ['-C', 'debuginfo=2'],
                         'debugoptimized': ['-C', 'debuginfo=2', '-C', 'opt-level=2'],
                         'release': ['-C', 'opt-level=3'],
                         'minsize': [], # In a future release: ['-C', 'opt-level=s'],
                         }
  
  d_gdc_buildtype_args = {'plain': [],
                          'debug': ['-g', '-O0'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O3', '-frelease'],
                          'minsize': [],
                          }
  
  d_ldc_buildtype_args = {'plain': [],
                          'debug': ['-g', '-O0'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O3', '-release'],
                          'minsize': [],
                          }
  
  d_dmd_buildtype_args = {'plain': [],
                          'debug': ['-g'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O', '-release'],
                          'minsize': [],
                          }
  
  mono_buildtype_args = {'plain': [],
                         'debug': ['-debug'],
                         'debugoptimized': ['-debug', '-optimize+'],
                         'release': ['-optimize+'],
                         'minsize': [],
                         }
  
  swift_buildtype_args = {'plain': [],
                          'debug': ['-g'],
                          'debugoptimized': ['-g', '-O'],
                          'release': ['-O'],
                          'minsize': [],
                          }
  
  gnu_winlibs = ['-lkernel32', '-luser32', '-lgdi32', '-lwinspool', '-lshell32',
                 '-lole32', '-loleaut32', '-luuid', '-lcomdlg32', '-ladvapi32']
  
  msvc_winlibs = ['kernel32.lib', 'user32.lib', 'gdi32.lib',
                  'winspool.lib', 'shell32.lib', 'ole32.lib', 'oleaut32.lib',
                  'uuid.lib', 'comdlg32.lib', 'advapi32.lib']
  
  gnu_color_args = {'auto': ['-fdiagnostics-color=auto'],
                    'always': ['-fdiagnostics-color=always'],
                    'never': ['-fdiagnostics-color=never'],
                    }
  
  clang_color_args = {'auto': ['-Xclang', '-fcolor-diagnostics'],
                      'always': ['-Xclang', '-fcolor-diagnostics'],
                      'never': ['-Xclang', '-fno-color-diagnostics'],
                      }
  
  base_options = {'b_pch': coredata.UserBooleanOption('b_pch', 'Use precompiled headers', True),
                  'b_lto': coredata.UserBooleanOption('b_lto', 'Use link time optimization', False),
                  'b_sanitize': coredata.UserComboOption('b_sanitize',
                                                         'Code sanitizer to use',
                                                         ['none', 'address', 'thread', 'undefined', 'memory', 'address,undefined'],
                                                         'none'),
                  'b_lundef': coredata.UserBooleanOption('b_lundef', 'Use -Wl,--no-undefined when linking', True),
                  'b_asneeded': coredata.UserBooleanOption('b_asneeded', 'Use -Wl,--as-needed when linking', True),
                  'b_pgo': coredata.UserComboOption('b_pgo', 'Use profile guided optimization',
                                                    ['off', 'generate', 'use'],
                                                    'off'),
                  'b_coverage': coredata.UserBooleanOption('b_coverage',
                                                           'Enable coverage tracking.',
                                                           False),
                  'b_colorout': coredata.UserComboOption('b_colorout', 'Use colored output',
                                                         ['auto', 'always', 'never'],
                                                         'always'),
                  'b_ndebug': coredata.UserComboOption('b_ndebug', 'Disable asserts',
                                                       ['true', 'false', 'if-release'], 'false'),
                  'b_staticpic': coredata.UserBooleanOption('b_staticpic',
                                                            'Build static libraries as position independent',
                                                            True),
                  'b_bitcode': coredata.UserBooleanOption('b_bitcode',
                                                          'Generate and embed bitcode (only macOS and iOS)',
                                                          False),
                  }
  
  gnulike_instruction_set_args = {'mmx': ['-mmmx'],
                                  'sse': ['-msse'],
                                  'sse2': ['-msse2'],
                                  'sse3': ['-msse3'],
                                  'ssse3': ['-mssse3'],
                                  'sse41': ['-msse4.1'],
                                  'sse42': ['-msse4.2'],
                                  'avx': ['-mavx'],
                                  'avx2': ['-mavx2'],
                                  'neon': ['-mfpu=neon'],
                                  }
  
  vs32_instruction_set_args = {'mmx': ['/arch:SSE'], # There does not seem to be a flag just for MMX
                               'sse': ['/arch:SSE'],
                               'sse2': ['/arch:SSE2'],
                               'sse3': ['/arch:AVX'], # VS leaped from SSE2 directly to AVX.
                               'sse41': ['/arch:AVX'],
                               'sse42': ['/arch:AVX'],
                               'avx': ['/arch:AVX'],
                               'avx2': ['/arch:AVX2'],
                               'neon': None,
                               }
  
  # The 64 bit compiler defaults to /arch:avx.
  vs64_instruction_set_args = {'mmx': ['/arch:AVX'],
                               'sse': ['/arch:AVX'],
                               'sse2': ['/arch:AVX'],
                               'sse3': ['/arch:AVX'],
                               'ssse3': ['/arch:AVX'],
                               'sse41': ['/arch:AVX'],
                               'sse42': ['/arch:AVX'],
                               'avx': ['/arch:AVX'],
                               'avx2': ['/arch:AVX2'],
                               'neon': None,
                               }
  
  def sanitizer_compile_args(value):
      if value == 'none':
          return []
      args = ['-fsanitize=' + value]
      if 'address' in value: # For -fsanitize=address,undefined
          args.append('-fno-omit-frame-pointer')
      return args
  
  def sanitizer_link_args(value):
      if value == 'none':
          return []
      args = ['-fsanitize=' + value]
      return args
  
  def option_enabled(boptions, options, option):
      try:
          if option not in boptions:
              return False
          return options[option].value
      except KeyError:
          return False
  
  def get_base_compile_args(options, compiler):
      args = []
      # FIXME, gcc/clang specific.
      try:
          if options['b_lto'].value:
              args.append('-flto')
      except KeyError:
          pass
      try:
          args += compiler.get_colorout_args(options['b_colorout'].value)
      except KeyError:
          pass
      try:
          args += sanitizer_compile_args(options['b_sanitize'].value)
      except KeyError:
          pass
      try:
          pgo_val = options['b_pgo'].value
          if pgo_val == 'generate':
              args.append('-fprofile-generate')
          elif pgo_val == 'use':
              args.append('-fprofile-use')
      except KeyError:
          pass
      try:
          if options['b_coverage'].value:
              args += compiler.get_coverage_args()
      except KeyError:
          pass
      try:
          if (options['b_ndebug'].value == 'true' or
                  (options['b_ndebug'].value == 'if-release' and
                   options['buildtype'].value == 'release')):
              args += ['-DNDEBUG']
      except KeyError:
          pass
      # This does not need a try...except
      if option_enabled(compiler.base_options, options, 'b_bitcode'):
          args.append('-fembed-bitcode')
      return args
  
  def get_base_link_args(options, linker, is_shared_module):
      args = []
      # FIXME, gcc/clang specific.
      try:
          if options['b_lto'].value:
              args.append('-flto')
      except KeyError:
          pass
      try:
          args += sanitizer_link_args(options['b_sanitize'].value)
      except KeyError:
          pass
      try:
          pgo_val = options['b_pgo'].value
          if pgo_val == 'generate':
              args.append('-fprofile-generate')
          elif pgo_val == 'use':
              args.append('-fprofile-use')
      except KeyError:
          pass
      try:
          if options['b_coverage'].value:
              args += linker.get_coverage_link_args()
      except KeyError:
          pass
      # These do not need a try...except
      if not is_shared_module and option_enabled(linker.base_options, options, 'b_lundef'):
          args.append('-Wl,--no-undefined')
      as_needed = option_enabled(linker.base_options, options, 'b_asneeded')
      bitcode = option_enabled(linker.base_options, options, 'b_bitcode')
      # Shared modules cannot be built with bitcode_bundle because
      # -bitcode_bundle is incompatible with -undefined and -bundle
      if bitcode and not is_shared_module:
          args.append('-Wl,-bitcode_bundle')
      elif as_needed:
          # -Wl,-dead_strip_dylibs is incompatible with bitcode
          args.append(linker.get_asneeded_args())
      return args
  
  class CrossNoRunException(MesonException):
      pass
  
  class RunResult:
      def __init__(self, compiled, returncode=999, stdout='UNDEFINED', stderr='UNDEFINED'):
          self.compiled = compiled
          self.returncode = returncode
          self.stdout = stdout
          self.stderr = stderr
  
  class CompilerArgs(list):
      '''
      Class derived from list() that manages a list of compiler arguments. Should
      be used while constructing compiler arguments from various sources. Can be
      operated with ordinary lists, so this does not need to be used everywhere.
  
      All arguments must be inserted and stored in GCC-style (-lfoo, -Idir, etc)
      and can converted to the native type of each compiler by using the
      .to_native() method to which you must pass an instance of the compiler or
      the compiler class.
  
      New arguments added to this class (either with .append(), .extend(), or +=)
      are added in a way that ensures that they override previous arguments.
      For example:
  
      >>> a = ['-Lfoo', '-lbar']
      >>> a += ['-Lpho', '-lbaz']
      >>> print(a)
      ['-Lpho', '-Lfoo', '-lbar', '-lbaz']
  
      Arguments will also be de-duped if they can be de-duped safely.
  
      Note that because of all this, this class is not commutative and does not
      preserve the order of arguments if it is safe to not. For example:
      >>> ['-Ifoo', '-Ibar'] + ['-Ifez', '-Ibaz', '-Werror']
      ['-Ifez', '-Ibaz', '-Ifoo', '-Ibar', '-Werror']
      >>> ['-Ifez', '-Ibaz', '-Werror'] + ['-Ifoo', '-Ibar']
      ['-Ifoo', '-Ibar', '-Ifez', '-Ibaz', '-Werror']
  
      '''
      # NOTE: currently this class is only for C-like compilers, but it can be
      # extended to other languages easily. Just move the following to the
      # compiler class and initialize when self.compiler is set.
  
      # Arg prefixes that override by prepending instead of appending
      prepend_prefixes = ('-I', '-L')
      # Arg prefixes and args that must be de-duped by returning 2
      dedup2_prefixes = ('-I', '-L', '-D', '-U')
      dedup2_suffixes = ()
      dedup2_args = ()
      # Arg prefixes and args that must be de-duped by returning 1
      dedup1_prefixes = ('-l',)
      dedup1_suffixes = ('.lib', '.dll', '.so', '.dylib', '.a')
      # Match a .so of the form path/to/libfoo.so.0.1.0
      # Only UNIX shared libraries require this. Others have a fixed extension.
      dedup1_regex = re.compile(r'([\/\\]|\A)lib.*\.so(\.[0-9]+)?(\.[0-9]+)?(\.[0-9]+)?$')
      dedup1_args = ('-c', '-S', '-E', '-pipe', '-pthread')
      compiler = None
  
      def _check_args(self, args):
          cargs = []
          if len(args) > 2:
              raise TypeError("CompilerArgs() only accepts at most 2 arguments: "
                              "The compiler, and optionally an initial list")
          elif not args:
              return cargs
          elif len(args) == 1:
              if isinstance(args[0], (Compiler, StaticLinker)):
                  self.compiler = args[0]
              else:
                  raise TypeError("you must pass a Compiler instance as one of "
                                  "the arguments")
          elif len(args) == 2:
              if isinstance(args[0], (Compiler, StaticLinker)):
                  self.compiler = args[0]
                  cargs = args[1]
              elif isinstance(args[1], (Compiler, StaticLinker)):
                  cargs = args[0]
                  self.compiler = args[1]
              else:
                  raise TypeError("you must pass a Compiler instance as one of "
                                  "the two arguments")
          else:
              raise AssertionError('Not reached')
          return cargs
  
      def __init__(self, *args):
          super().__init__(self._check_args(args))
  
      @classmethod
      def _can_dedup(cls, arg):
          '''
          Returns whether the argument can be safely de-duped. This is dependent
          on three things:
  
          a) Whether an argument can be 'overridden' by a later argument.  For
             example, -DFOO defines FOO and -UFOO undefines FOO. In this case, we
             can safely remove the previous occurrence and add a new one. The same
             is true for include paths and library paths with -I and -L. For
             these we return `2`. See `dedup2_prefixes` and `dedup2_args`.
          b) Arguments that once specified cannot be undone, such as `-c` or
             `-pipe`. New instances of these can be completely skipped. For these
             we return `1`. See `dedup1_prefixes` and `dedup1_args`.
          c) Whether it matters where or how many times on the command-line
             a particular argument is present. This can matter for symbol
             resolution in static or shared libraries, so we cannot de-dup or
             reorder them. For these we return `0`. This is the default.
  
          In addition to these, we handle library arguments specially.
          With GNU ld, we surround library arguments with -Wl,--start/end-group
          to recursively search for symbols in the libraries. This is not needed
          with other linkers.
          '''
  
          # A standalone argument must never be deduplicated because it is
          # defined by what comes _after_ it. Thus dedupping this:
          # -D FOO -D BAR
          # would yield either
          # -D FOO BAR
          # or
          # FOO -D BAR
          # both of which are invalid.
          if arg in cls.dedup2_prefixes:
              return 0
          if arg in cls.dedup2_args or \
             arg.startswith(cls.dedup2_prefixes) or \
             arg.endswith(cls.dedup2_suffixes):
              return 2
          if arg in cls.dedup1_args or \
             arg.startswith(cls.dedup1_prefixes) or \
             arg.endswith(cls.dedup1_suffixes) or \
             re.search(cls.dedup1_regex, arg):
              return 1
          return 0
  
      @classmethod
      def _should_prepend(cls, arg):
          if arg.startswith(cls.prepend_prefixes):
              return True
          return False
  
      def to_native(self):
          # Check if we need to add --start/end-group for circular dependencies
          # between static libraries, and for recursively searching for symbols
          # needed by static libraries that are provided by object files or
          # shared libraries.
          if get_compiler_uses_gnuld(self.compiler):
              global soregex
              group_start = -1
              for each in self:
                  if not each.startswith('-l') and not each.endswith('.a') and \
                     not soregex.match(each):
                      continue
                  i = self.index(each)
                  if group_start < 0:
                      # First occurrence of a library
                      group_start = i
              if group_start >= 0:
                  # Last occurrence of a library
                  self.insert(i + 1, '-Wl,--end-group')
                  self.insert(group_start, '-Wl,--start-group')
          return self.compiler.unix_args_to_native(self)
  
      def append_direct(self, arg):
          '''
          Append the specified argument without any reordering or de-dup
          except for absolute paths where the order of include search directories
          is not relevant
          '''
          if os.path.isabs(arg):
              self.append(arg)
          else:
              super().append(arg)
  
      def extend_direct(self, iterable):
          '''
          Extend using the elements in the specified iterable without any
          reordering or de-dup except for absolute paths where the order of
          include search directories is not relevant
          '''
          for elem in iterable:
              self.append_direct(elem)
  
      def __add__(self, args):
          new = CompilerArgs(self, self.compiler)
          new += args
          return new
  
      def __iadd__(self, args):
          '''
          Add two CompilerArgs while taking into account overriding of arguments
          and while preserving the order of arguments as much as possible
          '''
          pre = []
          post = []
          if not isinstance(args, list):
              raise TypeError('can only concatenate list (not "{}") to list'.format(args))
          for arg in args:
              # If the argument can be de-duped, do it either by removing the
              # previous occurrence of it and adding a new one, or not adding the
              # new occurrence.
              dedup = self._can_dedup(arg)
              if dedup == 1:
                  # Argument already exists and adding a new instance is useless
                  if arg in self or arg in pre or arg in post:
                      continue
              if dedup == 2:
                  # Remove all previous occurrences of the arg and add it anew
                  if arg in self:
                      self.remove(arg)
                  if arg in pre:
                      pre.remove(arg)
                  if arg in post:
                      post.remove(arg)
              if self._should_prepend(arg):
                  pre.append(arg)
              else:
                  post.append(arg)
          # Insert at the beginning
          self[:0] = pre
          # Append to the end
          super().__iadd__(post)
          return self
  
      def __radd__(self, args):
          new = CompilerArgs(args, self.compiler)
          new += self
          return new
  
      def __mul__(self, args):
          raise TypeError("can't multiply compiler arguments")
  
      def __imul__(self, args):
          raise TypeError("can't multiply compiler arguments")
  
      def __rmul__(self, args):
          raise TypeError("can't multiply compiler arguments")
  
      def append(self, arg):
          self.__iadd__([arg])
  
      def extend(self, args):
          self.__iadd__(args)
  
  class Compiler:
      # Libraries to ignore in find_library() since they are provided by the
      # compiler or the C library. Currently only used for MSVC.
      ignore_libs = ()
      # Cache for the result of compiler checks which can be cached
      compiler_check_cache = {}
  
      def __init__(self, exelist, version, **kwargs):
          if isinstance(exelist, str):
              self.exelist = [exelist]
          elif isinstance(exelist, list):
              self.exelist = exelist
          else:
              raise TypeError('Unknown argument to Compiler')
          # In case it's been overridden by a child class already
          if not hasattr(self, 'file_suffixes'):
              self.file_suffixes = lang_suffixes[self.language]
          if not hasattr(self, 'can_compile_suffixes'):
              self.can_compile_suffixes = set(self.file_suffixes)
          self.default_suffix = self.file_suffixes[0]
          self.version = version
          if 'full_version' in kwargs:
              self.full_version = kwargs['full_version']
          else:
              self.full_version = None
          self.base_options = []
  
      def __repr__(self):
          repr_str = "<{0}: v{1} `{2}`>"
          return repr_str.format(self.__class__.__name__, self.version,
                                 ' '.join(self.exelist))
  
      def can_compile(self, src):
          if hasattr(src, 'fname'):
              src = src.fname
          suffix = os.path.splitext(src)[1].lower()
          if suffix and suffix[1:] in self.can_compile_suffixes:
              return True
          return False
  
      def get_id(self):
          return self.id
  
      def get_language(self):
          return self.language
  
      def get_display_language(self):
          return self.language.capitalize()
  
      def get_default_suffix(self):
          return self.default_suffix
  
      def get_define(self, dname, prefix, env, extra_args, dependencies):
          raise EnvironmentException('%s does not support get_define ' % self.get_id())
  
      def compute_int(self, expression, low, high, guess, prefix, env, extra_args, dependencies):
          raise EnvironmentException('%s does not support compute_int ' % self.get_id())
  
      def has_members(self, typename, membernames, prefix, env, extra_args=None, dependencies=None):
          raise EnvironmentException('%s does not support has_member(s) ' % self.get_id())
  
      def has_type(self, typename, prefix, env, extra_args, dependencies=None):
          raise EnvironmentException('%s does not support has_type ' % self.get_id())
  
      def symbols_have_underscore_prefix(self, env):
          raise EnvironmentException('%s does not support symbols_have_underscore_prefix ' % self.get_id())
  
      def get_exelist(self):
          return self.exelist[:]
  
      def get_builtin_define(self, *args, **kwargs):
          raise EnvironmentException('%s does not support get_builtin_define.' % self.id)
  
      def has_builtin_define(self, *args, **kwargs):
          raise EnvironmentException('%s does not support has_builtin_define.' % self.id)
  
      def get_always_args(self):
          return []
  
      def can_linker_accept_rsp(self):
          """
          Determines whether the linker can accept arguments using the @rsp syntax.
          """
          return mesonlib.is_windows()
  
      def get_linker_always_args(self):
          return []
  
      def gen_import_library_args(self, implibname):
          """
          Used only on Windows for libraries that need an import library.
          This currently means C, C++, Fortran.
          """
          return []
  
      def get_preproc_flags(self):
          if self.get_language() in ('c', 'cpp', 'objc', 'objcpp'):
              return os.environ.get('CPPFLAGS', '')
          return ''
  
      def get_args_from_envvars(self):
          """
          Returns a tuple of (compile_flags, link_flags) for the specified language
          from the inherited environment
          """
          def log_var(var, val):
              if val:
                  mlog.log('Appending {} from environment: {!r}'.format(var, val))
  
          lang = self.get_language()
          compiler_is_linker = False
          if hasattr(self, 'get_linker_exelist'):
              compiler_is_linker = (self.get_exelist() == self.get_linker_exelist())
  
          if lang not in cflags_mapping:
              return [], []
  
          compile_flags = os.environ.get(cflags_mapping[lang], '')
          log_var(cflags_mapping[lang], compile_flags)
          compile_flags = shlex.split(compile_flags)
  
          # Link flags (same for all languages)
          link_flags = os.environ.get('LDFLAGS', '')
          log_var('LDFLAGS', link_flags)
          link_flags = shlex.split(link_flags)
          if compiler_is_linker:
              # When the compiler is used as a wrapper around the linker (such as
              # with GCC and Clang), the compile flags can be needed while linking
              # too. This is also what Autotools does. However, we don't want to do
              # this when the linker is stand-alone such as with MSVC C/C++, etc.
              link_flags = compile_flags + link_flags
  
          # Pre-processor flags (not for fortran or D)
          preproc_flags = self.get_preproc_flags()
          log_var('CPPFLAGS', preproc_flags)
          preproc_flags = shlex.split(preproc_flags)
          compile_flags += preproc_flags
  
          return compile_flags, link_flags
  
      def get_options(self):
          opts = {} # build afresh every time
  
          # Take default values from env variables.
          compile_args, link_args = self.get_args_from_envvars()
          description = 'Extra arguments passed to the {}'.format(self.get_display_language())
          opts.update({
              self.language + '_args': coredata.UserArrayOption(
                  self.language + '_args',
                  description + ' compiler',
                  compile_args, shlex_split=True, user_input=True),
              self.language + '_link_args': coredata.UserArrayOption(
                  self.language + '_link_args',
                  description + ' linker',
                  link_args, shlex_split=True, user_input=True),
          })
  
          return opts
  
      def get_option_compile_args(self, options):
          return []
  
      def get_option_link_args(self, options):
          return []
  
      def check_header(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support header checks.' % self.get_display_language())
  
      def has_header(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support header checks.' % self.get_display_language())
  
      def has_header_symbol(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support header symbol checks.' % self.get_display_language())
  
      def compiles(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support compile checks.' % self.get_display_language())
  
      def links(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support link checks.' % self.get_display_language())
  
      def run(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support run checks.' % self.get_display_language())
  
      def sizeof(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support sizeof checks.' % self.get_display_language())
  
      def alignment(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support alignment checks.' % self.get_display_language())
  
      def has_function(self, *args, **kwargs):
          raise EnvironmentException('Language %s does not support function checks.' % self.get_display_language())
  
      @classmethod
      def unix_args_to_native(cls, args):
          "Always returns a copy that can be independently mutated"
          return args[:]
  
      def find_library(self, *args, **kwargs):
          raise EnvironmentException('Language {} does not support library finding.'.format(self.get_display_language()))
  
      def get_library_dirs(self):
          return []
  
      def has_multi_arguments(self, args, env):
          raise EnvironmentException(
              'Language {} does not support has_multi_arguments.'.format(
                  self.get_display_language()))
  
      def has_multi_link_arguments(self, args, env):
          raise EnvironmentException(
              'Language {} does not support has_multi_link_arguments.'.format(
                  self.get_display_language()))
  
      def get_cross_extra_flags(self, environment, link):
          extra_flags = []
          if self.is_cross and environment:
              if 'properties' in environment.cross_info.config:
                  props = environment.cross_info.config['properties']
                  lang_args_key = self.language + '_args'
                  extra_flags += props.get(lang_args_key, [])
                  lang_link_args_key = self.language + '_link_args'
                  if link:
                      extra_flags += props.get(lang_link_args_key, [])
          return extra_flags
  
      def _get_compile_output(self, dirname, mode):
          # In pre-processor mode, the output is sent to stdout and discarded
          if mode == 'preprocess':
              return None
          # Extension only matters if running results; '.exe' is
          # guaranteed to be executable on every platform.
          if mode == 'link':
              suffix = 'exe'
          else:
              suffix = 'obj'
          return os.path.join(dirname, 'output.' + suffix)
  
      @contextlib.contextmanager
      def compile(self, code, extra_args=None, mode='link', want_output=False):
          if extra_args is None:
              textra_args = None
              extra_args = []
          else:
              textra_args = tuple(extra_args)
          key = (code, textra_args, mode)
          if not want_output:
              if key in self.compiler_check_cache:
                  p = self.compiler_check_cache[key]
                  mlog.debug('Using cached compile:')
                  mlog.debug('Cached command line: ', ' '.join(p.commands), '\n')
                  mlog.debug('Code:\n', code)
                  mlog.debug('Cached compiler stdout:\n', p.stdo)
                  mlog.debug('Cached compiler stderr:\n', p.stde)
                  yield p
                  return
          try:
              with tempfile.TemporaryDirectory() as tmpdirname:
                  if isinstance(code, str):
                      srcname = os.path.join(tmpdirname,
                                             'testfile.' + self.default_suffix)
                      with open(srcname, 'w') as ofile:
                          ofile.write(code)
                  elif isinstance(code, mesonlib.File):
                      srcname = code.fname
  
                  # Construct the compiler command-line
                  commands = CompilerArgs(self)
                  commands.append(srcname)
                  commands += self.get_always_args()
                  if mode == 'compile':
                      commands += self.get_compile_only_args()
                  # Preprocess mode outputs to stdout, so no output args
                  if mode == 'preprocess':
                      commands += self.get_preprocess_only_args()
                  else:
                      output = self._get_compile_output(tmpdirname, mode)
                      commands += self.get_output_args(output)
                  # extra_args must be last because it could contain '/link' to
                  # pass args to VisualStudio's linker. In that case everything
                  # in the command line after '/link' is given to the linker.
                  commands += extra_args
                  # Generate full command-line with the exelist
                  commands = self.get_exelist() + commands.to_native()
                  mlog.debug('Running compile:')
                  mlog.debug('Working directory: ', tmpdirname)
                  mlog.debug('Command line: ', ' '.join(commands), '\n')
                  mlog.debug('Code:\n', code)
                  p, p.stdo, p.stde = Popen_safe(commands, cwd=tmpdirname)
                  mlog.debug('Compiler stdout:\n', p.stdo)
                  mlog.debug('Compiler stderr:\n', p.stde)
                  p.commands = commands
                  p.input_name = srcname
                  if want_output:
                      p.output_name = output
                  else:
                      self.compiler_check_cache[key] = p
                  yield p
          except (PermissionError, OSError):
              # On Windows antivirus programs and the like hold on to files so
              # they can't be deleted. There's not much to do in this case. Also,
              # catch OSError because the directory is then no longer empty.
              pass
  
      def get_colorout_args(self, colortype):
          return []
  
      # Some compilers (msvc) write debug info to a separate file.
      # These args specify where it should be written.
      def get_compile_debugfile_args(self, rel_obj, **kwargs):
          return []
  
      def get_link_debugfile_args(self, rel_obj):
          return []
  
      def get_std_shared_lib_link_args(self):
          return []
  
      def get_std_shared_module_link_args(self, options):
          return self.get_std_shared_lib_link_args()
  
      def get_link_whole_for(self, args):
          if isinstance(args, list) and not args:
              return []
          raise EnvironmentException('Language %s does not support linking whole archives.' % self.get_display_language())
  
      # Compiler arguments needed to enable the given instruction set.
      # May be [] meaning nothing needed or None meaning the given set
      # is not supported.
      def get_instruction_set_args(self, instruction_set):
          return None
  
      def build_osx_rpath_args(self, build_dir, rpath_paths, build_rpath):
          if not rpath_paths and not build_rpath:
              return []
          # On OSX, rpaths must be absolute.
          abs_rpaths = [os.path.join(build_dir, p) for p in rpath_paths]
          if build_rpath != '':
              abs_rpaths.append(build_rpath)
          # Ensure that there is enough space for large RPATHs
          args = ['-Wl,-headerpad_max_install_names']
          args += ['-Wl,-rpath,' + rp for rp in abs_rpaths]
          return args
  
      def build_unix_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
          if not rpath_paths and not install_rpath and not build_rpath:
              return []
          # The rpaths we write must be relative, because otherwise
          # they have different length depending on the build
          # directory. This breaks reproducible builds.
          rel_rpaths = []
          for p in rpath_paths:
              if p == from_dir:
                  relative = '' # relpath errors out in this case
              else:
                  relative = os.path.relpath(os.path.join(build_dir, p), os.path.join(build_dir, from_dir))
              rel_rpaths.append(relative)
          paths = ':'.join([os.path.join('$ORIGIN', p) for p in rel_rpaths])
          # Build_rpath is used as-is (it is usually absolute).
          if build_rpath != '':
              if paths != '':
                  paths += ':'
              paths += build_rpath
          if len(paths) < len(install_rpath):
              padding = 'X' * (len(install_rpath) - len(paths))
              if not paths:
                  paths = padding
              else:
                  paths = paths + ':' + padding
          args = []
          if mesonlib.is_dragonflybsd() or mesonlib.is_openbsd():
              # This argument instructs the compiler to record the value of
              # ORIGIN in the .dynamic section of the elf. On Linux this is done
              # by default, but is not on dragonfly/openbsd for some reason. Without this
              # $ORIGIN in the runtime path will be undefined and any binaries
              # linked against local libraries will fail to resolve them.
              args.append('-Wl,-z,origin')
          args.append('-Wl,-rpath,' + paths)
          if get_compiler_is_linuxlike(self):
              # Rpaths to use while linking must be absolute. These are not
              # written to the binary. Needed only with GNU ld:
              # https://sourceware.org/bugzilla/show_bug.cgi?id=16936
              # Not needed on Windows or other platforms that don't use RPATH
              # https://github.com/mesonbuild/meson/issues/1897
              lpaths = ':'.join([os.path.join(build_dir, p) for p in rpath_paths])
  
              # clang expands '-Wl,rpath-link,' to ['-rpath-link'] instead of ['-rpath-link','']
              # This eats the next argument, which happens to be 'ldstdc++', causing link failures.
              # We can dodge this problem by not adding any rpath_paths if the argument is empty.
              if lpaths.strip() != '':
                  args += ['-Wl,-rpath-link,' + lpaths]
          return args
  
      def thread_flags(self, env):
          return []
  
      def openmp_flags(self):
          raise EnvironmentException('Language %s does not support OpenMP flags.' % self.get_display_language())
  
      def language_stdlib_only_link_flags(self):
          # The linker flags needed to link the standard library of the current
          # language in. This is needed in cases where you e.g. combine D and C++
          # and both of which need to link their runtime library in or otherwise
          # building fails with undefined symbols.
          return []
  
  GCC_STANDARD = 0
  GCC_OSX = 1
  GCC_MINGW = 2
  GCC_CYGWIN = 3
  
  CLANG_STANDARD = 0
  CLANG_OSX = 1
  CLANG_WIN = 2
  # Possibly clang-cl?
  
  ICC_STANDARD = 0
  ICC_OSX = 1
  ICC_WIN = 2
  
  # GNU ld cannot be installed on macOS
  # https://github.com/Homebrew/homebrew-core/issues/17794#issuecomment-328174395
  # Hence, we don't need to differentiate between OS and ld
  # for the sake of adding as-needed support
  GNU_LD_AS_NEEDED = '-Wl,--as-needed'
  APPLE_LD_AS_NEEDED = '-Wl,-dead_strip_dylibs'
  
  def get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion):
      install_name = prefix + shlib_name
      if soversion is not None:
          install_name += '.' + soversion
      install_name += '.dylib'
      return '@rpath/' + install_name
  
  def get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module):
      if soversion is None:
          sostr = ''
      else:
          sostr = '.' + soversion
      if gcc_type == GCC_STANDARD:
          return ['-Wl,-soname,%s%s.%s%s' % (prefix, shlib_name, suffix, sostr)]
      elif gcc_type in (GCC_MINGW, GCC_CYGWIN):
          # For PE/COFF the soname argument has no effect with GNU LD
          return []
      elif gcc_type == GCC_OSX:
          if is_shared_module:
              return []
          name = get_macos_dylib_install_name(prefix, shlib_name, suffix, soversion)
          return ['-install_name', name]
      else:
          raise RuntimeError('Not implemented yet.')
  
  def get_compiler_is_linuxlike(compiler):
      if (getattr(compiler, 'gcc_type', None) == GCC_STANDARD) or \
         (getattr(compiler, 'clang_type', None) == CLANG_STANDARD) or \
         (getattr(compiler, 'icc_type', None) == ICC_STANDARD):
          return True
      return False
  
  def get_compiler_uses_gnuld(c):
      # FIXME: Perhaps we should detect the linker in the environment?
      # FIXME: Assumes that *BSD use GNU ld, but they might start using lld soon
      if (getattr(c, 'gcc_type', None) in (GCC_STANDARD, GCC_MINGW, GCC_CYGWIN)) or \
         (getattr(c, 'clang_type', None) in (CLANG_STANDARD, CLANG_WIN)) or \
         (getattr(c, 'icc_type', None) in (ICC_STANDARD, ICC_WIN)):
          return True
      return False
  
  def get_largefile_args(compiler):
      '''
      Enable transparent large-file-support for 32-bit UNIX systems
      '''
      if get_compiler_is_linuxlike(compiler):
          # Enable large-file support unconditionally on all platforms other
          # than macOS and Windows. macOS is now 64-bit-only so it doesn't
          # need anything special, and Windows doesn't have automatic LFS.
          # You must use the 64-bit counterparts explicitly.
          # glibc, musl, and uclibc, and all BSD libcs support this. On Android,
          # support for transparent LFS is available depending on the version of
          # Bionic: https://github.com/android/platform_bionic#32-bit-abi-bugs
          # https://code.google.com/p/android/issues/detail?id=64613
          #
          # If this breaks your code, fix it! It's been 20+ years!
          return ['-D_FILE_OFFSET_BITS=64']
          # We don't enable -D_LARGEFILE64_SOURCE since that enables
          # transitionary features and must be enabled by programs that use
          # those features explicitly.
      return []
  
  # TODO: The result from calling compiler should be cached. So that calling this
  # function multiple times don't add latency.
  def gnulike_default_include_dirs(compiler, lang):
      if lang == 'cpp':
          lang = 'c++'
      env = os.environ.copy()
      env["LC_ALL"] = 'C'
      cmd = compiler + ['-x{}'.format(lang), '-E', '-v', '-']
      p = subprocess.Popen(
          cmd,
          stdin=subprocess.DEVNULL,
          stderr=subprocess.PIPE,
          stdout=subprocess.PIPE,
          env=env
      )
      stderr = p.stderr.read().decode('utf-8', errors='replace')
      parse_state = 0
      paths = []
      for line in stderr.split('\n'):
          if parse_state == 0:
              if line == '#include "..." search starts here:':
                  parse_state = 1
          elif parse_state == 1:
              if line == '#include <...> search starts here:':
                  parse_state = 2
              else:
                  paths.append(line[1:])
          elif parse_state == 2:
              if line == 'End of search list.':
                  break
              else:
                  paths.append(line[1:])
      if len(paths) == 0:
          mlog.warning('No include directory found parsing "{cmd}" output'.format(cmd=" ".join(cmd)))
      return paths
  
  class GnuCompiler:
      # Functionality that is common to all GNU family compilers.
      def __init__(self, gcc_type, defines):
          self.id = 'gcc'
          self.gcc_type = gcc_type
          self.defines = defines or {}
          self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
                               'b_colorout', 'b_ndebug', 'b_staticpic']
          if self.gcc_type == GCC_OSX:
              self.base_options.append('b_bitcode')
          else:
              self.base_options.append('b_lundef')
          self.base_options.append('b_asneeded')
          # All GCC backends can do assembly
          self.can_compile_suffixes.add('s')
  
      # TODO: centralise this policy more globally, instead
      # of fragmenting it into GnuCompiler and ClangCompiler
      def get_asneeded_args(self):
          if self.gcc_type == GCC_OSX:
              return APPLE_LD_AS_NEEDED
          else:
              return GNU_LD_AS_NEEDED
  
      def get_colorout_args(self, colortype):
          if mesonlib.version_compare(self.version, '>=4.9.0'):
              return gnu_color_args[colortype][:]
          return []
  
      def get_warn_args(self, level):
          args = super().get_warn_args(level)
          if mesonlib.version_compare(self.version, '<4.8.0') and '-Wpedantic' in args:
              # -Wpedantic was added in 4.8.0
              # https://gcc.gnu.org/gcc-4.8/changes.html
              args[args.index('-Wpedantic')] = '-pedantic'
          return args
  
      def has_builtin_define(self, define):
          return define in self.defines
  
      def get_builtin_define(self, define):
          if define in self.defines:
              return self.defines[define]
  
      def get_pic_args(self):
          if self.gcc_type in (GCC_CYGWIN, GCC_MINGW, GCC_OSX):
              return [] # On Window and OS X, pic is always on.
          return ['-fPIC']
  
      def get_buildtype_args(self, buildtype):
          return gnulike_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          if self.gcc_type == GCC_OSX:
              return apple_buildtype_linker_args[buildtype]
          return gnulike_buildtype_linker_args[buildtype]
  
      def get_pch_suffix(self):
          return 'gch'
  
      def split_shlib_to_parts(self, fname):
          return os.path.dirname(fname), fname
  
      def get_soname_args(self, prefix, shlib_name, suffix, soversion, is_shared_module):
          return get_gcc_soname_args(self.gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module)
  
      def get_std_shared_lib_link_args(self):
          return ['-shared']
  
      def get_link_whole_for(self, args):
          return ['-Wl,--whole-archive'] + args + ['-Wl,--no-whole-archive']
  
      def gen_vs_module_defs_args(self, defsfile):
          if not isinstance(defsfile, str):
              raise RuntimeError('Module definitions file should be str')
          # On Windows targets, .def files may be specified on the linker command
          # line like an object file.
          if self.gcc_type in (GCC_CYGWIN, GCC_MINGW):
              return [defsfile]
          # For other targets, discard the .def file.
          return []
  
      def get_gui_app_args(self):
          if self.gcc_type in (GCC_CYGWIN, GCC_MINGW):
              return ['-mwindows']
          return []
  
      def get_instruction_set_args(self, instruction_set):
          return gnulike_instruction_set_args.get(instruction_set, None)
  
      def get_default_include_dirs(self):
          return gnulike_default_include_dirs(self.exelist, self.language)
  
      def openmp_flags(self):
          return ['-fopenmp']
  
  
  class ElbrusCompiler(GnuCompiler):
      # Elbrus compiler is nearly like GCC, but does not support
      # PCH, LTO, sanitizers and color output as of version 1.21.x.
      def __init__(self, gcc_type, defines):
          GnuCompiler.__init__(self, gcc_type, defines)
          self.id = 'lcc'
          self.base_options = ['b_pgo', 'b_coverage',
                               'b_ndebug', 'b_staticpic',
                               'b_lundef', 'b_asneeded']
  
      def get_library_dirs(self):
          env = os.environ.copy()
          env['LC_ALL'] = 'C'
          stdo = Popen_safe(self.exelist + ['--print-search-dirs'], env=env)[1]
          paths = []
          for line in stdo.split('\n'):
              if line.startswith('libraries:'):
                  # lcc does not include '=' in --print-search-dirs output.
                  libstr = line.split(' ', 1)[1]
                  paths = [os.path.realpath(p) for p in libstr.split(':')]
                  break
          return paths
  
      def get_program_dirs(self):
          env = os.environ.copy()
          env['LC_ALL'] = 'C'
          stdo = Popen_safe(self.exelist + ['--print-search-dirs'], env=env)[1]
          paths = []
          for line in stdo.split('\n'):
              if line.startswith('programs:'):
                  # lcc does not include '=' in --print-search-dirs output.
                  libstr = line.split(' ', 1)[1]
                  paths = [os.path.realpath(p) for p in libstr.split(':')]
                  break
          return paths
  
  class ClangCompiler:
      def __init__(self, clang_type):
          self.id = 'clang'
          self.clang_type = clang_type
          self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
                               'b_ndebug', 'b_staticpic', 'b_colorout']
          if self.clang_type == CLANG_OSX:
              self.base_options.append('b_bitcode')
          else:
              self.base_options.append('b_lundef')
          self.base_options.append('b_asneeded')
          # All Clang backends can do assembly and LLVM IR
          self.can_compile_suffixes.update(['ll', 's'])
  
      # TODO: centralise this policy more globally, instead
      # of fragmenting it into GnuCompiler and ClangCompiler
      def get_asneeded_args(self):
          if self.clang_type == CLANG_OSX:
              return APPLE_LD_AS_NEEDED
          else:
              return GNU_LD_AS_NEEDED
  
      def get_pic_args(self):
          if self.clang_type in (CLANG_WIN, CLANG_OSX):
              return [] # On Window and OS X, pic is always on.
          return ['-fPIC']
  
      def get_colorout_args(self, colortype):
          return clang_color_args[colortype][:]
  
      def get_buildtype_args(self, buildtype):
          return gnulike_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          if self.clang_type == CLANG_OSX:
              return apple_buildtype_linker_args[buildtype]
          return gnulike_buildtype_linker_args[buildtype]
  
      def get_pch_suffix(self):
          return 'pch'
  
      def get_pch_use_args(self, pch_dir, header):
          # Workaround for Clang bug http://llvm.org/bugs/show_bug.cgi?id=15136
          # This flag is internal to Clang (or at least not documented on the man page)
          # so it might change semantics at any time.
          return ['-include-pch', os.path.join(pch_dir, self.get_pch_name(header))]
  
      def get_soname_args(self, prefix, shlib_name, suffix, soversion, is_shared_module):
          if self.clang_type == CLANG_STANDARD:
              gcc_type = GCC_STANDARD
          elif self.clang_type == CLANG_OSX:
              gcc_type = GCC_OSX
          elif self.clang_type == CLANG_WIN:
              gcc_type = GCC_MINGW
          else:
              raise MesonException('Unreachable code when converting clang type to gcc type.')
          return get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module)
  
      def has_multi_arguments(self, args, env):
          myargs = ['-Werror=unknown-warning-option', '-Werror=unused-command-line-argument']
          if mesonlib.version_compare(self.version, '>=3.6.0'):
              myargs.append('-Werror=ignored-optimization-argument')
          return super().has_multi_arguments(
              myargs + args,
              env)
  
      def has_function(self, funcname, prefix, env, extra_args=None, dependencies=None):
          if extra_args is None:
              extra_args = []
          # Starting with XCode 8, we need to pass this to force linker
          # visibility to obey OS X and iOS minimum version targets with
          # -mmacosx-version-min, -miphoneos-version-min, etc.
          # https://github.com/Homebrew/homebrew-core/issues/3727
          if self.clang_type == CLANG_OSX and version_compare(self.version, '>=8.0'):
              extra_args.append('-Wl,-no_weak_imports')
          return super().has_function(funcname, prefix, env, extra_args, dependencies)
  
      def get_std_shared_module_link_args(self, options):
          if self.clang_type == CLANG_OSX:
              return ['-bundle', '-Wl,-undefined,dynamic_lookup']
          return ['-shared']
  
      def get_link_whole_for(self, args):
          if self.clang_type == CLANG_OSX:
              result = []
              for a in args:
                  result += ['-Wl,-force_load', a]
              return result
          return ['-Wl,--whole-archive'] + args + ['-Wl,--no-whole-archive']
  
      def get_instruction_set_args(self, instruction_set):
          return gnulike_instruction_set_args.get(instruction_set, None)
  
      def get_default_include_dirs(self):
          return gnulike_default_include_dirs(self.exelist, self.language)
  
      def openmp_flags(self):
          if version_compare(self.version, '>=3.8.0'):
              return ['-fopenmp']
          elif version_compare(self.version, '>=3.7.0'):
              return ['-fopenmp=libomp']
          else:
              # Shouldn't work, but it'll be checked explicitly in the OpenMP dependency.
              return []
  
  
  # Tested on linux for ICC 14.0.3, 15.0.6, 16.0.4, 17.0.1
  class IntelCompiler:
      def __init__(self, icc_type):
          self.id = 'intel'
          self.icc_type = icc_type
          self.lang_header = 'none'
          self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
                               'b_colorout', 'b_ndebug', 'b_staticpic', 'b_lundef', 'b_asneeded']
          # Assembly
          self.can_compile_suffixes.add('s')
  
      def get_pic_args(self):
          return ['-fPIC']
  
      def get_buildtype_args(self, buildtype):
          return gnulike_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          return gnulike_buildtype_linker_args[buildtype]
  
      def get_pch_suffix(self):
          return 'pchi'
  
      def get_pch_use_args(self, pch_dir, header):
          return ['-pch', '-pch_dir', os.path.join(pch_dir), '-x',
                  self.lang_header, '-include', header, '-x', 'none']
  
      def get_pch_name(self, header_name):
          return os.path.basename(header_name) + '.' + self.get_pch_suffix()
  
      def split_shlib_to_parts(self, fname):
          return os.path.dirname(fname), fname
  
      def get_soname_args(self, prefix, shlib_name, suffix, soversion, is_shared_module):
          if self.icc_type == ICC_STANDARD:
              gcc_type = GCC_STANDARD
          elif self.icc_type == ICC_OSX:
              gcc_type = GCC_OSX
          elif self.icc_type == ICC_WIN:
              gcc_type = GCC_MINGW
          else:
              raise MesonException('Unreachable code when converting icc type to gcc type.')
          return get_gcc_soname_args(gcc_type, prefix, shlib_name, suffix, soversion, is_shared_module)
  
      # TODO: centralise this policy more globally, instead
      # of fragmenting it into GnuCompiler and ClangCompiler
      def get_asneeded_args(self):
          if self.icc_type == CLANG_OSX:
              return APPLE_LD_AS_NEEDED
          else:
              return GNU_LD_AS_NEEDED
  
      def get_std_shared_lib_link_args(self):
          # FIXME: Don't know how icc works on OSX
          # if self.icc_type == ICC_OSX:
          #     return ['-bundle']
          return ['-shared']
  
      def get_default_include_dirs(self):
          return gnulike_default_include_dirs(self.exelist, self.language)
  
      def openmp_flags(self):
          if version_compare(self.version, '>=15.0.0'):
              return ['-qopenmp']
          else:
              return ['-openmp']
  
  
  class ArmCompiler:
      # Functionality that is common to all ARM family compilers.
      def __init__(self):
          if not self.is_cross:
              raise EnvironmentException('armcc supports only cross-compilation.')
          self.id = 'arm'
          default_warn_args = []
          self.warn_args = {'1': default_warn_args,
                            '2': default_warn_args + [],
                            '3': default_warn_args + []}
          # Assembly
          self.can_compile_suffixes.add('s')
  
      def can_linker_accept_rsp(self):
          return False
  
      def get_pic_args(self):
          # FIXME: Add /ropi, /rwpi, /fpic etc. qualifiers to --apcs
          return []
  
      def get_buildtype_args(self, buildtype):
          return arm_buildtype_args[buildtype]
  
      def get_buildtype_linker_args(self, buildtype):
          return arm_buildtype_linker_args[buildtype]
  
      # Override CCompiler.get_always_args
      def get_always_args(self):
          return []
  
      # Override CCompiler.get_dependency_gen_args
      def get_dependency_gen_args(self, outtarget, outfile):
          return []
  
      # Override CCompiler.get_std_shared_lib_link_args
      def get_std_shared_lib_link_args(self):
          return []
  
      def get_pch_use_args(self, pch_dir, header):
          # FIXME: Add required arguments
          # NOTE from armcc user guide:
          # "Support for Precompiled Header (PCH) files is deprecated from ARM Compiler 5.05
          # onwards on all platforms. Note that ARM Compiler on Windows 8 never supported
          # PCH files."
          return []
  
      def get_pch_suffix(self):
          # NOTE from armcc user guide:
          # "Support for Precompiled Header (PCH) files is deprecated from ARM Compiler 5.05
          # onwards on all platforms. Note that ARM Compiler on Windows 8 never supported
          # PCH files."
          return 'pch'
  
      def thread_flags(self, env):
          return []
  
      def thread_link_flags(self, env):
          return []
  
      def get_linker_exelist(self):
          args = ['armlink']
          return args
  
      def get_coverage_args(self):
          return []
  
      def get_coverage_link_args(self):
          return []
  
files: mesonbuild/compilers/compilers.py
files: # Copyright 2013-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.
  
  # This file contains the detection logic for external dependencies.
  # Custom logic for several other packages are in separate files.
  
  import copy
  import os
  import re
  import stat
  import shlex
  import shutil
  import textwrap
  from enum import Enum
  from pathlib import PurePath
  
  from .. import mlog
  from .. import mesonlib
  from ..compilers import clib_langs
  from ..mesonlib import MesonException, OrderedSet
  from ..mesonlib import Popen_safe, version_compare_many, version_compare, listify
  
  
  # These must be defined in this file to avoid cyclical references.
  packages = {}
  _packages_accept_language = set()
  
  
  class DependencyException(MesonException):
      '''Exceptions raised while trying to find dependencies'''
  
  
  class DependencyMethods(Enum):
      # Auto means to use whatever dependency checking mechanisms in whatever order meson thinks is best.
      AUTO = 'auto'
      PKGCONFIG = 'pkg-config'
      QMAKE = 'qmake'
      # Just specify the standard link arguments, assuming the operating system provides the library.
      SYSTEM = 'system'
      # This is only supported on OSX - search the frameworks directory by name.
      EXTRAFRAMEWORK = 'extraframework'
      # Detect using the sysconfig module.
      SYSCONFIG = 'sysconfig'
      # Specify using a "program"-config style tool
      CONFIG_TOOL = 'config-tool'
      # For backewards compatibility
      SDLCONFIG = 'sdlconfig'
      CUPSCONFIG = 'cups-config'
      PCAPCONFIG = 'pcap-config'
      LIBWMFCONFIG = 'libwmf-config'
  
  
  class Dependency:
      @classmethod
      def _process_method_kw(cls, kwargs):
          method = kwargs.get('method', 'auto')
          if method not in [e.value for e in DependencyMethods]:
              raise DependencyException('method {!r} is invalid'.format(method))
          method = DependencyMethods(method)
  
          # This sets per-tool config methods which are deprecated to to the new
          # generic CONFIG_TOOL value.
          if method in [DependencyMethods.SDLCONFIG, DependencyMethods.CUPSCONFIG,
                        DependencyMethods.PCAPCONFIG, DependencyMethods.LIBWMFCONFIG]:
              mlog.warning(textwrap.dedent("""\
                  Configuration method {} has been deprecated in favor of
                  'config-tool'. This will be removed in a future version of
                  meson.""".format(method)))
              method = DependencyMethods.CONFIG_TOOL
  
          # Set the detection method. If the method is set to auto, use any available method.
          # If method is set to a specific string, allow only that detection method.
          if method == DependencyMethods.AUTO:
              methods = cls.get_methods()
          elif method in cls.get_methods():
              methods = [method]
          else:
              raise DependencyException(
                  'Unsupported detection method: {}, allowed methods are {}'.format(
                      method.value,
                      mlog.format_list([x.value for x in [DependencyMethods.AUTO] + cls.get_methods()])))
  
          return methods
  
      def __init__(self, type_name, kwargs):
          self.name = "null"
          self.version = 'none'
          self.language = None # None means C-like
          self.is_found = False
          self.type_name = type_name
          self.compile_args = []
          self.link_args = []
          self.sources = []
          self.methods = self._process_method_kw(kwargs)
  
      def __repr__(self):
          s = '<{0} {1}: {2}>'
          return s.format(self.__class__.__name__, self.name, self.is_found)
  
      def get_compile_args(self):
          return self.compile_args
  
      def get_link_args(self):
          return self.link_args
  
      def found(self):
          return self.is_found
  
      def get_sources(self):
          """Source files that need to be added to the target.
          As an example, gtest-all.cc when using GTest."""
          return self.sources
  
      @staticmethod
      def get_methods():
          return [DependencyMethods.AUTO]
  
      def get_name(self):
          return self.name
  
      def get_version(self):
          return self.version
  
      def get_exe_args(self, compiler):
          return []
  
      def need_openmp(self):
          return False
  
      def need_threads(self):
          return False
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          raise DependencyException('{!r} is not a pkgconfig dependency'.format(self.name))
  
      def get_configtool_variable(self, variable_name):
          raise DependencyException('{!r} is not a config-tool dependency'.format(self.name))
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          """Create a new dependency that contains part of the parent dependency.
  
          The following options can be inherited:
              links -- all link_with arguemnts
              includes -- all include_directory and -I/-isystem calls
              sources -- any source, header, or generated sources
              compile_args -- any compile args
              link_args -- any link args
  
          Additionally the new dependency will have the version parameter of it's
          parent (if any) and the requested values of any dependencies will be
          added as well.
          """
          RuntimeError('Unreachable code in partial_dependency called')
  
  
  class InternalDependency(Dependency):
      def __init__(self, version, incdirs, compile_args, link_args, libraries, whole_libraries, sources, ext_deps):
          super().__init__('internal', {})
          self.version = version
          self.is_found = True
          self.include_directories = incdirs
          self.compile_args = compile_args
          self.link_args = link_args
          self.libraries = libraries
          self.whole_libraries = whole_libraries
          self.sources = sources
          self.ext_deps = ext_deps
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          raise DependencyException('Method "get_pkgconfig_variable()" is '
                                    'invalid for an internal dependency')
  
      def get_configtool_variable(self, variable_name):
          raise DependencyException('Method "get_configtool_variable()" is '
                                    'invalid for an internal dependency')
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          compile_args = self.compile_args.copy() if compile_args else []
          link_args = self.link_args.copy() if link_args else []
          libraries = self.libraries.copy() if links else []
          whole_libraries = self.whole_libraries.copy() if links else []
          sources = self.sources.copy() if sources else []
          includes = self.include_directories.copy() if includes else []
          deps = [d.get_partial_dependency(
              compile_args=compile_args, link_args=link_args, links=links,
              includes=includes, sources=sources) for d in self.ext_deps]
          return InternalDependency(
              self.version, includes, compile_args, link_args, libraries,
              whole_libraries, sources, deps)
  
  
  class ExternalDependency(Dependency):
      def __init__(self, type_name, environment, language, kwargs):
          super().__init__(type_name, kwargs)
          self.env = environment
          self.name = type_name # default
          self.is_found = False
          self.language = language
          self.version_reqs = kwargs.get('version', None)
          self.required = kwargs.get('required', True)
          self.silent = kwargs.get('silent', False)
          self.static = kwargs.get('static', False)
          if not isinstance(self.static, bool):
              raise DependencyException('Static keyword must be boolean')
          # Is this dependency for cross-compilation?
          if 'native' in kwargs and self.env.is_cross_build():
              self.want_cross = not kwargs['native']
          else:
              self.want_cross = self.env.is_cross_build()
          self.clib_compiler = None
          # Set the compiler that will be used by this dependency
          # This is only used for configuration checks
          if self.want_cross:
              compilers = self.env.coredata.cross_compilers
          else:
              compilers = self.env.coredata.compilers
          # Set the compiler for this dependency if a language is specified,
          # else try to pick something that looks usable.
          if self.language:
              if self.language not in compilers:
                  m = self.name.capitalize() + ' requires a {0} compiler, but ' \
                      '{0} is not in the list of project languages'
                  raise DependencyException(m.format(self.language.capitalize()))
              self.clib_compiler = compilers[self.language]
          else:
              # Try to find a compiler that can find C libraries for
              # running compiler.find_library()
              for lang in clib_langs:
                  self.clib_compiler = compilers.get(lang, None)
                  if self.clib_compiler:
                      break
  
      def get_compiler(self):
          return self.clib_compiler
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          new = copy.copy(self)
          if not compile_args:
              new.compile_args = []
          if not link_args:
              new.link_args = []
          if not sources:
              new.sources = []
  
          return new
  
  
  class NotFoundDependency(Dependency):
      def __init__(self, environment):
          super().__init__('not-found', {})
          self.env = environment
          self.name = 'not-found'
          self.is_found = False
  
  
  class ConfigToolDependency(ExternalDependency):
  
      """Class representing dependencies found using a config tool."""
  
      tools = None
      tool_name = None
      __strip_version = re.compile(r'^[0-9.]*')
  
      def __init__(self, name, environment, language, kwargs):
          super().__init__('config-tool', environment, language, kwargs)
          self.name = name
          self.native = kwargs.get('native', False)
          self.tools = listify(kwargs.get('tools', self.tools))
  
          req_version = kwargs.get('version', None)
          tool, version = self.find_config(req_version)
          self.config = tool
          self.is_found = self.report_config(version, req_version)
          if not self.is_found:
              self.config = None
              return
          self.version = version
  
      def _sanitize_version(self, version):
          """Remove any non-numeric, non-point version suffixes."""
          m = self.__strip_version.match(version)
          if m:
              # Ensure that there isn't a trailing '.', such as an input like
              # `1.2.3.git-1234`
              return m.group(0).rstrip('.')
          return version
  
      @classmethod
      def factory(cls, name, environment, language, kwargs, tools, tool_name):
          """Constructor for use in dependencies that can be found multiple ways.
  
          In addition to the standard constructor values, this constructor sets
          the tool_name and tools values of the instance.
          """
          # This deserves some explanation, because metaprogramming is hard.
          # This uses type() to create a dynamic subclass of ConfigToolDependency
          # with the tools and tool_name class attributes set, this class is then
          # instantiated and returned. The reduce function (method) is also
          # attached, since python's pickle module won't be able to do anything
          # with this dynamically generated class otherwise.
          def reduce(self):
              return (cls._unpickle, (), self.__dict__)
          sub = type('{}Dependency'.format(name.capitalize()), (cls, ),
                     {'tools': tools, 'tool_name': tool_name, '__reduce__': reduce})
  
          return sub(name, environment, language, kwargs)
  
      @classmethod
      def _unpickle(cls):
          return cls.__new__(cls)
  
      def find_config(self, versions=None):
          """Helper method that searchs for config tool binaries in PATH and
          returns the one that best matches the given version requirements.
          """
          if not isinstance(versions, list) and versions is not None:
              versions = listify(versions)
  
          if self.env.is_cross_build() and not self.native:
              cross_file = self.env.cross_info.config['binaries']
              try:
                  tools = [cross_file[self.tool_name]]
              except KeyError:
                  mlog.warning('No entry for {0} specified in your cross file. '
                               'Falling back to searching PATH. This may find a '
                               'native version of {0}!'.format(self.tool_name))
                  tools = self.tools
          else:
              tools = self.tools
  
          best_match = (None, None)
          for tool in tools:
              try:
                  p, out = Popen_safe([tool, '--version'])[:2]
              except (FileNotFoundError, PermissionError):
                  continue
              if p.returncode != 0:
                  continue
  
              out = self._sanitize_version(out.strip())
              # Some tools, like pcap-config don't supply a version, but also
              # don't fail with --version, in that case just assume that there is
              # only one version and return it.
              if not out:
                  return (tool, 'none')
              if versions:
                  is_found = version_compare_many(out, versions)[0]
                  # This allows returning a found version without a config tool,
                  # which is useful to inform the user that you found version x,
                  # but y was required.
                  if not is_found:
                      tool = None
              if best_match[1]:
                  if version_compare(out, '> {}'.format(best_match[1])):
                      best_match = (tool, out)
              else:
                  best_match = (tool, out)
  
          return best_match
  
      def report_config(self, version, req_version):
          """Helper method to print messages about the tool."""
          if self.config is None:
              if version is not None:
                  mlog.log('Found', mlog.bold(self.tool_name), repr(version),
                           mlog.red('NO'), '(needed', req_version, ')')
              else:
                  mlog.log('Found', mlog.bold(self.tool_name), repr(req_version),
                           mlog.red('NO'))
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.red('NO'))
              if self.required:
                  raise DependencyException('Dependency {} not found'.format(self.name))
              return False
          mlog.log('Found {}:'.format(self.tool_name), mlog.bold(shutil.which(self.config)),
                   '({})'.format(version))
          mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'))
          return True
  
      def get_config_value(self, args, stage):
          p, out, err = Popen_safe([self.config] + args)
          if p.returncode != 0:
              if self.required:
                  raise DependencyException(
                      'Could not generate {} for {}.\n{}'.format(
                          stage, self.name, err))
              return []
          return shlex.split(out)
  
      @staticmethod
      def get_methods():
          return [DependencyMethods.AUTO, DependencyMethods.CONFIG_TOOL]
  
      def get_configtool_variable(self, variable_name):
          p, out, _ = Popen_safe([self.config, '--{}'.format(variable_name)])
          if p.returncode != 0:
              if self.required:
                  raise DependencyException(
                      'Could not get variable "{}" for dependency {}'.format(
                          variable_name, self.name))
          variable = out.strip()
          mlog.debug('Got config-tool variable {} : {}'.format(variable_name, variable))
          return variable
  
  
  class PkgConfigDependency(ExternalDependency):
      # The class's copy of the pkg-config path. Avoids having to search for it
      # multiple times in the same Meson invocation.
      class_pkgbin = None
      # We cache all pkg-config subprocess invocations to avoid redundant calls
      pkgbin_cache = {}
  
      def __init__(self, name, environment, kwargs, language=None):
          super().__init__('pkgconfig', environment, language, kwargs)
          self.name = name
          self.is_libtool = False
          # Store a copy of the pkg-config path on the object itself so it is
          # stored in the pickled coredata and recovered.
          self.pkgbin = None
  
          # When finding dependencies for cross-compiling, we don't care about
          # the 'native' pkg-config
          if self.want_cross:
              if 'pkgconfig' not in environment.cross_info.config['binaries']:
                  if self.required:
                      raise DependencyException('Pkg-config binary missing from cross file')
              else:
                  pkgname = environment.cross_info.config['binaries']['pkgconfig']
                  potential_pkgbin = ExternalProgram(pkgname, silent=True)
                  if potential_pkgbin.found():
                      self.pkgbin = potential_pkgbin
                      PkgConfigDependency.class_pkgbin = self.pkgbin
                  else:
                      mlog.debug('Cross pkg-config %s not found.' % potential_pkgbin.name)
          # Only search for the native pkg-config the first time and
          # store the result in the class definition
          elif PkgConfigDependency.class_pkgbin is None:
              self.pkgbin = self.check_pkgconfig()
              PkgConfigDependency.class_pkgbin = self.pkgbin
          else:
              self.pkgbin = PkgConfigDependency.class_pkgbin
  
          if not self.pkgbin:
              if self.required:
                  raise DependencyException('Pkg-config not found.')
              return
          if self.want_cross:
              self.type_string = 'Cross'
          else:
              self.type_string = 'Native'
  
          mlog.debug('Determining dependency {!r} with pkg-config executable '
                     '{!r}'.format(name, self.pkgbin.get_path()))
          ret, self.version = self._call_pkgbin(['--modversion', name])
          if ret != 0:
              if self.required:
                  raise DependencyException('{} dependency {!r} not found'
                                            ''.format(self.type_string, name))
              return
          found_msg = [self.type_string + ' dependency', mlog.bold(name), 'found:']
          if self.version_reqs is None:
              self.is_found = True
          else:
              if not isinstance(self.version_reqs, (str, list)):
                  raise DependencyException('Version argument must be string or list.')
              if isinstance(self.version_reqs, str):
                  self.version_reqs = [self.version_reqs]
              (self.is_found, not_found, found) = \
                  version_compare_many(self.version, self.version_reqs)
              if not self.is_found:
                  found_msg += [mlog.red('NO'),
                                'found {!r} but need:'.format(self.version),
                                ', '.join(["'{}'".format(e) for e in not_found])]
                  if found:
                      found_msg += ['; matched:',
                                    ', '.join(["'{}'".format(e) for e in found])]
                  if not self.silent:
                      mlog.log(*found_msg)
                  if self.required:
                      m = 'Invalid version of dependency, need {!r} {!r} found {!r}.'
                      raise DependencyException(m.format(name, not_found, self.version))
                  return
  
          try:
              # Fetch cargs to be used while using this dependency
              self._set_cargs()
              # Fetch the libraries and library paths needed for using this
              self._set_libs()
              found_msg += [mlog.green('YES'), self.version]
          except DependencyException as e:
              if self.required:
                  raise
              else:
                  self.compile_args = []
                  self.link_args = []
                  self.is_found = False
                  found_msg += [mlog.red('NO'), '; reason: {}'.format(str(e))]
  
          # Print the found message only at the very end because fetching cflags
          # and libs can also fail if other needed pkg-config files aren't found.
          if not self.silent:
              mlog.log(*found_msg)
  
      def __repr__(self):
          s = '<{0} {1}: {2} {3}>'
          return s.format(self.__class__.__name__, self.name, self.is_found,
                          self.version_reqs)
  
      def _call_pkgbin_real(self, args, env):
          p, out = Popen_safe(self.pkgbin.get_command() + args, env=env)[0:2]
          return p.returncode, out.strip()
  
      def _call_pkgbin(self, args, env=None):
          if env is None:
              fenv = env
              env = os.environ
          else:
              fenv = frozenset(env.items())
          targs = tuple(args)
          cache = PkgConfigDependency.pkgbin_cache
          if (self.pkgbin, targs, fenv) not in cache:
              cache[(self.pkgbin, targs, fenv)] = self._call_pkgbin_real(args, env)
          return cache[(self.pkgbin, targs, fenv)]
  
      def _convert_mingw_paths(self, args):
          '''
          Both MSVC and native Python on Windows cannot handle MinGW-esque /c/foo
          paths so convert them to C:/foo. We cannot resolve other paths starting
          with / like /home/foo so leave them as-is so that the user gets an
          error/warning from the compiler/linker.
          '''
          if not mesonlib.is_windows():
              return args
          converted = []
          for arg in args:
              pargs = []
              # Library search path
              if arg.startswith('-L/'):
                  pargs = PurePath(arg[2:]).parts
                  tmpl = '-L{}:/{}'
              elif arg.startswith('-I/'):
                  pargs = PurePath(arg[2:]).parts
                  tmpl = '-I{}:/{}'
              # Full path to library or .la file
              elif arg.startswith('/'):
                  pargs = PurePath(arg).parts
                  tmpl = '{}:/{}'
              if len(pargs) > 1 and len(pargs[1]) == 1:
                  arg = tmpl.format(pargs[1], '/'.join(pargs[2:]))
              converted.append(arg)
          return converted
  
      def _set_cargs(self):
          env = None
          if self.language == 'fortran':
              # gfortran doesn't appear to look in system paths for INCLUDE files,
              # so don't allow pkg-config to suppress -I flags for system paths
              env = os.environ.copy()
              env['PKG_CONFIG_ALLOW_SYSTEM_CFLAGS'] = '1'
          ret, out = self._call_pkgbin(['--cflags', self.name], env=env)
          if ret != 0:
              raise DependencyException('Could not generate cargs for %s:\n\n%s' %
                                        (self.name, out))
          self.compile_args = self._convert_mingw_paths(shlex.split(out))
  
      def _set_libs(self):
          env = None
          libcmd = [self.name, '--libs']
          if self.static:
              libcmd.append('--static')
          # Force pkg-config to output -L fields even if they are system
          # paths so we can do manual searching with cc.find_library() later.
          env = os.environ.copy()
          env['PKG_CONFIG_ALLOW_SYSTEM_LIBS'] = '1'
          ret, out = self._call_pkgbin(libcmd, env=env)
          if ret != 0:
              raise DependencyException('Could not generate libs for %s:\n\n%s' %
                                        (self.name, out))
          # These libraries should be safe to de-dup
          link_args = OrderedSet()
          libpaths = OrderedSet()
          libs_notfound = []
          libtype = 'static' if self.static else 'default'
          # We always look for the file ourselves instead of depending on the
          # compiler to find it with -lfoo or foo.lib (if possible) because:
          # 1. We want to be able to select static or shared
          # 2. We need the full path of the library to calculate RPATH values
          #
          # Libraries that are provided by the toolchain or are not found by
          # find_library() will be added with -L -l pairs.
          for lib in self._convert_mingw_paths(shlex.split(out)):
              if lib.startswith('-L'):
                  libpaths.add(lib[2:])
                  continue
              elif lib.startswith('-l'):
                  if self.clib_compiler:
                      args = self.clib_compiler.find_library(lib[2:], self.env,
                                                             list(libpaths), libtype)
                  # If the project only uses a non-clib language such as D, Rust,
                  # C#, Python, etc, all we can do is limp along.
                  else:
                      args = None
                  if args:
                      # Replace -l arg with full path to library if available
                      if not args[0].startswith('-l'):
                          lib = args[0]
                      # else, library is provided by the compiler and can't be resolved
                  else:
                      # Library wasn't found, maybe we're looking in the wrong
                      # places or the library will be provided with LDFLAGS or
                      # LIBRARY_PATH from the environment (on macOS), and many
                      # other edge cases that we can't account for.
                      #
                      # Add all -L paths and use it as -lfoo
                      if lib in libs_notfound:
                          continue
                      if self.static:
                          mlog.warning('Static library {!r} not found for dependency {!r}, may '
                                       'not be statically linked'.format(lib[2:], self.name))
                      libs_notfound.append(lib)
              elif lib.endswith(".la"):
                  shared_libname = self.extract_libtool_shlib(lib)
                  shared_lib = os.path.join(os.path.dirname(lib), shared_libname)
                  if not os.path.exists(shared_lib):
                      shared_lib = os.path.join(os.path.dirname(lib), ".libs", shared_libname)
  
                  if not os.path.exists(shared_lib):
                      raise DependencyException('Got a libtools specific "%s" dependencies'
                                                'but we could not compute the actual shared'
                                                'library path' % lib)
                  lib = shared_lib
                  self.is_libtool = True
              link_args.add(lib)
          self.link_args = list(link_args)
          # Add all -Lbar args if we have -lfoo args in link_args
          if libs_notfound:
              # Order of -L flags doesn't matter with ld, but it might with other
              # linkers such as MSVC, so prepend them.
              self.link_args = ['-L' + lp for lp in libpaths] + self.link_args
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          options = ['--variable=' + variable_name, self.name]
  
          if 'define_variable' in kwargs:
              definition = kwargs.get('define_variable', [])
              if not isinstance(definition, list):
                  raise MesonException('define_variable takes a list')
  
              if len(definition) != 2 or not all(isinstance(i, str) for i in definition):
                  raise MesonException('define_variable must be made up of 2 strings for VARIABLENAME and VARIABLEVALUE')
  
              options = ['--define-variable=' + '='.join(definition)] + options
  
          ret, out = self._call_pkgbin(options)
          variable = ''
          if ret != 0:
              if self.required:
                  raise DependencyException('%s dependency %s not found.' %
                                            (self.type_string, self.name))
          else:
              variable = out.strip()
  
              # pkg-config doesn't distinguish between empty and non-existent variables
              # use the variable list to check for variable existence
              if not variable:
                  ret, out = self._call_pkgbin(['--print-variables', self.name])
                  if not re.search(r'^' + variable_name + r'$', out, re.MULTILINE):
                      if 'default' in kwargs:
                          variable = kwargs['default']
                      else:
                          mlog.warning("pkgconfig variable '%s' not defined for dependency %s." % (variable_name, self.name))
  
          mlog.debug('Got pkgconfig variable %s : %s' % (variable_name, variable))
          return variable
  
      @staticmethod
      def get_methods():
          return [DependencyMethods.PKGCONFIG]
  
      def check_pkgconfig(self):
          evar = 'PKG_CONFIG'
          if evar in os.environ:
              pkgbin = os.environ[evar].strip()
          else:
              pkgbin = 'pkg-config'
          pkgbin = ExternalProgram(pkgbin, silent=True)
          if pkgbin.found():
              try:
                  p, out = Popen_safe(pkgbin.get_command() + ['--version'])[0:2]
                  if p.returncode != 0:
                      mlog.warning('Found pkg-config {!r} but couldn\'t run it'
                                   ''.format(' '.join(pkgbin.get_command())))
                      # Set to False instead of None to signify that we've already
                      # searched for it and not found it
                      pkgbin = False
              except (FileNotFoundError, PermissionError):
                  pkgbin = False
          else:
              pkgbin = False
          if not self.silent:
              if pkgbin:
                  mlog.log('Found pkg-config:', mlog.bold(pkgbin.get_path()),
                           '(%s)' % out.strip())
              else:
                  mlog.log('Found Pkg-config:', mlog.red('NO'))
          return pkgbin
  
      def extract_field(self, la_file, fieldname):
          with open(la_file) as f:
              for line in f:
                  arr = line.strip().split('=')
                  if arr[0] == fieldname:
                      return arr[1][1:-1]
          return None
  
      def extract_dlname_field(self, la_file):
          return self.extract_field(la_file, 'dlname')
  
      def extract_libdir_field(self, la_file):
          return self.extract_field(la_file, 'libdir')
  
      def extract_libtool_shlib(self, la_file):
          '''
          Returns the path to the shared library
          corresponding to this .la file
          '''
          dlname = self.extract_dlname_field(la_file)
          if dlname is None:
              return None
  
          # Darwin uses absolute paths where possible; since the libtool files never
          # contain absolute paths, use the libdir field
          if mesonlib.is_osx():
              dlbasename = os.path.basename(dlname)
              libdir = self.extract_libdir_field(la_file)
              if libdir is None:
                  return dlbasename
              return os.path.join(libdir, dlbasename)
          # From the comments in extract_libtool(), older libtools had
          # a path rather than the raw dlname
          return os.path.basename(dlname)
  
  
  class ExternalProgram:
      windows_exts = ('exe', 'msc', 'com', 'bat', 'cmd')
  
      def __init__(self, name, command=None, silent=False, search_dir=None):
          self.name = name
          if command is not None:
              self.command = listify(command)
          else:
              self.command = self._search(name, search_dir)
  
          # Set path to be the last item that is actually a file (in order to
          # skip options in something like ['python', '-u', 'file.py']. If we
          # can't find any components, default to the last component of the path.
          self.path = self.command[-1]
          for i in range(len(self.command) - 1, -1, -1):
              arg = self.command[i]
              if arg is not None and os.path.isfile(arg):
                  self.path = arg
                  break
  
          if not silent:
              if self.found():
                  mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
                           '(%s)' % ' '.join(self.command))
              else:
                  mlog.log('Program', mlog.bold(name), 'found:', mlog.red('NO'))
  
      def __repr__(self):
          r = '<{} {!r} -> {!r}>'
          return r.format(self.__class__.__name__, self.name, self.command)
  
      @staticmethod
      def _shebang_to_cmd(script):
          """
          Check if the file has a shebang and manually parse it to figure out
          the interpreter to use. This is useful if the script is not executable
          or if we're on Windows (which does not understand shebangs).
          """
          try:
              with open(script) as f:
                  first_line = f.readline().strip()
              if first_line.startswith('#!'):
                  # In a shebang, everything before the first space is assumed to
                  # be the command to run and everything after the first space is
                  # the single argument to pass to that command. So we must split
                  # exactly once.
                  commands = first_line[2:].split('#')[0].strip().split(maxsplit=1)
                  if mesonlib.is_windows():
                      # Windows does not have UNIX paths so remove them,
                      # but don't remove Windows paths
                      if commands[0].startswith('/'):
                          commands[0] = commands[0].split('/')[-1]
                      if len(commands) > 0 and commands[0] == 'env':
                          commands = commands[1:]
                      # Windows does not ship python3.exe, but we know the path to it
                      if len(commands) > 0 and commands[0] == 'python3':
                          commands = mesonlib.python_command + commands[1:]
                  elif mesonlib.is_haiku():
                      # Haiku does not have /usr, but a lot of scripts assume that
                      # /usr/bin/env always exists. Detect that case and run the
                      # script with the interpreter after it.
                      if commands[0] == '/usr/bin/env':
                          commands = commands[1:]
                      # We know what python3 is, we're running on it
                      if len(commands) > 0 and commands[0] == 'python3':
                          commands = mesonlib.python_command + commands[1:]
                  return commands + [script]
          except Exception as e:
              mlog.debug(e)
              pass
          mlog.debug('Unusable script {!r}'.format(script))
          return False
  
      def _is_executable(self, path):
          suffix = os.path.splitext(path)[-1].lower()[1:]
          if mesonlib.is_windows():
              if suffix in self.windows_exts:
                  return True
          elif os.access(path, os.X_OK):
              return not os.path.isdir(path)
          return False
  
      def _search_dir(self, name, search_dir):
          if search_dir is None:
              return False
          trial = os.path.join(search_dir, name)
          if os.path.exists(trial):
              if self._is_executable(trial):
                  return [trial]
              # Now getting desperate. Maybe it is a script file that is
              # a) not chmodded executable, or
              # b) we are on windows so they can't be directly executed.
              return self._shebang_to_cmd(trial)
          else:
              if mesonlib.is_windows():
                  for ext in self.windows_exts:
                      trial_ext = '{}.{}'.format(trial, ext)
                      if os.path.exists(trial_ext):
                          return [trial_ext]
          return False
  
      def _search_windows_special_cases(self, name, command):
          '''
          Lots of weird Windows quirks:
          1. PATH search for @name returns files with extensions from PATHEXT,
             but only self.windows_exts are executable without an interpreter.
          2. @name might be an absolute path to an executable, but without the
             extension. This works inside MinGW so people use it a lot.
          3. The script is specified without an extension, in which case we have
             to manually search in PATH.
          4. More special-casing for the shebang inside the script.
          '''
          if command:
              # On Windows, even if the PATH search returned a full path, we can't be
              # sure that it can be run directly if it's not a native executable.
              # For instance, interpreted scripts sometimes need to be run explicitly
              # with an interpreter if the file association is not done properly.
              name_ext = os.path.splitext(command)[1]
              if name_ext[1:].lower() in self.windows_exts:
                  # Good, it can be directly executed
                  return [command]
              # Try to extract the interpreter from the shebang
              commands = self._shebang_to_cmd(command)
              if commands:
                  return commands
              return [None]
          # Maybe the name is an absolute path to a native Windows
          # executable, but without the extension. This is technically wrong,
          # but many people do it because it works in the MinGW shell.
          if os.path.isabs(name):
              for ext in self.windows_exts:
                  command = '{}.{}'.format(name, ext)
                  if os.path.exists(command):
                      return [command]
          # On Windows, interpreted scripts must have an extension otherwise they
          # cannot be found by a standard PATH search. So we do a custom search
          # where we manually search for a script with a shebang in PATH.
          search_dirs = os.environ.get('PATH', '').split(';')
          for search_dir in search_dirs:
              commands = self._search_dir(name, search_dir)
              if commands:
                  return commands
          return [None]
  
      def _search(self, name, search_dir):
          '''
          Search in the specified dir for the specified executable by name
          and if not found search in PATH
          '''
          commands = self._search_dir(name, search_dir)
          if commands:
              return commands
          # Do a standard search in PATH
          command = shutil.which(name)
          if mesonlib.is_windows():
              return self._search_windows_special_cases(name, command)
          # On UNIX-like platforms, shutil.which() is enough to find
          # all executables whether in PATH or with an absolute path
          return [command]
  
      def found(self):
          return self.command[0] is not None
  
      def get_command(self):
          return self.command[:]
  
      def get_path(self):
          return self.path
  
      def get_name(self):
          return self.name
  
  class NonExistingExternalProgram(ExternalProgram):
  
      def __init__(self):
          super().__init__(name = 'nonexistingprogram', silent = True)
  
      def __repr__(self):
          r = '<{} {!r} -> {!r}>'
          return r.format(self.__class__.__name__, self.name, self.command)
  
      def found(self):
          return False
  
  class ExternalLibrary(ExternalDependency):
      def __init__(self, name, link_args, environment, language, silent=False):
          super().__init__('external', environment, language, {})
          self.name = name
          self.language = language
          self.is_found = False
          if link_args:
              self.is_found = True
              self.link_args = link_args
          if not silent:
              if self.is_found:
                  mlog.log('Library', mlog.bold(name), 'found:', mlog.green('YES'))
              else:
                  mlog.log('Library', mlog.bold(name), 'found:', mlog.red('NO'))
  
      def get_link_args(self, language=None):
          '''
          External libraries detected using a compiler must only be used with
          compatible code. For instance, Vala libraries (.vapi files) cannot be
          used with C code, and not all Rust library types can be linked with
          C-like code. Note that C++ libraries *can* be linked with C code with
          a C++ linker (and vice-versa).
          '''
          # Using a vala library in a non-vala target, or a non-vala library in a vala target
          # XXX: This should be extended to other non-C linkers such as Rust
          if (self.language == 'vala' and language != 'vala') or \
             (language == 'vala' and self.language != 'vala'):
              return []
          return self.link_args
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          # External library only has link_args, so ignore the rest of the
          # interface.
          new = copy.copy(self)
          if not link_args:
              new.link_args = []
          return new
  
  
  class ExtraFrameworkDependency(ExternalDependency):
      def __init__(self, name, required, path, env, lang, kwargs):
          super().__init__('extraframeworks', env, lang, kwargs)
          self.name = None
          self.required = required
          self.detect(name, path)
          if self.found():
              mlog.log('Dependency', mlog.bold(name), 'found:', mlog.green('YES'),
                       os.path.join(self.path, self.name))
          else:
              mlog.log('Dependency', name, 'found:', mlog.red('NO'))
  
      def detect(self, name, path):
          lname = name.lower()
          if path is None:
              paths = ['/System/Library/Frameworks', '/Library/Frameworks']
          else:
              paths = [path]
          for p in paths:
              for d in os.listdir(p):
                  fullpath = os.path.join(p, d)
                  if lname != d.split('.')[0].lower():
                      continue
                  if not stat.S_ISDIR(os.stat(fullpath).st_mode):
                      continue
                  self.path = p
                  self.name = d
                  self.is_found = True
                  return
          if not self.found() and self.required:
              raise DependencyException('Framework dependency %s not found.' % (name, ))
  
      def get_compile_args(self):
          if self.found():
              return ['-I' + os.path.join(self.path, self.name, 'Headers')]
          return []
  
      def get_link_args(self):
          if self.found():
              return ['-F' + self.path, '-framework', self.name.split('.')[0]]
          return []
  
      def get_version(self):
          return 'unknown'
  
  
  def get_dep_identifier(name, kwargs, want_cross):
      # Need immutable objects since the identifier will be used as a dict key
      version_reqs = listify(kwargs.get('version', []))
      if isinstance(version_reqs, list):
          version_reqs = frozenset(version_reqs)
      identifier = (name, version_reqs, want_cross)
      for key, value in kwargs.items():
          # 'version' is embedded above as the second element for easy access
          # 'native' is handled above with `want_cross`
          # 'required' is irrelevant for caching; the caller handles it separately
          # 'fallback' subprojects cannot be cached -- they must be initialized
          if key in ('version', 'native', 'required', 'fallback',):
              continue
          # All keyword arguments are strings, ints, or lists (or lists of lists)
          if isinstance(value, list):
              value = frozenset(listify(value))
          identifier += (key, value)
      return identifier
  
  
  def find_external_dependency(name, env, kwargs):
      required = kwargs.get('required', True)
      if not isinstance(required, bool):
          raise DependencyException('Keyword "required" must be a boolean.')
      if not isinstance(kwargs.get('method', ''), str):
          raise DependencyException('Keyword "method" must be a string.')
      lname = name.lower()
      if lname in packages:
          if lname not in _packages_accept_language and 'language' in kwargs:
              raise DependencyException('%s dependency does not accept "language" keyword argument' % (lname, ))
          # Create the dependency object using a factory class method, if one
          # exists, otherwise it is just constructed directly.
          if getattr(packages[lname], '_factory', None):
              dep = packages[lname]._factory(env, kwargs)
          else:
              dep = packages[lname](env, kwargs)
          if required and not dep.found():
              raise DependencyException('Dependency "%s" not found' % name)
          return dep
      if 'language' in kwargs:
          # Remove check when PkgConfigDependency supports language.
          raise DependencyException('%s dependency does not accept "language" keyword argument' % (lname, ))
      pkg_exc = None
      pkgdep = None
      try:
          pkgdep = PkgConfigDependency(name, env, kwargs)
          if pkgdep.found():
              return pkgdep
      except Exception as e:
          pkg_exc = e
      if mesonlib.is_osx():
          fwdep = ExtraFrameworkDependency(name, False, None, env, None, kwargs)
          if required and not fwdep.found():
              m = 'Dependency {!r} not found, tried Extra Frameworks ' \
                  'and Pkg-Config:\n\n' + str(pkg_exc)
              raise DependencyException(m.format(name))
          return fwdep
      if pkg_exc is not None:
          raise pkg_exc
      mlog.log('Dependency', mlog.bold(name), 'found:', mlog.red('NO'))
      return pkgdep
  
  
  def strip_system_libdirs(environment, link_args):
      """Remove -L<system path> arguments.
  
      leaving these in will break builds where a user has a version of a library
      in the system path, and a different version not in the system path if they
      want to link against the non-system path version.
      """
      exclude = {'-L{}'.format(p) for p in environment.get_compiler_system_dirs()}
      return [l for l in link_args if l not in exclude]
  
files: mesonbuild/dependencies/base.py
files: # Copyright 2013-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.
  
  # This file contains the detection logic for external dependencies.
  # Custom logic for several other packages are in separate files.
  
  import copy
  import os
  import re
  import stat
  import shlex
  import shutil
  import textwrap
  from enum import Enum
  from pathlib import PurePath
  
  from .. import mlog
  from .. import mesonlib
  from ..compilers import clib_langs, clike_langs
  from ..mesonlib import MesonException, OrderedSet
  from ..mesonlib import Popen_safe, version_compare_many, version_compare, listify
  
  
  # These must be defined in this file to avoid cyclical references.
  packages = {}
  _packages_accept_language = set()
  
  
  class DependencyException(MesonException):
      '''Exceptions raised while trying to find dependencies'''
  
  
  class DependencyMethods(Enum):
      # Auto means to use whatever dependency checking mechanisms in whatever order meson thinks is best.
      AUTO = 'auto'
      PKGCONFIG = 'pkg-config'
      QMAKE = 'qmake'
      # Just specify the standard link arguments, assuming the operating system provides the library.
      SYSTEM = 'system'
      # This is only supported on OSX - search the frameworks directory by name.
      EXTRAFRAMEWORK = 'extraframework'
      # Detect using the sysconfig module.
      SYSCONFIG = 'sysconfig'
      # Specify using a "program"-config style tool
      CONFIG_TOOL = 'config-tool'
      # For backewards compatibility
      SDLCONFIG = 'sdlconfig'
      CUPSCONFIG = 'cups-config'
      PCAPCONFIG = 'pcap-config'
      LIBWMFCONFIG = 'libwmf-config'
  
  
  class Dependency:
      @classmethod
      def _process_method_kw(cls, kwargs):
          method = kwargs.get('method', 'auto')
          if method not in [e.value for e in DependencyMethods]:
              raise DependencyException('method {!r} is invalid'.format(method))
          method = DependencyMethods(method)
  
          # This sets per-tool config methods which are deprecated to to the new
          # generic CONFIG_TOOL value.
          if method in [DependencyMethods.SDLCONFIG, DependencyMethods.CUPSCONFIG,
                        DependencyMethods.PCAPCONFIG, DependencyMethods.LIBWMFCONFIG]:
              mlog.warning(textwrap.dedent("""\
                  Configuration method {} has been deprecated in favor of
                  'config-tool'. This will be removed in a future version of
                  meson.""".format(method)))
              method = DependencyMethods.CONFIG_TOOL
  
          # Set the detection method. If the method is set to auto, use any available method.
          # If method is set to a specific string, allow only that detection method.
          if method == DependencyMethods.AUTO:
              methods = cls.get_methods()
          elif method in cls.get_methods():
              methods = [method]
          else:
              raise DependencyException(
                  'Unsupported detection method: {}, allowed methods are {}'.format(
                      method.value,
                      mlog.format_list([x.value for x in [DependencyMethods.AUTO] + cls.get_methods()])))
  
          return methods
  
      def __init__(self, type_name, kwargs):
          self.name = "null"
          self.version = 'none'
          self.language = None # None means C-like
          self.is_found = False
          self.type_name = type_name
          self.compile_args = []
          self.link_args = []
          self.sources = []
          self.methods = self._process_method_kw(kwargs)
  
      def __repr__(self):
          s = '<{0} {1}: {2}>'
          return s.format(self.__class__.__name__, self.name, self.is_found)
  
      def get_compile_args(self):
          return self.compile_args
  
      def get_link_args(self):
          return self.link_args
  
      def found(self):
          return self.is_found
  
      def get_sources(self):
          """Source files that need to be added to the target.
          As an example, gtest-all.cc when using GTest."""
          return self.sources
  
      @staticmethod
      def get_methods():
          return [DependencyMethods.AUTO]
  
      def get_name(self):
          return self.name
  
      def get_version(self):
          return self.version
  
      def get_exe_args(self, compiler):
          return []
  
      def need_openmp(self):
          return False
  
      def need_threads(self):
          return False
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          raise DependencyException('{!r} is not a pkgconfig dependency'.format(self.name))
  
      def get_configtool_variable(self, variable_name):
          raise DependencyException('{!r} is not a config-tool dependency'.format(self.name))
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          """Create a new dependency that contains part of the parent dependency.
  
          The following options can be inherited:
              links -- all link_with arguemnts
              includes -- all include_directory and -I/-isystem calls
              sources -- any source, header, or generated sources
              compile_args -- any compile args
              link_args -- any link args
  
          Additionally the new dependency will have the version parameter of it's
          parent (if any) and the requested values of any dependencies will be
          added as well.
          """
          RuntimeError('Unreachable code in partial_dependency called')
  
  
  class InternalDependency(Dependency):
      def __init__(self, version, incdirs, compile_args, link_args, libraries, whole_libraries, sources, ext_deps):
          super().__init__('internal', {})
          self.version = version
          self.is_found = True
          self.include_directories = incdirs
          self.compile_args = compile_args
          self.link_args = link_args
          self.libraries = libraries
          self.whole_libraries = whole_libraries
          self.sources = sources
          self.ext_deps = ext_deps
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          raise DependencyException('Method "get_pkgconfig_variable()" is '
                                    'invalid for an internal dependency')
  
      def get_configtool_variable(self, variable_name):
          raise DependencyException('Method "get_configtool_variable()" is '
                                    'invalid for an internal dependency')
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          compile_args = self.compile_args.copy() if compile_args else []
          link_args = self.link_args.copy() if link_args else []
          libraries = self.libraries.copy() if links else []
          whole_libraries = self.whole_libraries.copy() if links else []
          sources = self.sources.copy() if sources else []
          includes = self.include_directories.copy() if includes else []
          deps = [d.get_partial_dependency(
              compile_args=compile_args, link_args=link_args, links=links,
              includes=includes, sources=sources) for d in self.ext_deps]
          return InternalDependency(
              self.version, includes, compile_args, link_args, libraries,
              whole_libraries, sources, deps)
  
  
  class ExternalDependency(Dependency):
      def __init__(self, type_name, environment, language, kwargs):
          super().__init__(type_name, kwargs)
          self.env = environment
          self.name = type_name # default
          self.is_found = False
          self.language = language
          self.version_reqs = kwargs.get('version', None)
          self.required = kwargs.get('required', True)
          self.silent = kwargs.get('silent', False)
          self.static = kwargs.get('static', False)
          if not isinstance(self.static, bool):
              raise DependencyException('Static keyword must be boolean')
          # Is this dependency for cross-compilation?
          if 'native' in kwargs and self.env.is_cross_build():
              self.want_cross = not kwargs['native']
          else:
              self.want_cross = self.env.is_cross_build()
          self.clib_compiler = None
          # Set the compiler that will be used by this dependency
          # This is only used for configuration checks
          if self.want_cross:
              compilers = self.env.coredata.cross_compilers
          else:
              compilers = self.env.coredata.compilers
          # Set the compiler for this dependency if a language is specified,
          # else try to pick something that looks usable.
          if self.language:
              if self.language not in compilers:
                  m = self.name.capitalize() + ' requires a {0} compiler, but ' \
                      '{0} is not in the list of project languages'
                  raise DependencyException(m.format(self.language.capitalize()))
              self.clib_compiler = compilers[self.language]
          else:
              # Try to find a compiler that can find C libraries for
              # running compiler.find_library()
              for lang in clib_langs:
                  self.clib_compiler = compilers.get(lang, None)
                  if self.clib_compiler:
                      break
  
      def get_compiler(self):
          return self.clib_compiler
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          new = copy.copy(self)
          if not compile_args:
              new.compile_args = []
          if not link_args:
              new.link_args = []
          if not sources:
              new.sources = []
  
          return new
  
  
  class NotFoundDependency(Dependency):
      def __init__(self, environment):
          super().__init__('not-found', {})
          self.env = environment
          self.name = 'not-found'
          self.is_found = False
  
  
  class ConfigToolDependency(ExternalDependency):
  
      """Class representing dependencies found using a config tool."""
  
      tools = None
      tool_name = None
      __strip_version = re.compile(r'^[0-9.]*')
  
      def __init__(self, name, environment, language, kwargs):
          super().__init__('config-tool', environment, language, kwargs)
          self.name = name
          self.native = kwargs.get('native', False)
          self.tools = listify(kwargs.get('tools', self.tools))
  
          req_version = kwargs.get('version', None)
          tool, version = self.find_config(req_version)
          self.config = tool
          self.is_found = self.report_config(version, req_version)
          if not self.is_found:
              self.config = None
              return
          self.version = version
  
      def _sanitize_version(self, version):
          """Remove any non-numeric, non-point version suffixes."""
          m = self.__strip_version.match(version)
          if m:
              # Ensure that there isn't a trailing '.', such as an input like
              # `1.2.3.git-1234`
              return m.group(0).rstrip('.')
          return version
  
      @classmethod
      def factory(cls, name, environment, language, kwargs, tools, tool_name):
          """Constructor for use in dependencies that can be found multiple ways.
  
          In addition to the standard constructor values, this constructor sets
          the tool_name and tools values of the instance.
          """
          # This deserves some explanation, because metaprogramming is hard.
          # This uses type() to create a dynamic subclass of ConfigToolDependency
          # with the tools and tool_name class attributes set, this class is then
          # instantiated and returned. The reduce function (method) is also
          # attached, since python's pickle module won't be able to do anything
          # with this dynamically generated class otherwise.
          def reduce(self):
              return (cls._unpickle, (), self.__dict__)
          sub = type('{}Dependency'.format(name.capitalize()), (cls, ),
                     {'tools': tools, 'tool_name': tool_name, '__reduce__': reduce})
  
          return sub(name, environment, language, kwargs)
  
      @classmethod
      def _unpickle(cls):
          return cls.__new__(cls)
  
      def find_config(self, versions=None):
          """Helper method that searchs for config tool binaries in PATH and
          returns the one that best matches the given version requirements.
          """
          if not isinstance(versions, list) and versions is not None:
              versions = listify(versions)
  
          if self.env.is_cross_build() and not self.native:
              cross_file = self.env.cross_info.config['binaries']
              try:
                  tools = [cross_file[self.tool_name]]
              except KeyError:
                  mlog.warning('No entry for {0} specified in your cross file. '
                               'Falling back to searching PATH. This may find a '
                               'native version of {0}!'.format(self.tool_name))
                  tools = self.tools
          else:
              tools = self.tools
  
          best_match = (None, None)
          for tool in tools:
              try:
                  p, out = Popen_safe([tool, '--version'])[:2]
              except (FileNotFoundError, PermissionError):
                  continue
              if p.returncode != 0:
                  continue
  
              out = self._sanitize_version(out.strip())
              # Some tools, like pcap-config don't supply a version, but also
              # don't fail with --version, in that case just assume that there is
              # only one version and return it.
              if not out:
                  return (tool, 'none')
              if versions:
                  is_found = version_compare_many(out, versions)[0]
                  # This allows returning a found version without a config tool,
                  # which is useful to inform the user that you found version x,
                  # but y was required.
                  if not is_found:
                      tool = None
              if best_match[1]:
                  if version_compare(out, '> {}'.format(best_match[1])):
                      best_match = (tool, out)
              else:
                  best_match = (tool, out)
  
          return best_match
  
      def report_config(self, version, req_version):
          """Helper method to print messages about the tool."""
          if self.config is None:
              if version is not None:
                  mlog.log('Found', mlog.bold(self.tool_name), repr(version),
                           mlog.red('NO'), '(needed', req_version, ')')
              else:
                  mlog.log('Found', mlog.bold(self.tool_name), repr(req_version),
                           mlog.red('NO'))
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.red('NO'))
              if self.required:
                  raise DependencyException('Dependency {} not found'.format(self.name))
              return False
          mlog.log('Found {}:'.format(self.tool_name), mlog.bold(shutil.which(self.config)),
                   '({})'.format(version))
          mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'))
          return True
  
      def get_config_value(self, args, stage):
          p, out, err = Popen_safe([self.config] + args)
          if p.returncode != 0:
              if self.required:
                  raise DependencyException(
                      'Could not generate {} for {}.\n{}'.format(
                          stage, self.name, err))
              return []
          return shlex.split(out)
  
      @staticmethod
      def get_methods():
          return [DependencyMethods.AUTO, DependencyMethods.CONFIG_TOOL]
  
      def get_configtool_variable(self, variable_name):
          p, out, _ = Popen_safe([self.config, '--{}'.format(variable_name)])
          if p.returncode != 0:
              if self.required:
                  raise DependencyException(
                      'Could not get variable "{}" for dependency {}'.format(
                          variable_name, self.name))
          variable = out.strip()
          mlog.debug('Got config-tool variable {} : {}'.format(variable_name, variable))
          return variable
  
  
  class PkgConfigDependency(ExternalDependency):
      # The class's copy of the pkg-config path. Avoids having to search for it
      # multiple times in the same Meson invocation.
      class_pkgbin = None
      # We cache all pkg-config subprocess invocations to avoid redundant calls
      pkgbin_cache = {}
  
      def __init__(self, name, environment, kwargs, language=None):
          super().__init__('pkgconfig', environment, language, kwargs)
          self.name = name
          self.is_libtool = False
          # Store a copy of the pkg-config path on the object itself so it is
          # stored in the pickled coredata and recovered.
          self.pkgbin = None
  
          # When finding dependencies for cross-compiling, we don't care about
          # the 'native' pkg-config
          if self.want_cross:
              if 'pkgconfig' not in environment.cross_info.config['binaries']:
                  if self.required:
                      raise DependencyException('Pkg-config binary missing from cross file')
              else:
                  pkgname = environment.cross_info.config['binaries']['pkgconfig']
                  potential_pkgbin = ExternalProgram(pkgname, silent=True)
                  if potential_pkgbin.found():
                      self.pkgbin = potential_pkgbin
                      PkgConfigDependency.class_pkgbin = self.pkgbin
                  else:
                      mlog.debug('Cross pkg-config %s not found.' % potential_pkgbin.name)
          # Only search for the native pkg-config the first time and
          # store the result in the class definition
          elif PkgConfigDependency.class_pkgbin is None:
              self.pkgbin = self.check_pkgconfig()
              PkgConfigDependency.class_pkgbin = self.pkgbin
          else:
              self.pkgbin = PkgConfigDependency.class_pkgbin
  
          if not self.pkgbin:
              if self.required:
                  raise DependencyException('Pkg-config not found.')
              return
          if self.want_cross:
              self.type_string = 'Cross'
          else:
              self.type_string = 'Native'
  
          mlog.debug('Determining dependency {!r} with pkg-config executable '
                     '{!r}'.format(name, self.pkgbin.get_path()))
          ret, self.version = self._call_pkgbin(['--modversion', name])
          if ret != 0:
              if self.required:
                  raise DependencyException('{} dependency {!r} not found'
                                            ''.format(self.type_string, name))
              return
          found_msg = [self.type_string + ' dependency', mlog.bold(name), 'found:']
          if self.version_reqs is None:
              self.is_found = True
          else:
              if not isinstance(self.version_reqs, (str, list)):
                  raise DependencyException('Version argument must be string or list.')
              if isinstance(self.version_reqs, str):
                  self.version_reqs = [self.version_reqs]
              (self.is_found, not_found, found) = \
                  version_compare_many(self.version, self.version_reqs)
              if not self.is_found:
                  found_msg += [mlog.red('NO'),
                                'found {!r} but need:'.format(self.version),
                                ', '.join(["'{}'".format(e) for e in not_found])]
                  if found:
                      found_msg += ['; matched:',
                                    ', '.join(["'{}'".format(e) for e in found])]
                  if not self.silent:
                      mlog.log(*found_msg)
                  if self.required:
                      m = 'Invalid version of dependency, need {!r} {!r} found {!r}.'
                      raise DependencyException(m.format(name, not_found, self.version))
                  return
  
          try:
              # Fetch cargs to be used while using this dependency
              self._set_cargs()
              # Fetch the libraries and library paths needed for using this
              self._set_libs()
              found_msg += [mlog.green('YES'), self.version]
          except DependencyException as e:
              if self.required:
                  raise
              else:
                  self.compile_args = []
                  self.link_args = []
                  self.is_found = False
                  found_msg += [mlog.red('NO'), '; reason: {}'.format(str(e))]
  
          # Print the found message only at the very end because fetching cflags
          # and libs can also fail if other needed pkg-config files aren't found.
          if not self.silent:
              mlog.log(*found_msg)
  
      def __repr__(self):
          s = '<{0} {1}: {2} {3}>'
          return s.format(self.__class__.__name__, self.name, self.is_found,
                          self.version_reqs)
  
      def _call_pkgbin_real(self, args, env):
          p, out = Popen_safe(self.pkgbin.get_command() + args, env=env)[0:2]
          return p.returncode, out.strip()
  
      def _call_pkgbin(self, args, env=None):
          if env is None:
              fenv = env
              env = os.environ
          else:
              fenv = frozenset(env.items())
          targs = tuple(args)
          cache = PkgConfigDependency.pkgbin_cache
          if (self.pkgbin, targs, fenv) not in cache:
              cache[(self.pkgbin, targs, fenv)] = self._call_pkgbin_real(args, env)
          return cache[(self.pkgbin, targs, fenv)]
  
      def _convert_mingw_paths(self, args):
          '''
          Both MSVC and native Python on Windows cannot handle MinGW-esque /c/foo
          paths so convert them to C:/foo. We cannot resolve other paths starting
          with / like /home/foo so leave them as-is so that the user gets an
          error/warning from the compiler/linker.
          '''
          if not mesonlib.is_windows():
              return args
          converted = []
          for arg in args:
              pargs = []
              # Library search path
              if arg.startswith('-L/'):
                  pargs = PurePath(arg[2:]).parts
                  tmpl = '-L{}:/{}'
              elif arg.startswith('-I/'):
                  pargs = PurePath(arg[2:]).parts
                  tmpl = '-I{}:/{}'
              # Full path to library or .la file
              elif arg.startswith('/'):
                  pargs = PurePath(arg).parts
                  tmpl = '{}:/{}'
              if len(pargs) > 1 and len(pargs[1]) == 1:
                  arg = tmpl.format(pargs[1], '/'.join(pargs[2:]))
              converted.append(arg)
          return converted
  
      def _set_cargs(self):
          env = None
          if self.language == 'fortran':
              # gfortran doesn't appear to look in system paths for INCLUDE files,
              # so don't allow pkg-config to suppress -I flags for system paths
              env = os.environ.copy()
              env['PKG_CONFIG_ALLOW_SYSTEM_CFLAGS'] = '1'
          ret, out = self._call_pkgbin(['--cflags', self.name], env=env)
          if ret != 0:
              raise DependencyException('Could not generate cargs for %s:\n\n%s' %
                                        (self.name, out))
          self.compile_args = self._convert_mingw_paths(shlex.split(out))
  
      def _set_libs(self):
          env = None
          libcmd = [self.name, '--libs']
          if self.static:
              libcmd.append('--static')
          # Force pkg-config to output -L fields even if they are system
          # paths so we can do manual searching with cc.find_library() later.
          env = os.environ.copy()
          env['PKG_CONFIG_ALLOW_SYSTEM_LIBS'] = '1'
          ret, out = self._call_pkgbin(libcmd, env=env)
          if ret != 0:
              raise DependencyException('Could not generate libs for %s:\n\n%s' %
                                        (self.name, out))
          # These libraries should be safe to de-dup
          link_args = OrderedSet()
          libpaths = OrderedSet()
          libs_notfound = []
          libtype = 'static' if self.static else 'default'
          # We always look for the file ourselves instead of depending on the
          # compiler to find it with -lfoo or foo.lib (if possible) because:
          # 1. We want to be able to select static or shared
          # 2. We need the full path of the library to calculate RPATH values
          #
          # Libraries that are provided by the toolchain or are not found by
          # find_library() will be added with -L -l pairs.
          for lib in self._convert_mingw_paths(shlex.split(out)):
              if lib.startswith('-L'):
                  libpaths.add(lib[2:])
                  continue
              elif lib.startswith('-l'):
                  if self.clib_compiler:
                      args = self.clib_compiler.find_library(lib[2:], self.env,
                                                             list(libpaths), libtype)
                  # If the project only uses a non-clib language such as D, Rust,
                  # C#, Python, etc, all we can do is limp along.
                  else:
                      args = None
                  if args:
                      # Replace -l arg with full path to library if available
                      if not args[0].startswith('-l'):
                          lib = args[0]
                      # else, library is provided by the compiler and can't be resolved
                  else:
                      # Library wasn't found, maybe we're looking in the wrong
                      # places or the library will be provided with LDFLAGS or
                      # LIBRARY_PATH from the environment (on macOS), and many
                      # other edge cases that we can't account for.
                      #
                      # Add all -L paths and use it as -lfoo
                      if lib in libs_notfound:
                          continue
                      if self.static:
                          mlog.warning('Static library {!r} not found for dependency {!r}, may '
                                       'not be statically linked'.format(lib[2:], self.name))
                      libs_notfound.append(lib)
              elif lib.endswith(".la"):
                  shared_libname = self.extract_libtool_shlib(lib)
                  shared_lib = os.path.join(os.path.dirname(lib), shared_libname)
                  if not os.path.exists(shared_lib):
                      shared_lib = os.path.join(os.path.dirname(lib), ".libs", shared_libname)
  
                  if not os.path.exists(shared_lib):
                      raise DependencyException('Got a libtools specific "%s" dependencies'
                                                'but we could not compute the actual shared'
                                                'library path' % lib)
                  lib = shared_lib
                  self.is_libtool = True
              link_args.add(lib)
          self.link_args = list(link_args)
          # Add all -Lbar args if we have -lfoo args in link_args
          if libs_notfound:
              # Order of -L flags doesn't matter with ld, but it might with other
              # linkers such as MSVC, so prepend them.
              self.link_args = ['-L' + lp for lp in libpaths] + self.link_args
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          options = ['--variable=' + variable_name, self.name]
  
          if 'define_variable' in kwargs:
              definition = kwargs.get('define_variable', [])
              if not isinstance(definition, list):
                  raise MesonException('define_variable takes a list')
  
              if len(definition) != 2 or not all(isinstance(i, str) for i in definition):
                  raise MesonException('define_variable must be made up of 2 strings for VARIABLENAME and VARIABLEVALUE')
  
              options = ['--define-variable=' + '='.join(definition)] + options
  
          ret, out = self._call_pkgbin(options)
          variable = ''
          if ret != 0:
              if self.required:
                  raise DependencyException('%s dependency %s not found.' %
                                            (self.type_string, self.name))
          else:
              variable = out.strip()
  
              # pkg-config doesn't distinguish between empty and non-existent variables
              # use the variable list to check for variable existence
              if not variable:
                  ret, out = self._call_pkgbin(['--print-variables', self.name])
                  if not re.search(r'^' + variable_name + r'$', out, re.MULTILINE):
                      if 'default' in kwargs:
                          variable = kwargs['default']
                      else:
                          mlog.warning("pkgconfig variable '%s' not defined for dependency %s." % (variable_name, self.name))
  
          mlog.debug('Got pkgconfig variable %s : %s' % (variable_name, variable))
          return variable
  
      @staticmethod
      def get_methods():
          return [DependencyMethods.PKGCONFIG]
  
      def check_pkgconfig(self):
          evar = 'PKG_CONFIG'
          if evar in os.environ:
              pkgbin = os.environ[evar].strip()
          else:
              pkgbin = 'pkg-config'
          pkgbin = ExternalProgram(pkgbin, silent=True)
          if pkgbin.found():
              try:
                  p, out = Popen_safe(pkgbin.get_command() + ['--version'])[0:2]
                  if p.returncode != 0:
                      mlog.warning('Found pkg-config {!r} but couldn\'t run it'
                                   ''.format(' '.join(pkgbin.get_command())))
                      # Set to False instead of None to signify that we've already
                      # searched for it and not found it
                      pkgbin = False
              except (FileNotFoundError, PermissionError):
                  pkgbin = False
          else:
              pkgbin = False
          if not self.silent:
              if pkgbin:
                  mlog.log('Found pkg-config:', mlog.bold(pkgbin.get_path()),
                           '(%s)' % out.strip())
              else:
                  mlog.log('Found Pkg-config:', mlog.red('NO'))
          return pkgbin
  
      def extract_field(self, la_file, fieldname):
          with open(la_file) as f:
              for line in f:
                  arr = line.strip().split('=')
                  if arr[0] == fieldname:
                      return arr[1][1:-1]
          return None
  
      def extract_dlname_field(self, la_file):
          return self.extract_field(la_file, 'dlname')
  
      def extract_libdir_field(self, la_file):
          return self.extract_field(la_file, 'libdir')
  
      def extract_libtool_shlib(self, la_file):
          '''
          Returns the path to the shared library
          corresponding to this .la file
          '''
          dlname = self.extract_dlname_field(la_file)
          if dlname is None:
              return None
  
          # Darwin uses absolute paths where possible; since the libtool files never
          # contain absolute paths, use the libdir field
          if mesonlib.is_osx():
              dlbasename = os.path.basename(dlname)
              libdir = self.extract_libdir_field(la_file)
              if libdir is None:
                  return dlbasename
              return os.path.join(libdir, dlbasename)
          # From the comments in extract_libtool(), older libtools had
          # a path rather than the raw dlname
          return os.path.basename(dlname)
  
  
  class ExternalProgram:
      windows_exts = ('exe', 'msc', 'com', 'bat', 'cmd')
  
      def __init__(self, name, command=None, silent=False, search_dir=None):
          self.name = name
          if command is not None:
              self.command = listify(command)
          else:
              self.command = self._search(name, search_dir)
  
          # Set path to be the last item that is actually a file (in order to
          # skip options in something like ['python', '-u', 'file.py']. If we
          # can't find any components, default to the last component of the path.
          self.path = self.command[-1]
          for i in range(len(self.command) - 1, -1, -1):
              arg = self.command[i]
              if arg is not None and os.path.isfile(arg):
                  self.path = arg
                  break
  
          if not silent:
              if self.found():
                  mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
                           '(%s)' % ' '.join(self.command))
              else:
                  mlog.log('Program', mlog.bold(name), 'found:', mlog.red('NO'))
  
      def __repr__(self):
          r = '<{} {!r} -> {!r}>'
          return r.format(self.__class__.__name__, self.name, self.command)
  
      @staticmethod
      def _shebang_to_cmd(script):
          """
          Check if the file has a shebang and manually parse it to figure out
          the interpreter to use. This is useful if the script is not executable
          or if we're on Windows (which does not understand shebangs).
          """
          try:
              with open(script) as f:
                  first_line = f.readline().strip()
              if first_line.startswith('#!'):
                  # In a shebang, everything before the first space is assumed to
                  # be the command to run and everything after the first space is
                  # the single argument to pass to that command. So we must split
                  # exactly once.
                  commands = first_line[2:].split('#')[0].strip().split(maxsplit=1)
                  if mesonlib.is_windows():
                      # Windows does not have UNIX paths so remove them,
                      # but don't remove Windows paths
                      if commands[0].startswith('/'):
                          commands[0] = commands[0].split('/')[-1]
                      if len(commands) > 0 and commands[0] == 'env':
                          commands = commands[1:]
                      # Windows does not ship python3.exe, but we know the path to it
                      if len(commands) > 0 and commands[0] == 'python3':
                          commands = mesonlib.python_command + commands[1:]
                  elif mesonlib.is_haiku():
                      # Haiku does not have /usr, but a lot of scripts assume that
                      # /usr/bin/env always exists. Detect that case and run the
                      # script with the interpreter after it.
                      if commands[0] == '/usr/bin/env':
                          commands = commands[1:]
                      # We know what python3 is, we're running on it
                      if len(commands) > 0 and commands[0] == 'python3':
                          commands = mesonlib.python_command + commands[1:]
                  return commands + [script]
          except Exception as e:
              mlog.debug(e)
              pass
          mlog.debug('Unusable script {!r}'.format(script))
          return False
  
      def _is_executable(self, path):
          suffix = os.path.splitext(path)[-1].lower()[1:]
          if mesonlib.is_windows():
              if suffix in self.windows_exts:
                  return True
          elif os.access(path, os.X_OK):
              return not os.path.isdir(path)
          return False
  
      def _search_dir(self, name, search_dir):
          if search_dir is None:
              return False
          trial = os.path.join(search_dir, name)
          if os.path.exists(trial):
              if self._is_executable(trial):
                  return [trial]
              # Now getting desperate. Maybe it is a script file that is
              # a) not chmodded executable, or
              # b) we are on windows so they can't be directly executed.
              return self._shebang_to_cmd(trial)
          else:
              if mesonlib.is_windows():
                  for ext in self.windows_exts:
                      trial_ext = '{}.{}'.format(trial, ext)
                      if os.path.exists(trial_ext):
                          return [trial_ext]
          return False
  
      def _search_windows_special_cases(self, name, command):
          '''
          Lots of weird Windows quirks:
          1. PATH search for @name returns files with extensions from PATHEXT,
             but only self.windows_exts are executable without an interpreter.
          2. @name might be an absolute path to an executable, but without the
             extension. This works inside MinGW so people use it a lot.
          3. The script is specified without an extension, in which case we have
             to manually search in PATH.
          4. More special-casing for the shebang inside the script.
          '''
          if command:
              # On Windows, even if the PATH search returned a full path, we can't be
              # sure that it can be run directly if it's not a native executable.
              # For instance, interpreted scripts sometimes need to be run explicitly
              # with an interpreter if the file association is not done properly.
              name_ext = os.path.splitext(command)[1]
              if name_ext[1:].lower() in self.windows_exts:
                  # Good, it can be directly executed
                  return [command]
              # Try to extract the interpreter from the shebang
              commands = self._shebang_to_cmd(command)
              if commands:
                  return commands
              return [None]
          # Maybe the name is an absolute path to a native Windows
          # executable, but without the extension. This is technically wrong,
          # but many people do it because it works in the MinGW shell.
          if os.path.isabs(name):
              for ext in self.windows_exts:
                  command = '{}.{}'.format(name, ext)
                  if os.path.exists(command):
                      return [command]
          # On Windows, interpreted scripts must have an extension otherwise they
          # cannot be found by a standard PATH search. So we do a custom search
          # where we manually search for a script with a shebang in PATH.
          search_dirs = os.environ.get('PATH', '').split(';')
          for search_dir in search_dirs:
              commands = self._search_dir(name, search_dir)
              if commands:
                  return commands
          return [None]
  
      def _search(self, name, search_dir):
          '''
          Search in the specified dir for the specified executable by name
          and if not found search in PATH
          '''
          commands = self._search_dir(name, search_dir)
          if commands:
              return commands
          # Do a standard search in PATH
          command = shutil.which(name)
          if mesonlib.is_windows():
              return self._search_windows_special_cases(name, command)
          # On UNIX-like platforms, shutil.which() is enough to find
          # all executables whether in PATH or with an absolute path
          return [command]
  
      def found(self):
          return self.command[0] is not None
  
      def get_command(self):
          return self.command[:]
  
      def get_path(self):
          return self.path
  
      def get_name(self):
          return self.name
  
  class NonExistingExternalProgram(ExternalProgram):
  
      def __init__(self):
          super().__init__(name = 'nonexistingprogram', silent = True)
  
      def __repr__(self):
          r = '<{} {!r} -> {!r}>'
          return r.format(self.__class__.__name__, self.name, self.command)
  
      def found(self):
          return False
  
  class ExternalLibrary(ExternalDependency):
      def __init__(self, name, link_args, environment, language, silent=False):
          super().__init__('external', environment, language, {})
          self.name = name
          self.language = language
          self.is_found = False
          if link_args:
              self.is_found = True
              self.link_args = link_args
          if not silent:
              if self.is_found:
                  mlog.log('Library', mlog.bold(name), 'found:', mlog.green('YES'))
              else:
                  mlog.log('Library', mlog.bold(name), 'found:', mlog.red('NO'))
  
      def get_link_args(self, language=None):
          '''
          External libraries detected using a compiler must only be used with
          compatible code. For instance, Vala libraries (.vapi files) cannot be
          used with C code, and not all Rust library types can be linked with
          C-like code. Note that C++ libraries *can* be linked with C code with
          a C++ linker (and vice-versa).
          '''
          # Using a vala library in a non-vala target, or a non-vala library in a vala target
          # XXX: This should be extended to other non-C linkers such as Rust
          if (self.language == 'vala' and language != 'vala') or \
             (language == 'vala' and self.language != 'vala'):
              return []
          return self.link_args
  
      def get_partial_dependency(self, *, compile_args=False, link_args=False,
                                 links=False, includes=False, sources=False):
          # External library only has link_args, so ignore the rest of the
          # interface.
          new = copy.copy(self)
          if not link_args:
              new.link_args = []
          return new
  
  
  class ExtraFrameworkDependency(ExternalDependency):
      def __init__(self, name, required, path, env, lang, kwargs):
          super().__init__('extraframeworks', env, lang, kwargs)
          self.name = None
          self.required = required
          self.detect(name, path)
          if self.found():
              mlog.log('Dependency', mlog.bold(name), 'found:', mlog.green('YES'),
                       os.path.join(self.path, self.name))
          else:
              mlog.log('Dependency', name, 'found:', mlog.red('NO'))
  
      def detect(self, name, path):
          lname = name.lower()
          if path is None:
              paths = ['/System/Library/Frameworks', '/Library/Frameworks']
          else:
              paths = [path]
          for p in paths:
              for d in os.listdir(p):
                  fullpath = os.path.join(p, d)
                  if lname != d.split('.')[0].lower():
                      continue
                  if not stat.S_ISDIR(os.stat(fullpath).st_mode):
                      continue
                  self.path = p
                  self.name = d
                  self.is_found = True
                  return
          if not self.found() and self.required:
              raise DependencyException('Framework dependency %s not found.' % (name, ))
  
      def get_compile_args(self):
          if self.found():
              return ['-I' + os.path.join(self.path, self.name, 'Headers')]
          return []
  
      def get_link_args(self):
          if self.found():
              return ['-F' + self.path, '-framework', self.name.split('.')[0]]
          return []
  
      def get_version(self):
          return 'unknown'
  
  
  def get_dep_identifier(name, kwargs, want_cross):
      # Need immutable objects since the identifier will be used as a dict key
      version_reqs = listify(kwargs.get('version', []))
      if isinstance(version_reqs, list):
          version_reqs = frozenset(version_reqs)
      identifier = (name, version_reqs, want_cross)
      for key, value in kwargs.items():
          # 'version' is embedded above as the second element for easy access
          # 'native' is handled above with `want_cross`
          # 'required' is irrelevant for caching; the caller handles it separately
          # 'fallback' subprojects cannot be cached -- they must be initialized
          if key in ('version', 'native', 'required', 'fallback',):
              continue
          # All keyword arguments are strings, ints, or lists (or lists of lists)
          if isinstance(value, list):
              value = frozenset(listify(value))
          identifier += (key, value)
      return identifier
  
  
  def find_external_dependency(name, env, kwargs):
      required = kwargs.get('required', True)
      if not isinstance(required, bool):
          raise DependencyException('Keyword "required" must be a boolean.')
      if not isinstance(kwargs.get('method', ''), str):
          raise DependencyException('Keyword "method" must be a string.')
      lname = name.lower()
      if lname in packages:
          if lname not in _packages_accept_language and 'language' in kwargs:
              raise DependencyException('%s dependency does not accept "language" keyword argument' % (lname, ))
          # Create the dependency object using a factory class method, if one
          # exists, otherwise it is just constructed directly.
          if getattr(packages[lname], '_factory', None):
              dep = packages[lname]._factory(env, kwargs)
          else:
              dep = packages[lname](env, kwargs)
          if required and not dep.found():
              raise DependencyException('Dependency "%s" not found' % name)
          return dep
      if 'language' in kwargs:
          # Remove check when PkgConfigDependency supports language.
          raise DependencyException('%s dependency does not accept "language" keyword argument' % (lname, ))
      pkg_exc = None
      pkgdep = None
      try:
          pkgdep = PkgConfigDependency(name, env, kwargs)
          if pkgdep.found():
              return pkgdep
      except Exception as e:
          pkg_exc = e
      if mesonlib.is_osx():
          fwdep = ExtraFrameworkDependency(name, False, None, env, None, kwargs)
          if required and not fwdep.found():
              m = 'Dependency {!r} not found, tried Extra Frameworks ' \
                  'and Pkg-Config:\n\n' + str(pkg_exc)
              raise DependencyException(m.format(name))
          return fwdep
      if pkg_exc is not None:
          raise pkg_exc
      mlog.log('Dependency', mlog.bold(name), 'found:', mlog.red('NO'))
      return pkgdep
  
  
  def strip_system_libdirs(environment, link_args):
      """Remove -L<system path> arguments.
  
      leaving these in will break builds where a user has a version of a library
      in the system path, and a different version not in the system path if they
      want to link against the non-system path version.
      """
      exclude = {'-L{}'.format(p) for p in environment.get_compiler_system_dirs()}
      return [l for l in link_args if l not in exclude]
  
files: mesonbuild/dependencies/base.py
files: # Copyright 2013-2017 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.
  
  # This file contains the detection logic for miscellaneous external dependencies.
  
  import os
  import re
  import shlex
  import sysconfig
  
  from pathlib import Path
  
  from .. import mlog
  from .. import mesonlib
  from ..environment import detect_cpu_family
  
  from .base import (
      DependencyException, DependencyMethods, ExternalDependency,
      ExternalProgram, ExtraFrameworkDependency, PkgConfigDependency,
      ConfigToolDependency,
  )
  
  from ..interpreterbase import FeatureNew
  
  class MPIDependency(ExternalDependency):
  
      @FeatureNew('MPI Dependency', '0.42.0')
      def __init__(self, environment, kwargs):
          language = kwargs.get('language', 'c')
          super().__init__('mpi', environment, language, kwargs)
          required = kwargs.pop('required', True)
          kwargs['required'] = False
          kwargs['silent'] = True
          self.is_found = False
  
          # NOTE: Only OpenMPI supplies a pkg-config file at the moment.
          if language == 'c':
              env_vars = ['MPICC']
              pkgconfig_files = ['ompi-c']
              default_wrappers = ['mpicc']
          elif language == 'cpp':
              env_vars = ['MPICXX']
              pkgconfig_files = ['ompi-cxx']
              default_wrappers = ['mpic++', 'mpicxx', 'mpiCC']
          elif language == 'fortran':
              env_vars = ['MPIFC', 'MPIF90', 'MPIF77']
              pkgconfig_files = ['ompi-fort']
              default_wrappers = ['mpifort', 'mpif90', 'mpif77']
          else:
              raise DependencyException('Language {} is not supported with MPI.'.format(language))
  
          for pkg in pkgconfig_files:
              try:
                  pkgdep = PkgConfigDependency(pkg, environment, kwargs, language=self.language)
                  if pkgdep.found():
                      self.compile_args = pkgdep.get_compile_args()
                      self.link_args = pkgdep.get_link_args()
                      self.version = pkgdep.get_version()
                      self.is_found = True
                      self.pcdep = pkgdep
                      break
              except Exception:
                  pass
  
          if not self.is_found:
              # Prefer environment.
              for var in env_vars:
                  if var in os.environ:
                      wrappers = [os.environ[var]]
                      break
              else:
                  # Or search for default wrappers.
                  wrappers = default_wrappers
  
              for prog in wrappers:
                  result = self._try_openmpi_wrapper(prog)
                  if result is not None:
                      self.is_found = True
                      self.version = result[0]
                      self.compile_args = self._filter_compile_args(result[1])
                      self.link_args = self._filter_link_args(result[2])
                      break
                  result = self._try_other_wrapper(prog)
                  if result is not None:
                      self.is_found = True
                      self.version = result[0]
                      self.compile_args = self._filter_compile_args(result[1])
                      self.link_args = self._filter_link_args(result[2])
                      break
  
          if not self.is_found and mesonlib.is_windows():
              result = self._try_msmpi()
              if result is not None:
                  self.is_found = True
                  self.version, self.compile_args, self.link_args = result
  
          if self.is_found:
              mlog.log('Dependency', mlog.bold(self.name), 'for', self.language, 'found:', mlog.green('YES'), self.version)
          else:
              mlog.log('Dependency', mlog.bold(self.name), 'for', self.language, 'found:', mlog.red('NO'))
              if required:
                  raise DependencyException('MPI dependency {!r} not found'.format(self.name))
  
      def _filter_compile_args(self, args):
          """
          MPI wrappers return a bunch of garbage args.
          Drop -O2 and everything that is not needed.
          """
          result = []
          multi_args = ('-I', )
          if self.language == 'fortran':
              fc = self.env.coredata.compilers['fortran']
              multi_args += fc.get_module_incdir_args()
  
          include_next = False
          for f in args:
              if f.startswith(('-D', '-f') + multi_args) or f == '-pthread' \
                      or (f.startswith('-W') and f != '-Wall' and not f.startswith('-Werror')):
                  result.append(f)
                  if f in multi_args:
                      # Path is a separate argument.
                      include_next = True
              elif include_next:
                  include_next = False
                  result.append(f)
          return result
  
      def _filter_link_args(self, args):
          """
          MPI wrappers return a bunch of garbage args.
          Drop -O2 and everything that is not needed.
          """
          result = []
          include_next = False
          for f in args:
              if f.startswith(('-L', '-l', '-Xlinker')) or f == '-pthread' \
                      or (f.startswith('-W') and f != '-Wall' and not f.startswith('-Werror')):
                  result.append(f)
                  if f in ('-L', '-Xlinker'):
                      include_next = True
              elif include_next:
                  include_next = False
                  result.append(f)
          return result
  
      def _try_openmpi_wrapper(self, prog):
          prog = ExternalProgram(prog, silent=True)
          if prog.found():
              cmd = prog.get_command() + ['--showme:compile']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              cargs = shlex.split(o)
  
              cmd = prog.get_command() + ['--showme:link']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              libs = shlex.split(o)
  
              cmd = prog.get_command() + ['--showme:version']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              version = re.search('\d+.\d+.\d+', o)
              if version:
                  version = version.group(0)
              else:
                  version = 'none'
  
              return version, cargs, libs
  
      def _try_other_wrapper(self, prog):
          prog = ExternalProgram(prog, silent=True)
          if prog.found():
              cmd = prog.get_command() + ['-show']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              args = shlex.split(o)
  
              version = 'none'
  
              return version, args, args
  
      def _try_msmpi(self):
          if self.language == 'cpp':
              # MS-MPI does not support the C++ version of MPI, only the standard C API.
              return
          if 'MSMPI_INC' not in os.environ:
              return
          incdir = os.environ['MSMPI_INC']
          arch = detect_cpu_family(self.env.coredata.compilers)
          if arch == 'x86':
              if 'MSMPI_LIB32' not in os.environ:
                  return
              libdir = os.environ['MSMPI_LIB32']
              post = 'x86'
          elif arch == 'x86_64':
              if 'MSMPI_LIB64' not in os.environ:
                  return
              libdir = os.environ['MSMPI_LIB64']
              post = 'x64'
          else:
              return
          if self.language == 'fortran':
              return ('none',
                      ['-I' + incdir, '-I' + os.path.join(incdir, post)],
                      [os.path.join(libdir, 'msmpi.lib'), os.path.join(libdir, 'msmpifec.lib')])
          else:
              return ('none',
                      ['-I' + incdir, '-I' + os.path.join(incdir, post)],
                      [os.path.join(libdir, 'msmpi.lib')])
  
  
  class OpenMPDependency(ExternalDependency):
      # Map date of specification release (which is the macro value) to a version.
      VERSIONS = {
          '201511': '4.5',
          '201307': '4.0',
          '201107': '3.1',
          '200805': '3.0',
          '200505': '2.5',
          '200203': '2.0',
          '199810': '1.0',
      }
  
      @FeatureNew('OpenMP Dependency', '0.46.0')
      def __init__(self, environment, kwargs):
          language = kwargs.get('language')
          super().__init__('openmp', environment, language, kwargs)
          self.is_found = False
          try:
              openmp_date = self.clib_compiler.get_define('_OPENMP', '', self.env, [], [self])
          except mesonlib.EnvironmentException as e:
              mlog.debug('OpenMP support not available in the compiler')
              mlog.debug(e)
              openmp_date = False
  
          if openmp_date:
              self.version = self.VERSIONS[openmp_date]
              if self.clib_compiler.has_header('omp.h', '', self.env, dependencies=[self]):
                  self.is_found = True
              else:
                  mlog.log(mlog.yellow('WARNING:'), 'OpenMP found but omp.h missing.')
          if self.is_found:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'), self.version)
          else:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.red('NO'))
  
      def need_openmp(self):
          return True
  
  
  class ThreadDependency(ExternalDependency):
      def __init__(self, environment, kwargs):
          super().__init__('threads', environment, None, {})
          self.name = 'threads'
          self.is_found = True
          mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'))
  
      def need_threads(self):
          return True
  
      def get_version(self):
          return 'unknown'
  
  
  class Python3Dependency(ExternalDependency):
      def __init__(self, environment, kwargs):
          super().__init__('python3', environment, None, kwargs)
          self.name = 'python3'
          self.static = kwargs.get('static', False)
          # We can only be sure that it is Python 3 at this point
          self.version = '3'
          self.pkgdep = None
          if DependencyMethods.PKGCONFIG in self.methods:
              try:
                  self.pkgdep = PkgConfigDependency('python3', environment, kwargs)
                  if self.pkgdep.found():
                      self.compile_args = self.pkgdep.get_compile_args()
                      self.link_args = self.pkgdep.get_link_args()
                      self.version = self.pkgdep.get_version()
                      self.is_found = True
                      self.pcdep = self.pkgdep
                      return
                  else:
                      self.pkgdep = None
              except Exception:
                  pass
          if not self.is_found:
              if mesonlib.is_windows() and DependencyMethods.SYSCONFIG in self.methods:
                  self._find_libpy3_windows(environment)
              elif mesonlib.is_osx() and DependencyMethods.EXTRAFRAMEWORK in self.methods:
                  # In OSX the Python 3 framework does not have a version
                  # number in its name.
                  # There is a python in /System/Library/Frameworks, but that's
                  # python 2, Python 3 will always bin in /Library
                  fw = ExtraFrameworkDependency(
                      'python', False, '/Library/Frameworks', self.env, self.language, kwargs)
                  if fw.found():
                      self.compile_args = fw.get_compile_args()
                      self.link_args = fw.get_link_args()
                      self.is_found = True
          if self.is_found:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'))
          else:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.red('NO'))
  
      @staticmethod
      def get_windows_python_arch():
          pyplat = sysconfig.get_platform()
          if pyplat == 'mingw':
              pycc = sysconfig.get_config_var('CC')
              if pycc.startswith('x86_64'):
                  return '64'
              elif pycc.startswith(('i686', 'i386')):
                  return '32'
              else:
                  mlog.log('MinGW Python built with unknown CC {!r}, please file'
                           'a bug'.format(pycc))
                  return None
          elif pyplat == 'win32':
              return '32'
          elif pyplat in ('win64', 'win-amd64'):
              return '64'
          mlog.log('Unknown Windows Python platform {!r}'.format(pyplat))
          return None
  
      def get_windows_link_args(self):
          pyplat = sysconfig.get_platform()
          if pyplat.startswith('win'):
              vernum = sysconfig.get_config_var('py_version_nodot')
              if self.static:
                  libname = 'libpython{}.a'.format(vernum)
              else:
                  libname = 'python{}.lib'.format(vernum)
              lib = Path(sysconfig.get_config_var('base')) / 'libs' / libname
          elif pyplat == 'mingw':
              if self.static:
                  libname = sysconfig.get_config_var('LIBRARY')
              else:
                  libname = sysconfig.get_config_var('LDLIBRARY')
              lib = Path(sysconfig.get_config_var('LIBDIR')) / libname
          if not lib.exists():
              mlog.log('Could not find Python3 library {!r}'.format(str(lib)))
              return None
          return [str(lib)]
  
      def _find_libpy3_windows(self, env):
          '''
          Find python3 libraries on Windows and also verify that the arch matches
          what we are building for.
          '''
          pyarch = self.get_windows_python_arch()
          if pyarch is None:
              self.is_found = False
              return
          arch = detect_cpu_family(env.coredata.compilers)
          if arch == 'x86':
              arch = '32'
          elif arch == 'x86_64':
              arch = '64'
          else:
              # We can't cross-compile Python 3 dependencies on Windows yet
              mlog.log('Unknown architecture {!r} for'.format(arch),
                       mlog.bold(self.name))
              self.is_found = False
              return
          # Pyarch ends in '32' or '64'
          if arch != pyarch:
              mlog.log('Need', mlog.bold(self.name), 'for {}-bit, but '
                       'found {}-bit'.format(arch, pyarch))
              self.is_found = False
              return
          # This can fail if the library is not found
          largs = self.get_windows_link_args()
          if largs is None:
              self.is_found = False
              return
          self.link_args = largs
          # Compile args
          inc = sysconfig.get_path('include')
          platinc = sysconfig.get_path('platinclude')
          self.compile_args = ['-I' + inc]
          if inc != platinc:
              self.compile_args.append('-I' + platinc)
          self.version = sysconfig.get_config_var('py_version')
          self.is_found = True
  
      @staticmethod
      def get_methods():
          if mesonlib.is_windows():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSCONFIG]
          elif mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG]
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          if self.pkgdep:
              return self.pkgdep.get_pkgconfig_variable(variable_name, kwargs)
          else:
              return super().get_pkgconfig_variable(variable_name, kwargs)
  
  
  class PcapDependency(ExternalDependency):
  
      @FeatureNew('Pcap Dependency', '0.42.0')
      def __init__(self, environment, kwargs):
          super().__init__('pcap', environment, None, kwargs)
  
      @classmethod
      def _factory(cls, environment, kwargs):
          methods = cls._process_method_kw(kwargs)
          if DependencyMethods.PKGCONFIG in methods:
              try:
                  pcdep = PkgConfigDependency('pcap', environment, kwargs)
                  if pcdep.found():
                      return pcdep
              except Exception as e:
                  mlog.debug('Pcap not found via pkgconfig. Trying next, error was:', str(e))
          if DependencyMethods.CONFIG_TOOL in methods:
              try:
                  ctdep = ConfigToolDependency.factory(
                      'pcap', environment, None, kwargs, ['pcap-config'], 'pcap-config')
                  if ctdep.found():
                      ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
                      ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
                      ctdep.version = cls.get_pcap_lib_version(ctdep)
                      return ctdep
              except Exception as e:
                  mlog.debug('Pcap not found via pcap-config. Trying next, error was:', str(e))
  
          return PcapDependency(environment, kwargs)
  
      @staticmethod
      def get_methods():
          if mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
  
      @staticmethod
      def get_pcap_lib_version(ctdep):
          return ctdep.clib_compiler.get_return_value('pcap_lib_version', 'string',
                                                      '#include <pcap.h>', ctdep.env, [], [ctdep])
  
  
  class CupsDependency(ExternalDependency):
      def __init__(self, environment, kwargs):
          super().__init__('cups', environment, None, kwargs)
  
      @classmethod
      def _factory(cls, environment, kwargs):
          methods = cls._process_method_kw(kwargs)
          if DependencyMethods.PKGCONFIG in methods:
              try:
                  pcdep = PkgConfigDependency('cups', environment, kwargs)
                  if pcdep.found():
                      return pcdep
              except Exception as e:
                  mlog.debug('cups not found via pkgconfig. Trying next, error was:', str(e))
          if DependencyMethods.CONFIG_TOOL in methods:
              try:
                  ctdep = ConfigToolDependency.factory(
                      'cups', environment, None, kwargs, ['cups-config'], 'cups-config')
                  if ctdep.found():
                      ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
                      ctdep.link_args = ctdep.get_config_value(['--ldflags', '--libs'], 'link_args')
                      return ctdep
              except Exception as e:
                  mlog.debug('cups not found via cups-config. Trying next, error was:', str(e))
          if DependencyMethods.EXTRAFRAMEWORK in methods:
              if mesonlib.is_osx():
                  fwdep = ExtraFrameworkDependency('cups', False, None, environment,
                                                   kwargs.get('language', None), kwargs)
                  if fwdep.found():
                      return fwdep
          mlog.log('Dependency', mlog.bold('cups'), 'found:', mlog.red('NO'))
  
          return CupsDependency(environment, kwargs)
  
      @staticmethod
      def get_methods():
          if mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
  
  
  class LibWmfDependency(ExternalDependency):
      @FeatureNew('LibWMF Dependency', '0.44.0')
      def __init__(self, environment, kwargs):
          super().__init__('libwmf', environment, None, kwargs)
  
      @classmethod
      def _factory(cls, environment, kwargs):
          methods = cls._process_method_kw(kwargs)
          if DependencyMethods.PKGCONFIG in methods:
              try:
                  kwargs['required'] = False
                  pcdep = PkgConfigDependency('libwmf', environment, kwargs)
                  if pcdep.found():
                      return pcdep
              except Exception as e:
                  mlog.debug('LibWmf not found via pkgconfig. Trying next, error was:', str(e))
          if DependencyMethods.CONFIG_TOOL in methods:
              try:
                  ctdep = ConfigToolDependency.factory(
                      'libwmf', environment, None, kwargs, ['libwmf-config'], 'libwmf-config')
                  if ctdep.found():
                      ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
                      ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
                      return ctdep
              except Exception as e:
                  mlog.debug('cups not found via libwmf-config. Trying next, error was:', str(e))
  
          return LibWmfDependency(environment, kwargs)
  
      @staticmethod
      def get_methods():
          if mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
  
files: mesonbuild/dependencies/misc.py
files: # Copyright 2013-2017 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.
  
  # This file contains the detection logic for miscellaneous external dependencies.
  
  import os
  import re
  import shlex
  import sysconfig
  
  from pathlib import Path
  
  from .. import mlog
  from .. import mesonlib
  from ..environment import detect_cpu_family
  
  from .base import (
      DependencyException, DependencyMethods, ExternalDependency,
      ExternalProgram, ExtraFrameworkDependency, PkgConfigDependency,
      ConfigToolDependency,
  )
  
  from ..interpreterbase import FeatureNew
  
  class MPIDependency(ExternalDependency):
  
      @FeatureNew('MPI Dependency', '0.42.0')
      def __init__(self, environment, kwargs):
          language = kwargs.get('language', 'c')
          super().__init__('mpi', environment, language, kwargs)
          required = kwargs.pop('required', True)
          kwargs['required'] = False
          kwargs['silent'] = True
          self.is_found = False
  
          # NOTE: Only OpenMPI supplies a pkg-config file at the moment.
          if language == 'c':
              env_vars = ['MPICC']
              pkgconfig_files = ['ompi-c']
              default_wrappers = ['mpicc']
          elif language == 'cpp':
              env_vars = ['MPICXX']
              pkgconfig_files = ['ompi-cxx']
              default_wrappers = ['mpic++', 'mpicxx', 'mpiCC']
          elif language == 'fortran':
              env_vars = ['MPIFC', 'MPIF90', 'MPIF77']
              pkgconfig_files = ['ompi-fort']
              default_wrappers = ['mpifort', 'mpif90', 'mpif77']
          else:
              raise DependencyException('Language {} is not supported with MPI.'.format(language))
  
          for pkg in pkgconfig_files:
              try:
                  pkgdep = PkgConfigDependency(pkg, environment, kwargs, language=self.language)
                  if pkgdep.found():
                      self.compile_args = pkgdep.get_compile_args()
                      self.link_args = pkgdep.get_link_args()
                      self.version = pkgdep.get_version()
                      self.is_found = True
                      self.pcdep = pkgdep
                      break
              except Exception:
                  pass
  
          if not self.is_found:
              # Prefer environment.
              for var in env_vars:
                  if var in os.environ:
                      wrappers = [os.environ[var]]
                      break
              else:
                  # Or search for default wrappers.
                  wrappers = default_wrappers
  
              for prog in wrappers:
                  result = self._try_openmpi_wrapper(prog)
                  if result is not None:
                      self.is_found = True
                      self.version = result[0]
                      self.compile_args = self._filter_compile_args(result[1])
                      self.link_args = self._filter_link_args(result[2])
                      break
                  result = self._try_other_wrapper(prog)
                  if result is not None:
                      self.is_found = True
                      self.version = result[0]
                      self.compile_args = self._filter_compile_args(result[1])
                      self.link_args = self._filter_link_args(result[2])
                      break
  
          if not self.is_found and mesonlib.is_windows():
              result = self._try_msmpi()
              if result is not None:
                  self.is_found = True
                  self.version, self.compile_args, self.link_args = result
  
          if self.is_found:
              mlog.log('Dependency', mlog.bold(self.name), 'for', self.language, 'found:', mlog.green('YES'), self.version)
          else:
              mlog.log('Dependency', mlog.bold(self.name), 'for', self.language, 'found:', mlog.red('NO'))
              if required:
                  raise DependencyException('MPI dependency {!r} not found'.format(self.name))
  
      def _filter_compile_args(self, args):
          """
          MPI wrappers return a bunch of garbage args.
          Drop -O2 and everything that is not needed.
          """
          result = []
          multi_args = ('-I', )
          if self.language == 'fortran':
              fc = self.env.coredata.compilers['fortran']
              multi_args += fc.get_module_incdir_args()
  
          include_next = False
          for f in args:
              if f.startswith(('-D', '-f') + multi_args) or f == '-pthread' \
                      or (f.startswith('-W') and f != '-Wall' and not f.startswith('-Werror')):
                  result.append(f)
                  if f in multi_args:
                      # Path is a separate argument.
                      include_next = True
              elif include_next:
                  include_next = False
                  result.append(f)
          return result
  
      def _filter_link_args(self, args):
          """
          MPI wrappers return a bunch of garbage args.
          Drop -O2 and everything that is not needed.
          """
          result = []
          include_next = False
          for f in args:
              if f.startswith(('-L', '-l', '-Xlinker')) or f == '-pthread' \
                      or (f.startswith('-W') and f != '-Wall' and not f.startswith('-Werror')):
                  result.append(f)
                  if f in ('-L', '-Xlinker'):
                      include_next = True
              elif include_next:
                  include_next = False
                  result.append(f)
          return result
  
      def _try_openmpi_wrapper(self, prog):
          prog = ExternalProgram(prog, silent=True)
          if prog.found():
              cmd = prog.get_command() + ['--showme:compile']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              cargs = shlex.split(o)
  
              cmd = prog.get_command() + ['--showme:link']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              libs = shlex.split(o)
  
              cmd = prog.get_command() + ['--showme:version']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              version = re.search('\d+.\d+.\d+', o)
              if version:
                  version = version.group(0)
              else:
                  version = 'none'
  
              return version, cargs, libs
  
      def _try_other_wrapper(self, prog):
          prog = ExternalProgram(prog, silent=True)
          if prog.found():
              cmd = prog.get_command() + ['-show']
              p, o, e = mesonlib.Popen_safe(cmd)
              p.wait()
              if p.returncode != 0:
                  mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
                  mlog.debug(mlog.bold('Standard output\n'), o)
                  mlog.debug(mlog.bold('Standard error\n'), e)
                  return
              args = shlex.split(o)
  
              version = 'none'
  
              return version, args, args
  
      def _try_msmpi(self):
          if self.language == 'cpp':
              # MS-MPI does not support the C++ version of MPI, only the standard C API.
              return
          if 'MSMPI_INC' not in os.environ:
              return
          incdir = os.environ['MSMPI_INC']
          arch = detect_cpu_family(self.env.coredata.compilers)
          if arch == 'x86':
              if 'MSMPI_LIB32' not in os.environ:
                  return
              libdir = os.environ['MSMPI_LIB32']
              post = 'x86'
          elif arch == 'x86_64':
              if 'MSMPI_LIB64' not in os.environ:
                  return
              libdir = os.environ['MSMPI_LIB64']
              post = 'x64'
          else:
              return
          if self.language == 'fortran':
              return ('none',
                      ['-I' + incdir, '-I' + os.path.join(incdir, post)],
                      [os.path.join(libdir, 'msmpi.lib'), os.path.join(libdir, 'msmpifec.lib')])
          else:
              return ('none',
                      ['-I' + incdir, '-I' + os.path.join(incdir, post)],
                      [os.path.join(libdir, 'msmpi.lib')])
  
  
  class OpenMPDependency(ExternalDependency):
      # Map date of specification release (which is the macro value) to a version.
      VERSIONS = {
          '201511': '4.5',
          '201307': '4.0',
          '201107': '3.1',
          '200805': '3.0',
          '200505': '2.5',
          '200203': '2.0',
          '199810': '1.0',
      }
  
      @FeatureNew('OpenMP Dependency', '0.46.0')
      def __init__(self, environment, kwargs):
          language = kwargs.get('language')
          super().__init__('openmp', environment, language, kwargs)
          self.is_found = False
          try:
              openmp_date = self.clib_compiler.get_define('_OPENMP', '', self.env, [], [self])
          except mesonlib.EnvironmentException as e:
              mlog.debug('OpenMP support not available in the compiler')
              mlog.debug(e)
              openmp_date = False
  
          if openmp_date:
              self.version = self.VERSIONS[openmp_date]
              if self.clib_compiler.has_header('omp.h', '', self.env, dependencies=[self]):
                  self.is_found = True
              else:
                  mlog.log(mlog.yellow('WARNING:'), 'OpenMP found but omp.h missing.')
          if self.is_found:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'), self.version)
          else:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.red('NO'))
  
      def need_openmp(self):
          return True
  
  
  class ThreadDependency(ExternalDependency):
      def __init__(self, environment, kwargs):
          super().__init__('threads', environment, None, {})
          self.name = 'threads'
          self.is_found = True
          mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'))
  
      def need_threads(self):
          return True
  
      def get_version(self):
          return 'unknown'
  
  
  class Python3Dependency(ExternalDependency):
      def __init__(self, environment, kwargs):
          super().__init__('python3', environment, None, kwargs)
          self.name = 'python3'
          self.static = kwargs.get('static', False)
          # We can only be sure that it is Python 3 at this point
          self.version = '3'
          self.pkgdep = None
          if DependencyMethods.PKGCONFIG in self.methods:
              try:
                  self.pkgdep = PkgConfigDependency('python3', environment, kwargs)
                  if self.pkgdep.found():
                      self.compile_args = self.pkgdep.get_compile_args()
                      self.link_args = self.pkgdep.get_link_args()
                      self.version = self.pkgdep.get_version()
                      self.is_found = True
                      self.pcdep = self.pkgdep
                      return
                  else:
                      self.pkgdep = None
              except Exception:
                  pass
          if not self.is_found:
              if mesonlib.is_windows() and DependencyMethods.SYSCONFIG in self.methods:
                  self._find_libpy3_windows(environment)
              elif mesonlib.is_osx() and DependencyMethods.EXTRAFRAMEWORK in self.methods:
                  # In OSX the Python 3 framework does not have a version
                  # number in its name.
                  # There is a python in /System/Library/Frameworks, but that's
                  # python 2, Python 3 will always bin in /Library
                  fw = ExtraFrameworkDependency(
                      'python', False, '/Library/Frameworks', self.env, self.language, kwargs)
                  if fw.found():
                      self.compile_args = fw.get_compile_args()
                      self.link_args = fw.get_link_args()
                      self.is_found = True
          if self.is_found:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES'))
          else:
              mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.red('NO'))
  
      @staticmethod
      def get_windows_python_arch():
          pyplat = sysconfig.get_platform()
          if pyplat == 'mingw':
              pycc = sysconfig.get_config_var('CC')
              if pycc.startswith('x86_64'):
                  return '64'
              elif pycc.startswith(('i686', 'i386')):
                  return '32'
              else:
                  mlog.log('MinGW Python built with unknown CC {!r}, please file'
                           'a bug'.format(pycc))
                  return None
          elif pyplat == 'win32':
              return '32'
          elif pyplat in ('win64', 'win-amd64'):
              return '64'
          mlog.log('Unknown Windows Python platform {!r}'.format(pyplat))
          return None
  
      def get_windows_link_args(self):
          pyplat = sysconfig.get_platform()
          if pyplat.startswith('win'):
              vernum = sysconfig.get_config_var('py_version_nodot')
              if self.static:
                  libname = 'libpython{}.a'.format(vernum)
              else:
                  libname = 'python{}.lib'.format(vernum)
              lib = Path(sysconfig.get_config_var('base')) / 'libs' / libname
          elif pyplat == 'mingw':
              if self.static:
                  libname = sysconfig.get_config_var('LIBRARY')
              else:
                  libname = sysconfig.get_config_var('LDLIBRARY')
              lib = Path(sysconfig.get_config_var('LIBDIR')) / libname
          if not lib.exists():
              mlog.log('Could not find Python3 library {!r}'.format(str(lib)))
              return None
          return [str(lib)]
  
      def _find_libpy3_windows(self, env):
          '''
          Find python3 libraries on Windows and also verify that the arch matches
          what we are building for.
          '''
          pyarch = self.get_windows_python_arch()
          if pyarch is None:
              self.is_found = False
              return
          arch = detect_cpu_family(env.coredata.compilers)
          if arch == 'x86':
              arch = '32'
          elif arch == 'x86_64':
              arch = '64'
          else:
              # We can't cross-compile Python 3 dependencies on Windows yet
              mlog.log('Unknown architecture {!r} for'.format(arch),
                       mlog.bold(self.name))
              self.is_found = False
              return
          # Pyarch ends in '32' or '64'
          if arch != pyarch:
              mlog.log('Need', mlog.bold(self.name), 'for {}-bit, but '
                       'found {}-bit'.format(arch, pyarch))
              self.is_found = False
              return
          # This can fail if the library is not found
          largs = self.get_windows_link_args()
          if largs is None:
              self.is_found = False
              return
          self.link_args = largs
          # Compile args
          inc = sysconfig.get_path('include')
          platinc = sysconfig.get_path('platinclude')
          self.compile_args = ['-I' + inc]
          if inc != platinc:
              self.compile_args.append('-I' + platinc)
          self.version = sysconfig.get_config_var('py_version')
          self.is_found = True
  
      @staticmethod
      def get_methods():
          if mesonlib.is_windows():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSCONFIG]
          elif mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG]
  
      def get_pkgconfig_variable(self, variable_name, kwargs):
          if self.pkgdep:
              return self.pkgdep.get_pkgconfig_variable(variable_name, kwargs)
          else:
              return super().get_pkgconfig_variable(variable_name, kwargs)
  
  
  class PcapDependency(ExternalDependency):
  
      @FeatureNew('Pcap Dependency', '0.42.0')
      def __init__(self, environment, kwargs):
          super().__init__('pcap', environment, None, kwargs)
  
      @classmethod
      def _factory(cls, environment, kwargs):
          methods = cls._process_method_kw(kwargs)
          if DependencyMethods.PKGCONFIG in methods:
              try:
                  pcdep = PkgConfigDependency('pcap', environment, kwargs)
                  if pcdep.found():
                      return pcdep
              except Exception as e:
                  mlog.debug('Pcap not found via pkgconfig. Trying next, error was:', str(e))
          if DependencyMethods.CONFIG_TOOL in methods:
              try:
                  ctdep = ConfigToolDependency.factory(
                      'pcap', environment, None, kwargs, ['pcap-config'], 'pcap-config')
                  if ctdep.found():
                      ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
                      ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
                      ctdep.version = cls.get_pcap_lib_version(ctdep)
                      return ctdep
              except Exception as e:
                  mlog.debug('Pcap not found via pcap-config. Trying next, error was:', str(e))
  
          return PcapDependency(environment, kwargs)
  
      @staticmethod
      def get_methods():
          if mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
  
      @staticmethod
      def get_pcap_lib_version(ctdep):
          return ctdep.compiler.get_return_value('pcap_lib_version', 'string',
                                                 '#include <pcap.h>', ctdep.env, [], [ctdep])
  
  
  class CupsDependency(ExternalDependency):
      def __init__(self, environment, kwargs):
          super().__init__('cups', environment, None, kwargs)
  
      @classmethod
      def _factory(cls, environment, kwargs):
          methods = cls._process_method_kw(kwargs)
          if DependencyMethods.PKGCONFIG in methods:
              try:
                  pcdep = PkgConfigDependency('cups', environment, kwargs)
                  if pcdep.found():
                      return pcdep
              except Exception as e:
                  mlog.debug('cups not found via pkgconfig. Trying next, error was:', str(e))
          if DependencyMethods.CONFIG_TOOL in methods:
              try:
                  ctdep = ConfigToolDependency.factory(
                      'cups', environment, None, kwargs, ['cups-config'], 'cups-config')
                  if ctdep.found():
                      ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
                      ctdep.link_args = ctdep.get_config_value(['--ldflags', '--libs'], 'link_args')
                      return ctdep
              except Exception as e:
                  mlog.debug('cups not found via cups-config. Trying next, error was:', str(e))
          if DependencyMethods.EXTRAFRAMEWORK in methods:
              if mesonlib.is_osx():
                  fwdep = ExtraFrameworkDependency('cups', False, None, environment,
                                                   kwargs.get('language', None), kwargs)
                  if fwdep.found():
                      return fwdep
          mlog.log('Dependency', mlog.bold('cups'), 'found:', mlog.red('NO'))
  
          return CupsDependency(environment, kwargs)
  
      @staticmethod
      def get_methods():
          if mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
  
  
  class LibWmfDependency(ExternalDependency):
      @FeatureNew('LibWMF Dependency', '0.44.0')
      def __init__(self, environment, kwargs):
          super().__init__('libwmf', environment, None, kwargs)
  
      @classmethod
      def _factory(cls, environment, kwargs):
          methods = cls._process_method_kw(kwargs)
          if DependencyMethods.PKGCONFIG in methods:
              try:
                  kwargs['required'] = False
                  pcdep = PkgConfigDependency('libwmf', environment, kwargs)
                  if pcdep.found():
                      return pcdep
              except Exception as e:
                  mlog.debug('LibWmf not found via pkgconfig. Trying next, error was:', str(e))
          if DependencyMethods.CONFIG_TOOL in methods:
              try:
                  ctdep = ConfigToolDependency.factory(
                      'libwmf', environment, None, kwargs, ['libwmf-config'], 'libwmf-config')
                  if ctdep.found():
                      ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
                      ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
                      return ctdep
              except Exception as e:
                  mlog.debug('cups not found via libwmf-config. Trying next, error was:', str(e))
  
          return LibWmfDependency(environment, kwargs)
  
      @staticmethod
      def get_methods():
          if mesonlib.is_osx():
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK]
          else:
              return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
  
files: mesonbuild/dependencies/misc.py
files: # Copyright 2012-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.
  
  from . import mparser
  from . import environment
  from . import coredata
  from . import dependencies
  from . import mlog
  from . import build
  from . import optinterpreter
  from . import compilers
  from .wrap import wrap, WrapMode
  from . import mesonlib
  from .mesonlib import FileMode, Popen_safe, listify, extract_as_list, has_path_sep
  from .dependencies import ExternalProgram
  from .dependencies import InternalDependency, Dependency, NotFoundDependency, DependencyException
  from .interpreterbase import InterpreterBase
  from .interpreterbase import check_stringlist, flatten, noPosargs, noKwargs, stringArgs, permittedKwargs, noArgsFlattening
  from .interpreterbase import InterpreterException, InvalidArguments, InvalidCode, SubdirDoneRequest
  from .interpreterbase import InterpreterObject, MutableInterpreterObject, Disabler
  from .interpreterbase import FeatureNew, FeatureDeprecated, FeatureNewKwargs
  from .modules import ModuleReturnValue
  
  import os, sys, shutil, uuid
  import re, shlex
  import subprocess
  from collections import namedtuple
  from pathlib import PurePath
  
  import importlib
  
  permitted_method_kwargs = {
      'partial_dependency': {'compile_args', 'link_args', 'links', 'includes',
                             'sources'},
  }
  
  def stringifyUserArguments(args):
      if isinstance(args, list):
          return '[%s]' % ', '.join([stringifyUserArguments(x) for x in args])
      elif isinstance(args, dict):
          return '{%s}' % ', '.join(['%s : %s' % (stringifyUserArguments(k), stringifyUserArguments(v)) for k, v in args.items()])
      elif isinstance(args, int):
          return str(args)
      elif isinstance(args, str):
          return "'%s'" % args
      raise InvalidArguments('Function accepts only strings, integers, lists and lists thereof.')
  
  
  class ObjectHolder:
      def __init__(self, obj):
          self.held_object = obj
  
      def __repr__(self):
          return '<Holder: {!r}>'.format(self.held_object)
  
  class FeatureOptionHolder(InterpreterObject, ObjectHolder):
      def __init__(self, env, option):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, option)
          if option.is_auto():
              self.held_object = env.coredata.builtins['auto_features']
          self.name = option.name
          self.methods.update({'enabled': self.enabled_method,
                               'disabled': self.disabled_method,
                               'auto': self.auto_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def enabled_method(self, args, kwargs):
          return self.held_object.is_enabled()
  
      @noPosargs
      @permittedKwargs({})
      def disabled_method(self, args, kwargs):
          return self.held_object.is_disabled()
  
      @noPosargs
      @permittedKwargs({})
      def auto_method(self, args, kwargs):
          return self.held_object.is_auto()
  
  def extract_required_kwarg(kwargs):
      val = kwargs.get('required', True)
      disabled = False
      required = False
      feature = None
      if isinstance(val, FeatureOptionHolder):
          option = val.held_object
          feature = val.name
          if option.is_disabled():
              disabled = True
          elif option.is_enabled():
              required = True
      elif isinstance(required, bool):
          required = val
      else:
          raise InterpreterException('required keyword argument must be boolean or a feature option')
  
      # Keep boolean value in kwargs to simplify other places where this kwarg is
      # checked.
      kwargs['required'] = required
  
      return disabled, required, feature
  
  class TryRunResultHolder(InterpreterObject):
      def __init__(self, res):
          super().__init__()
          self.res = res
          self.methods.update({'returncode': self.returncode_method,
                               'compiled': self.compiled_method,
                               'stdout': self.stdout_method,
                               'stderr': self.stderr_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def returncode_method(self, args, kwargs):
          return self.res.returncode
  
      @noPosargs
      @permittedKwargs({})
      def compiled_method(self, args, kwargs):
          return self.res.compiled
  
      @noPosargs
      @permittedKwargs({})
      def stdout_method(self, args, kwargs):
          return self.res.stdout
  
      @noPosargs
      @permittedKwargs({})
      def stderr_method(self, args, kwargs):
          return self.res.stderr
  
  class RunProcess(InterpreterObject):
  
      def __init__(self, cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir=False, check=False, capture=True):
          super().__init__()
          if not isinstance(cmd, ExternalProgram):
              raise AssertionError('BUG: RunProcess must be passed an ExternalProgram')
          self.capture = capture
          pc, self.stdout, self.stderr = self.run_command(cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check)
          self.returncode = pc.returncode
          self.methods.update({'returncode': self.returncode_method,
                               'stdout': self.stdout_method,
                               'stderr': self.stderr_method,
                               })
  
      def run_command(self, cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check=False):
          command_array = cmd.get_command() + args
          env = {'MESON_SOURCE_ROOT': source_dir,
                 'MESON_BUILD_ROOT': build_dir,
                 'MESON_SUBDIR': subdir,
                 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in mesonintrospect]),
                 }
          if in_builddir:
              cwd = os.path.join(build_dir, subdir)
          else:
              cwd = os.path.join(source_dir, subdir)
          child_env = os.environ.copy()
          child_env.update(env)
          stdout = subprocess.PIPE if self.capture else subprocess.DEVNULL
          mlog.debug('Running command:', ' '.join(command_array))
          try:
              p, o, e = Popen_safe(command_array, stdout=stdout, env=child_env, cwd=cwd)
              if self.capture:
                  mlog.debug('--- stdout ---')
                  mlog.debug(o)
              else:
                  o = ''
                  mlog.debug('--- stdout disabled ---')
              mlog.debug('--- stderr ---')
              mlog.debug(e)
              mlog.debug('')
  
              if check and p.returncode != 0:
                  raise InterpreterException('Command "{}" failed with status {}.'.format(' '.join(command_array), p.returncode))
  
              return p, o, e
          except FileNotFoundError:
              raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array))
  
      @noPosargs
      @permittedKwargs({})
      def returncode_method(self, args, kwargs):
          return self.returncode
  
      @noPosargs
      @permittedKwargs({})
      def stdout_method(self, args, kwargs):
          return self.stdout
  
      @noPosargs
      @permittedKwargs({})
      def stderr_method(self, args, kwargs):
          return self.stderr
  
  class ConfigureFileHolder(InterpreterObject, ObjectHolder):
  
      def __init__(self, subdir, sourcename, targetname, configuration_data):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, build.ConfigureFile(subdir, sourcename,
                                                          targetname, configuration_data))
  
  
  class EnvironmentVariablesHolder(MutableInterpreterObject, ObjectHolder):
      def __init__(self):
          MutableInterpreterObject.__init__(self)
          ObjectHolder.__init__(self, build.EnvironmentVariables())
          self.methods.update({'set': self.set_method,
                               'append': self.append_method,
                               'prepend': self.prepend_method,
                               })
  
      def __repr__(self):
          repr_str = "<{0}: {1}>"
          return repr_str.format(self.__class__.__name__, self.held_object.envvars)
  
      def add_var(self, method, args, kwargs):
          if not isinstance(kwargs.get("separator", ""), str):
              raise InterpreterException("EnvironmentVariablesHolder methods 'separator'"
                                         " argument needs to be a string.")
          if len(args) < 2:
              raise InterpreterException("EnvironmentVariablesHolder methods require at least"
                                         "2 arguments, first is the name of the variable and"
                                         " following one are values")
          self.held_object.envvars.append((method, args[0], args[1:], kwargs))
  
      @stringArgs
      @permittedKwargs({'separator'})
      def set_method(self, args, kwargs):
          self.add_var(self.held_object.set, args, kwargs)
  
      @stringArgs
      @permittedKwargs({'separator'})
      def append_method(self, args, kwargs):
          self.add_var(self.held_object.append, args, kwargs)
  
      @stringArgs
      @permittedKwargs({'separator'})
      def prepend_method(self, args, kwargs):
          self.add_var(self.held_object.prepend, args, kwargs)
  
  
  class ConfigurationDataHolder(MutableInterpreterObject, ObjectHolder):
      def __init__(self):
          MutableInterpreterObject.__init__(self)
          self.used = False # These objects become immutable after use in configure_file.
          ObjectHolder.__init__(self, build.ConfigurationData())
          self.methods.update({'set': self.set_method,
                               'set10': self.set10_method,
                               'set_quoted': self.set_quoted_method,
                               'has': self.has_method,
                               'get': self.get_method,
                               'get_unquoted': self.get_unquoted_method,
                               'merge_from': self.merge_from_method,
                               })
  
      def is_used(self):
          return self.used
  
      def mark_used(self):
          self.used = True
  
      def validate_args(self, args, kwargs):
          if len(args) == 1 and isinstance(args[0], list) and len(args[0]) == 2:
              mlog.log(mlog.red('DEPRECATION:'),
                       '''Passing a list as the single argument to configuration_data.set is deprecated.
  This will become a hard error in the future''')
              args = args[0]
  
          if len(args) != 2:
              raise InterpreterException("Configuration set requires 2 arguments.")
          if self.used:
              raise InterpreterException("Can not set values on configuration object that has been used.")
          name = args[0]
          val = args[1]
          desc = kwargs.get('description', None)
          if not isinstance(name, str):
              raise InterpreterException("First argument to set must be a string.")
          if desc is not None and not isinstance(desc, str):
              raise InterpreterException('Description must be a string.')
  
          return name, val, desc
  
      @noArgsFlattening
      def set_method(self, args, kwargs):
          (name, val, desc) = self.validate_args(args, kwargs)
          self.held_object.values[name] = (val, desc)
  
      def set_quoted_method(self, args, kwargs):
          (name, val, desc) = self.validate_args(args, kwargs)
          if not isinstance(val, str):
              raise InterpreterException("Second argument to set_quoted must be a string.")
          escaped_val = '\\"'.join(val.split('"'))
          self.held_object.values[name] = ('"' + escaped_val + '"', desc)
  
      def set10_method(self, args, kwargs):
          (name, val, desc) = self.validate_args(args, kwargs)
          if val:
              self.held_object.values[name] = (1, desc)
          else:
              self.held_object.values[name] = (0, desc)
  
      def has_method(self, args, kwargs):
          return args[0] in self.held_object.values
  
      @FeatureNew('configuration_data.get()', '0.38.0')
      @noArgsFlattening
      def get_method(self, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InterpreterException('Get method takes one or two arguments.')
          name = args[0]
          if name in self.held_object:
              return self.held_object.get(name)[0]
          if len(args) > 1:
              return args[1]
          raise InterpreterException('Entry %s not in configuration data.' % name)
  
      @FeatureNew('get_unquoted', '0.44.0')
      def get_unquoted_method(self, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InterpreterException('Get method takes one or two arguments.')
          name = args[0]
          if name in self.held_object:
              val = self.held_object.get(name)[0]
          elif len(args) > 1:
              val = args[1]
          else:
              raise InterpreterException('Entry %s not in configuration data.' % name)
          if val[0] == '"' and val[-1] == '"':
              return val[1:-1]
          return val
  
      def get(self, name):
          return self.held_object.values[name] # (val, desc)
  
      def keys(self):
          return self.held_object.values.keys()
  
      def merge_from_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Merge_from takes one positional argument.')
          from_object = args[0]
          if not isinstance(from_object, ConfigurationDataHolder):
              raise InterpreterException('Merge_from argument must be a configuration data object.')
          from_object = from_object.held_object
          for k, v in from_object.values.items():
              self.held_object.values[k] = v
  
  # Interpreter objects can not be pickled so we must have
  # these wrappers.
  
  class DependencyHolder(InterpreterObject, ObjectHolder):
      def __init__(self, dep):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, dep)
          self.methods.update({'found': self.found_method,
                               'type_name': self.type_name_method,
                               'version': self.version_method,
                               'get_pkgconfig_variable': self.pkgconfig_method,
                               'get_configtool_variable': self.configtool_method,
                               'partial_dependency': self.partial_dependency_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def type_name_method(self, args, kwargs):
          return self.held_object.type_name
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          if self.held_object.type_name == 'internal':
              return True
          return self.held_object.found()
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
      @permittedKwargs({'define_variable'})
      def pkgconfig_method(self, args, kwargs):
          args = listify(args)
          if len(args) != 1:
              raise InterpreterException('get_pkgconfig_variable takes exactly one argument.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('Variable name must be a string.')
          return self.held_object.get_pkgconfig_variable(varname, kwargs)
  
      @FeatureNew('get_configtool_variable', '0.44.0')
      @permittedKwargs({})
      def configtool_method(self, args, kwargs):
          args = listify(args)
          if len(args) != 1:
              raise InterpreterException('get_configtool_variable takes exactly one argument.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('Variable name must be a string.')
          return self.held_object.get_configtool_variable(varname)
  
      @FeatureNew('dep.partial_dependency', '0.46.0')
      @noPosargs
      @permittedKwargs(permitted_method_kwargs['partial_dependency'])
      def partial_dependency_method(self, args, kwargs):
          return DependencyHolder(self.held_object.get_partial_dependency(**kwargs))
  
  class InternalDependencyHolder(InterpreterObject, ObjectHolder):
      def __init__(self, dep):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, dep)
          self.methods.update({'found': self.found_method,
                               'version': self.version_method,
                               'partial_dependency': self.partial_dependency_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          return True
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
      @FeatureNew('dep.partial_dependency', '0.46.0')
      @noPosargs
      @permittedKwargs(permitted_method_kwargs['partial_dependency'])
      def partial_dependency_method(self, args, kwargs):
          return DependencyHolder(self.held_object.get_partial_dependency(**kwargs))
  
  class ExternalProgramHolder(InterpreterObject, ObjectHolder):
      def __init__(self, ep):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, ep)
          self.methods.update({'found': self.found_method,
                               'path': self.path_method})
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          return self.found()
  
      @noPosargs
      @permittedKwargs({})
      def path_method(self, args, kwargs):
          return self.held_object.get_path()
  
      def found(self):
          return self.held_object.found()
  
      def get_command(self):
          return self.held_object.get_command()
  
      def get_name(self):
          return self.held_object.get_name()
  
  class ExternalLibraryHolder(InterpreterObject, ObjectHolder):
      def __init__(self, el):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, el)
          self.methods.update({'found': self.found_method,
                               'partial_dependency': self.partial_dependency_method,
                               })
  
      def found(self):
          return self.held_object.found()
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          return self.found()
  
      def get_name(self):
          return self.held_object.name
  
      def get_compile_args(self):
          return self.held_object.get_compile_args()
  
      def get_link_args(self):
          return self.held_object.get_link_args()
  
      def get_exe_args(self):
          return self.held_object.get_exe_args()
  
      @FeatureNew('dep.partial_dependency', '0.46.0')
      @noPosargs
      @permittedKwargs(permitted_method_kwargs['partial_dependency'])
      def partial_dependency_method(self, args, kwargs):
          return DependencyHolder(self.held_object.get_partial_dependency(**kwargs))
  
  class GeneratorHolder(InterpreterObject, ObjectHolder):
      def __init__(self, interpreter, args, kwargs):
          InterpreterObject.__init__(self)
          self.interpreter = interpreter
          ObjectHolder.__init__(self, build.Generator(args, kwargs))
          self.methods.update({'process': self.process_method})
  
      @FeatureNewKwargs('generator.process', '0.45.0', ['preserve_path_from'])
      @permittedKwargs({'extra_args', 'preserve_path_from'})
      def process_method(self, args, kwargs):
          extras = mesonlib.stringlistify(kwargs.get('extra_args', []))
          if 'preserve_path_from' in kwargs:
              preserve_path_from = kwargs['preserve_path_from']
              if not isinstance(preserve_path_from, str):
                  raise InvalidArguments('Preserve_path_from must be a string.')
              preserve_path_from = os.path.normpath(preserve_path_from)
              if not os.path.isabs(preserve_path_from):
                  # This is a bit of a hack. Fix properly before merging.
                  raise InvalidArguments('Preserve_path_from must be an absolute path for now. Sorry.')
          else:
              preserve_path_from = None
          gl = self.held_object.process_files('Generator', args, self.interpreter,
                                              preserve_path_from, extra_args=extras)
          return GeneratedListHolder(gl)
  
  
  class GeneratedListHolder(InterpreterObject, ObjectHolder):
      def __init__(self, arg1, extra_args=[]):
          InterpreterObject.__init__(self)
          if isinstance(arg1, GeneratorHolder):
              ObjectHolder.__init__(self, build.GeneratedList(arg1.held_object, extra_args))
          else:
              ObjectHolder.__init__(self, arg1)
  
      def __repr__(self):
          r = '<{}: {!r}>'
          return r.format(self.__class__.__name__, self.held_object.get_outputs())
  
      def add_file(self, a):
          self.held_object.add_file(a)
  
  class BuildMachine(InterpreterObject, ObjectHolder):
      def __init__(self, compilers):
          self.compilers = compilers
          InterpreterObject.__init__(self)
          held_object = environment.MachineInfo(environment.detect_system(),
                                                environment.detect_cpu_family(self.compilers),
                                                environment.detect_cpu(self.compilers),
                                                sys.byteorder)
          ObjectHolder.__init__(self, held_object)
          self.methods.update({'system': self.system_method,
                               'cpu_family': self.cpu_family_method,
                               'cpu': self.cpu_method,
                               'endian': self.endian_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      @noPosargs
      @permittedKwargs({})
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      @noPosargs
      @permittedKwargs({})
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      @noPosargs
      @permittedKwargs({})
      def endian_method(self, args, kwargs):
          return self.held_object.endian
  
  # This class will provide both host_machine and
  # target_machine
  class CrossMachineInfo(InterpreterObject, ObjectHolder):
      def __init__(self, cross_info):
          InterpreterObject.__init__(self)
          minimum_cross_info = {'cpu', 'cpu_family', 'endian', 'system'}
          if set(cross_info) < minimum_cross_info:
              raise InterpreterException(
                  'Machine info is currently {}\n'.format(cross_info) +
                  'but is missing {}.'.format(minimum_cross_info - set(cross_info)))
          self.info = cross_info
          minfo = environment.MachineInfo(cross_info['system'],
                                          cross_info['cpu_family'],
                                          cross_info['cpu'],
                                          cross_info['endian'])
          ObjectHolder.__init__(self, minfo)
          self.methods.update({'system': self.system_method,
                               'cpu': self.cpu_method,
                               'cpu_family': self.cpu_family_method,
                               'endian': self.endian_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      @noPosargs
      @permittedKwargs({})
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      @noPosargs
      @permittedKwargs({})
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      @noPosargs
      @permittedKwargs({})
      def endian_method(self, args, kwargs):
          return self.held_object.endian
  
  class IncludeDirsHolder(InterpreterObject, ObjectHolder):
      def __init__(self, idobj):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, idobj)
  
  class Headers(InterpreterObject):
  
      def __init__(self, sources, kwargs):
          InterpreterObject.__init__(self)
          self.sources = sources
          self.install_subdir = kwargs.get('subdir', '')
          self.custom_install_dir = kwargs.get('install_dir', None)
          self.custom_install_mode = kwargs.get('install_mode', None)
          if self.custom_install_dir is not None:
              if not isinstance(self.custom_install_dir, str):
                  raise InterpreterException('Custom_install_dir must be a string.')
  
      def set_install_subdir(self, subdir):
          self.install_subdir = subdir
  
      def get_install_subdir(self):
          return self.install_subdir
  
      def get_sources(self):
          return self.sources
  
      def get_custom_install_dir(self):
          return self.custom_install_dir
  
      def get_custom_install_mode(self):
          return self.custom_install_mode
  
  class DataHolder(InterpreterObject, ObjectHolder):
      def __init__(self, data):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, data)
  
      def get_source_subdir(self):
          return self.held_object.source_subdir
  
      def get_sources(self):
          return self.held_object.sources
  
      def get_install_dir(self):
          return self.held_object.install_dir
  
  class InstallDir(InterpreterObject):
      def __init__(self, src_subdir, inst_subdir, install_dir, install_mode, exclude, strip_directory):
          InterpreterObject.__init__(self)
          self.source_subdir = src_subdir
          self.installable_subdir = inst_subdir
          self.install_dir = install_dir
          self.install_mode = install_mode
          self.exclude = exclude
          self.strip_directory = strip_directory
  
  class Man(InterpreterObject):
  
      def __init__(self, sources, kwargs):
          InterpreterObject.__init__(self)
          self.sources = sources
          self.validate_sources()
          self.custom_install_dir = kwargs.get('install_dir', None)
          self.custom_install_mode = kwargs.get('install_mode', None)
          if self.custom_install_dir is not None and not isinstance(self.custom_install_dir, str):
              raise InterpreterException('Custom_install_dir must be a string.')
  
      def validate_sources(self):
          for s in self.sources:
              try:
                  num = int(s.split('.')[-1])
              except (IndexError, ValueError):
                  num = 0
              if num < 1 or num > 8:
                  raise InvalidArguments('Man file must have a file extension of a number between 1 and 8')
  
      def get_custom_install_dir(self):
          return self.custom_install_dir
  
      def get_custom_install_mode(self):
          return self.custom_install_mode
  
      def get_sources(self):
          return self.sources
  
  class GeneratedObjectsHolder(InterpreterObject, ObjectHolder):
      def __init__(self, held_object):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, held_object)
  
  class TargetHolder(InterpreterObject, ObjectHolder):
      def __init__(self, target, interp):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, target)
          self.interpreter = interp
  
  class BuildTargetHolder(TargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
          self.methods.update({'extract_objects': self.extract_objects_method,
                               'extract_all_objects': self.extract_all_objects_method,
                               'get_id': self.get_id_method,
                               'outdir': self.outdir_method,
                               'full_path': self.full_path_method,
                               'private_dir_include': self.private_dir_include_method,
                               })
  
      def __repr__(self):
          r = '<{} {}: {}>'
          h = self.held_object
          return r.format(self.__class__.__name__, h.get_id(), h.filename)
  
      def is_cross(self):
          return self.held_object.is_cross()
  
      @noPosargs
      @permittedKwargs({})
      def private_dir_include_method(self, args, kwargs):
          return IncludeDirsHolder(build.IncludeDirs('', [], False,
                                                     [self.interpreter.backend.get_target_private_dir(self.held_object)]))
  
      @noPosargs
      @permittedKwargs({})
      def full_path_method(self, args, kwargs):
          return self.interpreter.backend.get_target_filename_abs(self.held_object)
  
      @noPosargs
      @permittedKwargs({})
      def outdir_method(self, args, kwargs):
          return self.interpreter.backend.get_target_dir(self.held_object)
  
      @permittedKwargs({})
      def extract_objects_method(self, args, kwargs):
          gobjs = self.held_object.extract_objects(args)
          return GeneratedObjectsHolder(gobjs)
  
      @FeatureNewKwargs('extract_all_objects', '0.46.0', ['recursive'])
      @noPosargs
      @permittedKwargs({'recursive'})
      def extract_all_objects_method(self, args, kwargs):
          recursive = kwargs.get('recursive', False)
          gobjs = self.held_object.extract_all_objects(recursive)
          if gobjs.objlist and 'recursive' not in kwargs:
              mlog.warning('extract_all_objects called without setting recursive '
                           'keyword argument. Meson currently defaults to '
                           'non-recursive to maintain backward compatibility but '
                           'the default will be changed in the future.')
          return GeneratedObjectsHolder(gobjs)
  
      @noPosargs
      @permittedKwargs({})
      def get_id_method(self, args, kwargs):
          return self.held_object.get_id()
  
  class ExecutableHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class StaticLibraryHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class SharedLibraryHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
          # Set to True only when called from self.func_shared_lib().
          target.shared_library_only = False
  
  class BothLibrariesHolder(BuildTargetHolder):
      def __init__(self, shared_holder, static_holder, interp):
          # FIXME: This build target always represents the shared library, but
          # that should be configurable.
          super().__init__(shared_holder.held_object, interp)
          self.shared_holder = shared_holder
          self.static_holder = static_holder
          self.methods.update({'get_shared_lib': self.get_shared_lib_method,
                               'get_static_lib': self.get_static_lib_method,
                               })
  
      def __repr__(self):
          r = '<{} {}: {}, {}: {}>'
          h1 = self.shared_holder.held_object
          h2 = self.static_holder.held_object
          return r.format(self.__class__.__name__, h1.get_id(), h1.filename, h2.get_id(), h2.filename)
  
      @noPosargs
      @permittedKwargs({})
      def get_shared_lib_method(self, args, kwargs):
          return self.shared_holder
  
      @noPosargs
      @permittedKwargs({})
      def get_static_lib_method(self, args, kwargs):
          return self.static_holder
  
  class SharedModuleHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class JarHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class CustomTargetIndexHolder(InterpreterObject, ObjectHolder):
      def __init__(self, object_to_hold):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, object_to_hold)
  
  class CustomTargetHolder(TargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
          self.methods.update({'full_path': self.full_path_method,
                               })
  
      def __repr__(self):
          r = '<{} {}: {}>'
          h = self.held_object
          return r.format(self.__class__.__name__, h.get_id(), h.command)
  
      @noPosargs
      @permittedKwargs({})
      def full_path_method(self, args, kwargs):
          return self.interpreter.backend.get_target_filename_abs(self.held_object)
  
      def __getitem__(self, index):
          return CustomTargetIndexHolder(self.held_object[index])
  
      def __setitem__(self, index, value):
          raise InterpreterException('Cannot set a member of a CustomTarget')
  
      def __delitem__(self, index):
          raise InterpreterException('Cannot delete a member of a CustomTarget')
  
      def outdir_include(self):
          return IncludeDirsHolder(build.IncludeDirs('', [], False,
                                                     [os.path.join('@BUILD_ROOT@', self.interpreter.backend.get_target_dir(self.held_object))]))
  
  class RunTargetHolder(InterpreterObject, ObjectHolder):
      def __init__(self, name, command, args, dependencies, subdir, subproject):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, build.RunTarget(name, command, args, dependencies, subdir, subproject))
  
      def __repr__(self):
          r = '<{} {}: {}>'
          h = self.held_object
          return r.format(self.__class__.__name__, h.get_id(), h.command)
  
  class Test(InterpreterObject):
      def __init__(self, name, project, suite, exe, depends, is_parallel,
                   cmd_args, env, should_fail, timeout, workdir):
          InterpreterObject.__init__(self)
          self.name = name
          self.suite = suite
          self.project_name = project
          self.exe = exe
          self.depends = depends
          self.is_parallel = is_parallel
          self.cmd_args = cmd_args
          self.env = env
          self.should_fail = should_fail
          self.timeout = timeout
          self.workdir = workdir
  
      def get_exe(self):
          return self.exe
  
      def get_name(self):
          return self.name
  
  class SubprojectHolder(InterpreterObject, ObjectHolder):
  
      def __init__(self, subinterpreter):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, subinterpreter)
          self.methods.update({'get_variable': self.get_variable_method,
                               })
  
      @permittedKwargs({})
      def get_variable_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Get_variable takes one argument.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('Get_variable takes a string argument.')
          if varname not in self.held_object.variables:
              raise InvalidArguments('Requested variable "{0}" not found.'.format(varname))
          return self.held_object.variables[varname]
  
  class CompilerHolder(InterpreterObject):
      def __init__(self, compiler, env):
          InterpreterObject.__init__(self)
          self.compiler = compiler
          self.environment = env
          self.methods.update({'compiles': self.compiles_method,
                               'links': self.links_method,
                               'get_id': self.get_id_method,
                               'compute_int': self.compute_int_method,
                               'sizeof': self.sizeof_method,
                               'get_define': self.get_define_method,
                               'check_header': self.check_header_method,
                               'has_header': self.has_header_method,
                               'has_header_symbol': self.has_header_symbol_method,
                               'run': self.run_method,
                               'has_function': self.has_function_method,
                               'has_member': self.has_member_method,
                               'has_members': self.has_members_method,
                               'has_type': self.has_type_method,
                               'alignment': self.alignment_method,
                               'version': self.version_method,
                               'cmd_array': self.cmd_array_method,
                               'find_library': self.find_library_method,
                               'has_argument': self.has_argument_method,
                               'has_multi_arguments': self.has_multi_arguments_method,
                               'get_supported_arguments': self.get_supported_arguments_method,
                               'first_supported_argument': self.first_supported_argument_method,
                               'has_link_argument': self.has_link_argument_method,
                               'has_multi_link_arguments': self.has_multi_link_arguments_method,
                               'get_supported_link_arguments': self.get_supported_link_arguments_method,
                               'first_supported_link_argument': self.first_supported_link_argument_method,
                               'unittest_args': self.unittest_args_method,
                               'symbols_have_underscore_prefix': self.symbols_have_underscore_prefix_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return self.compiler.version
  
      @noPosargs
      @permittedKwargs({})
      def cmd_array_method(self, args, kwargs):
          return self.compiler.exelist
  
      def determine_args(self, kwargs):
          nobuiltins = kwargs.get('no_builtin_args', False)
          if not isinstance(nobuiltins, bool):
              raise InterpreterException('Type of no_builtin_args not a boolean.')
          args = []
          incdirs = extract_as_list(kwargs, 'include_directories')
          for i in incdirs:
              if not isinstance(i, IncludeDirsHolder):
                  raise InterpreterException('Include directories argument must be an include_directories object.')
              for idir in i.held_object.get_incdirs():
                  idir = os.path.join(self.environment.get_source_dir(),
                                      i.held_object.get_curdir(), idir)
                  args += self.compiler.get_include_args(idir, False)
          if not nobuiltins:
              opts = self.environment.coredata.compiler_options
              args += self.compiler.get_option_compile_args(opts)
              args += self.compiler.get_option_link_args(opts)
          args += mesonlib.stringlistify(kwargs.get('args', []))
          return args
  
      def determine_dependencies(self, kwargs):
          deps = kwargs.get('dependencies', None)
          if deps is not None:
              deps = listify(deps)
              final_deps = []
              for d in deps:
                  try:
                      d = d.held_object
                  except Exception:
                      pass
                  if isinstance(d, InternalDependency) or not isinstance(d, Dependency):
                      raise InterpreterException('Dependencies must be external dependencies')
                  final_deps.append(d)
              deps = final_deps
          return deps
  
      @permittedKwargs({
          'prefix',
          'args',
          'dependencies',
      })
      def alignment_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Alignment method takes exactly one positional argument.')
          check_stringlist(args)
          typename = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of sizeof must be a string.')
          extra_args = mesonlib.stringlistify(kwargs.get('args', []))
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.alignment(typename, prefix, self.environment, extra_args, deps)
          mlog.log('Checking for alignment of "', mlog.bold(typename), '": ', result, sep='')
          return result
  
      @permittedKwargs({
          'name',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def run_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Run method takes exactly one positional argument.')
          code = args[0]
          if isinstance(code, mesonlib.File):
              code = mesonlib.File.from_absolute_file(
                  code.rel_to_builddir(self.environment.source_dir))
          elif not isinstance(code, str):
              raise InvalidArguments('Argument must be string or file.')
          testname = kwargs.get('name', '')
          if not isinstance(testname, str):
              raise InterpreterException('Testname argument must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.run(code, self.environment, extra_args, deps)
          if len(testname) > 0:
              if not result.compiled:
                  h = mlog.red('DID NOT COMPILE')
              elif result.returncode == 0:
                  h = mlog.green('YES')
              else:
                  h = mlog.red('NO (%d)' % result.returncode)
              mlog.log('Checking if "', mlog.bold(testname), '" runs: ', h, sep='')
          return TryRunResultHolder(result)
  
      @noPosargs
      @permittedKwargs({})
      def get_id_method(self, args, kwargs):
          return self.compiler.get_id()
  
      @noPosargs
      @permittedKwargs({})
      def symbols_have_underscore_prefix_method(self, args, kwargs):
          '''
          Check if the compiler prefixes _ (underscore) to global C symbols
          See: https://en.wikipedia.org/wiki/Name_mangling#C
          '''
          return self.compiler.symbols_have_underscore_prefix(self.environment)
  
      @noPosargs
      @permittedKwargs({})
      def unittest_args_method(self, args, kwargs):
          '''
          This function is deprecated and should not be used.
          It can be removed in a future version of Meson.
          '''
          if not hasattr(self.compiler, 'get_feature_args'):
              raise InterpreterException('This {} compiler has no feature arguments.'.format(self.compiler.get_display_language()))
          build_to_src = os.path.relpath(self.environment.get_source_dir(), self.environment.get_build_dir())
          return self.compiler.get_feature_args({'unittest': 'true'}, build_to_src)
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_member_method(self, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('Has_member takes exactly two arguments.')
          check_stringlist(args)
          typename = args[0]
          membername = args[1]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_member must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_members(typename, [membername], prefix,
                                          self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          mlog.log('Checking whether type "', mlog.bold(typename),
                   '" has member "', mlog.bold(membername), '": ', hadtxt, sep='')
          return had
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_members_method(self, args, kwargs):
          if len(args) < 2:
              raise InterpreterException('Has_members needs at least two arguments.')
          check_stringlist(args)
          typename = args[0]
          membernames = args[1:]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_members must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_members(typename, membernames, prefix,
                                          self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          members = mlog.bold(', '.join(['"{}"'.format(m) for m in membernames]))
          mlog.log('Checking whether type "', mlog.bold(typename),
                   '" has members ', members, ': ', hadtxt, sep='')
          return had
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_function_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Has_function takes exactly one argument.')
          check_stringlist(args)
          funcname = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_function must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_function(funcname, prefix, self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          mlog.log('Checking for function "', mlog.bold(funcname), '": ', hadtxt, sep='')
          return had
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_type_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Has_type takes exactly one argument.')
          check_stringlist(args)
          typename = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_type must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_type(typename, prefix, self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          mlog.log('Checking for type "', mlog.bold(typename), '": ', hadtxt, sep='')
          return had
  
      @FeatureNew('compiler.compute_int', '0.40.0')
      @permittedKwargs({
          'prefix',
          'low',
          'high',
          'guess',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def compute_int_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Compute_int takes exactly one argument.')
          check_stringlist(args)
          expression = args[0]
          prefix = kwargs.get('prefix', '')
          low = kwargs.get('low', None)
          high = kwargs.get('high', None)
          guess = kwargs.get('guess', None)
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of compute_int must be a string.')
          if low is not None and not isinstance(low, int):
              raise InterpreterException('Low argument of compute_int must be an int.')
          if high is not None and not isinstance(high, int):
              raise InterpreterException('High argument of compute_int must be an int.')
          if guess is not None and not isinstance(guess, int):
              raise InterpreterException('Guess argument of compute_int must be an int.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          res = self.compiler.compute_int(expression, low, high, guess, prefix, self.environment, extra_args, deps)
          mlog.log('Computing int of "%s": %d' % (expression, res))
          return res
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def sizeof_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Sizeof takes exactly one argument.')
          check_stringlist(args)
          element = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of sizeof must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          esize = self.compiler.sizeof(element, prefix, self.environment, extra_args, deps)
          mlog.log('Checking for size of "%s": %d' % (element, esize))
          return esize
  
      @FeatureNew('compiler.get_define', '0.40.0')
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def get_define_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('get_define() takes exactly one argument.')
          check_stringlist(args)
          element = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of get_define() must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          value = self.compiler.get_define(element, prefix, self.environment, extra_args, deps)
          mlog.log('Fetching value of define "%s": %s' % (element, value))
          return value
  
      @permittedKwargs({
          'name',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def compiles_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('compiles method takes exactly one argument.')
          code = args[0]
          if isinstance(code, mesonlib.File):
              code = mesonlib.File.from_absolute_file(
                  code.rel_to_builddir(self.environment.source_dir))
          elif not isinstance(code, str):
              raise InvalidArguments('Argument must be string or file.')
          testname = kwargs.get('name', '')
          if not isinstance(testname, str):
              raise InterpreterException('Testname argument must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.compiles(code, self.environment, extra_args, deps)
          if len(testname) > 0:
              if result:
                  h = mlog.green('YES')
              else:
                  h = mlog.red('NO')
              mlog.log('Checking if "', mlog.bold(testname), '" compiles: ', h, sep='')
          return result
  
      @permittedKwargs({
          'name',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def links_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('links method takes exactly one argument.')
          code = args[0]
          if isinstance(code, mesonlib.File):
              code = mesonlib.File.from_absolute_file(
                  code.rel_to_builddir(self.environment.source_dir))
          elif not isinstance(code, str):
              raise InvalidArguments('Argument must be string or file.')
          testname = kwargs.get('name', '')
          if not isinstance(testname, str):
              raise InterpreterException('Testname argument must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.links(code, self.environment, extra_args, deps)
          if len(testname) > 0:
              if result:
                  h = mlog.green('YES')
              else:
                  h = mlog.red('NO')
              mlog.log('Checking if "', mlog.bold(testname), '" links: ', h, sep='')
          return result
  
      @FeatureNew('check_header', '0.47.0')
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def check_header_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('check_header method takes exactly one argument.')
          check_stringlist(args)
          hname = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_header must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          haz = self.compiler.check_header(hname, prefix, self.environment, extra_args, deps)
          if haz:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Check usable header "%s":' % hname, h)
          return haz
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_header_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('has_header method takes exactly one argument.')
          check_stringlist(args)
          hname = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_header must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          haz = self.compiler.has_header(hname, prefix, self.environment, extra_args, deps)
          if haz:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Has header "%s":' % hname, h)
          return haz
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_header_symbol_method(self, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('has_header_symbol method takes exactly two arguments.')
          check_stringlist(args)
          hname = args[0]
          symbol = args[1]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_header_symbol must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          haz = self.compiler.has_header_symbol(hname, symbol, prefix, self.environment, extra_args, deps)
          if haz:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Header <{0}> has symbol "{1}":'.format(hname, symbol), h)
          return haz
  
      @permittedKwargs({
          'required',
          'dirs',
      })
      def find_library_method(self, args, kwargs):
          # TODO add dependencies support?
          if len(args) != 1:
              raise InterpreterException('find_library method takes one argument.')
          libname = args[0]
          if not isinstance(libname, str):
              raise InterpreterException('Library name not a string.')
  
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              mlog.log('Library', mlog.bold(libname), 'skipped: feature', mlog.bold(feature), 'disabled')
              lib = dependencies.ExternalLibrary(libname, None,
                                                 self.environment,
                                                 self.compiler.language,
                                                 silent=True)
              return ExternalLibraryHolder(lib)
  
          search_dirs = mesonlib.stringlistify(kwargs.get('dirs', []))
          for i in search_dirs:
              if not os.path.isabs(i):
                  raise InvalidCode('Search directory %s is not an absolute path.' % i)
          linkargs = self.compiler.find_library(libname, self.environment, search_dirs)
          if required and not linkargs:
              raise InterpreterException('{} library {!r} not found'.format(self.compiler.get_display_language(), libname))
          lib = dependencies.ExternalLibrary(libname, linkargs, self.environment,
                                             self.compiler.language)
          return ExternalLibraryHolder(lib)
  
      @permittedKwargs({})
      def has_argument_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          if len(args) != 1:
              raise InterpreterException('has_argument takes exactly one argument.')
          return self.has_multi_arguments_method(args, kwargs)
  
      @permittedKwargs({})
      def has_multi_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          result = self.compiler.has_multi_arguments(args, self.environment)
          if result:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log(
              'Compiler for {} supports arguments {}:'.format(
                  self.compiler.get_display_language(), ' '.join(args)),
              h)
          return result
  
      @FeatureNew('compiler.get_supported_arguments', '0.43.0')
      @permittedKwargs({})
      def get_supported_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          supported_args = []
          for arg in args:
              if self.has_argument_method(arg, kwargs):
                  supported_args.append(arg)
          return supported_args
  
      @permittedKwargs({})
      def first_supported_argument_method(self, args, kwargs):
          for i in mesonlib.stringlistify(args):
              if self.has_argument_method(i, kwargs):
                  mlog.log('First supported argument:', mlog.bold(i))
                  return [i]
          mlog.log('First supported argument:', mlog.red('None'))
          return []
  
      @FeatureNew('has_link_argument', '0.46.0')
      @permittedKwargs({})
      def has_link_argument_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          if len(args) != 1:
              raise InterpreterException('has_link_argument takes exactly one argument.')
          return self.has_multi_link_arguments_method(args, kwargs)
  
      @FeatureNew('has_multi_link_argument', '0.46.0')
      @permittedKwargs({})
      def has_multi_link_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          result = self.compiler.has_multi_link_arguments(args, self.environment)
          if result:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log(
              'Compiler for {} supports link arguments {}:'.format(
                  self.compiler.get_display_language(), ' '.join(args)),
              h)
          return result
  
      @FeatureNew('get_supported_link_arguments_method', '0.46.0')
      @permittedKwargs({})
      def get_supported_link_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          supported_args = []
          for arg in args:
              if self.has_link_argument_method(arg, kwargs):
                  supported_args.append(arg)
          return supported_args
  
      @FeatureNew('first_supported_link_argument_method', '0.46.0')
      @permittedKwargs({})
      def first_supported_link_argument_method(self, args, kwargs):
          for i in mesonlib.stringlistify(args):
              if self.has_link_argument_method(i, kwargs):
                  mlog.log('First supported link argument:', mlog.bold(i))
                  return [i]
          mlog.log('First supported link argument:', mlog.red('None'))
          return []
  
  ModuleState = namedtuple('ModuleState', [
      'build_to_src', 'subproject', 'subdir', 'current_lineno', 'environment',
      'project_name', 'project_version', 'backend', 'compilers', 'targets',
      'data', 'headers', 'man', 'global_args', 'project_args', 'build_machine',
      'host_machine', 'target_machine'])
  
  class ModuleHolder(InterpreterObject, ObjectHolder):
      def __init__(self, modname, module, interpreter):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, module)
          self.modname = modname
          self.interpreter = interpreter
  
      def method_call(self, method_name, args, kwargs):
          try:
              fn = getattr(self.held_object, method_name)
          except AttributeError:
              raise InvalidArguments('Module %s does not have method %s.' % (self.modname, method_name))
          if method_name.startswith('_'):
              raise InvalidArguments('Function {!r} in module {!r} is private.'.format(method_name, self.modname))
          if not getattr(fn, 'no-args-flattening', False):
              args = flatten(args)
          # This is not 100% reliable but we can't use hash()
          # because the Build object contains dicts and lists.
          num_targets = len(self.interpreter.build.targets)
          state = ModuleState(
              build_to_src=os.path.relpath(self.interpreter.environment.get_source_dir(),
                                           self.interpreter.environment.get_build_dir()),
              subproject=self.interpreter.subproject,
              subdir=self.interpreter.subdir,
              current_lineno=self.interpreter.current_lineno,
              environment=self.interpreter.environment,
              project_name=self.interpreter.build.project_name,
              project_version=self.interpreter.build.dep_manifest[self.interpreter.active_projectname],
              # The backend object is under-used right now, but we will need it:
              # https://github.com/mesonbuild/meson/issues/1419
              backend=self.interpreter.backend,
              compilers=self.interpreter.build.compilers,
              targets=self.interpreter.build.targets,
              data=self.interpreter.build.data,
              headers=self.interpreter.build.get_headers(),
              man=self.interpreter.build.get_man(),
              global_args=self.interpreter.build.global_args,
              project_args=self.interpreter.build.projects_args.get(self.interpreter.subproject, {}),
              build_machine=self.interpreter.builtin['build_machine'].held_object,
              host_machine=self.interpreter.builtin['host_machine'].held_object,
              target_machine=self.interpreter.builtin['target_machine'].held_object,
          )
          if self.held_object.is_snippet(method_name):
              value = fn(self.interpreter, state, args, kwargs)
              return self.interpreter.holderify(value)
          else:
              value = fn(state, args, kwargs)
              if num_targets != len(self.interpreter.build.targets):
                  raise InterpreterException('Extension module altered internal state illegally.')
              return self.interpreter.module_method_callback(value)
  
  class MesonMain(InterpreterObject):
      def __init__(self, build, interpreter):
          InterpreterObject.__init__(self)
          self.build = build
          self.interpreter = interpreter
          self._found_source_scripts = {}
          self.methods.update({'get_compiler': self.get_compiler_method,
                               'is_cross_build': self.is_cross_build_method,
                               'has_exe_wrapper': self.has_exe_wrapper_method,
                               'is_unity': self.is_unity_method,
                               'is_subproject': self.is_subproject_method,
                               'current_source_dir': self.current_source_dir_method,
                               'current_build_dir': self.current_build_dir_method,
                               'source_root': self.source_root_method,
                               'build_root': self.build_root_method,
                               'add_install_script': self.add_install_script_method,
                               'add_postconf_script': self.add_postconf_script_method,
                               'install_dependency_manifest': self.install_dependency_manifest_method,
                               'override_find_program': self.override_find_program_method,
                               'project_version': self.project_version_method,
                               'project_license': self.project_license_method,
                               'version': self.version_method,
                               'project_name': self.project_name_method,
                               'get_cross_property': self.get_cross_property_method,
                               'backend': self.backend_method,
                               })
  
      def _find_source_script(self, name, args):
          # Prefer scripts in the current source directory
          search_dir = os.path.join(self.interpreter.environment.source_dir,
                                    self.interpreter.subdir)
          key = (name, search_dir)
          if key in self._found_source_scripts:
              found = self._found_source_scripts[key]
          else:
              found = dependencies.ExternalProgram(name, search_dir=search_dir)
              if found.found():
                  self._found_source_scripts[key] = found
              else:
                  m = 'Script or command {!r} not found or not executable'
                  raise InterpreterException(m.format(name))
          return build.RunScript(found.get_command(), args)
  
      @permittedKwargs({})
      def add_install_script_method(self, args, kwargs):
          if len(args) < 1:
              raise InterpreterException('add_install_script takes one or more arguments')
          check_stringlist(args, 'add_install_script args must be strings')
          script = self._find_source_script(args[0], args[1:])
          self.build.install_scripts.append(script)
  
      @permittedKwargs({})
      def add_postconf_script_method(self, args, kwargs):
          if len(args) < 1:
              raise InterpreterException('add_postconf_script takes one or more arguments')
          check_stringlist(args, 'add_postconf_script arguments must be strings')
          script = self._find_source_script(args[0], args[1:])
          self.build.postconf_scripts.append(script)
  
      @noPosargs
      @permittedKwargs({})
      def current_source_dir_method(self, args, kwargs):
          src = self.interpreter.environment.source_dir
          sub = self.interpreter.subdir
          if sub == '':
              return src
          return os.path.join(src, sub)
  
      @noPosargs
      @permittedKwargs({})
      def current_build_dir_method(self, args, kwargs):
          src = self.interpreter.environment.build_dir
          sub = self.interpreter.subdir
          if sub == '':
              return src
          return os.path.join(src, sub)
  
      @noPosargs
      @permittedKwargs({})
      def backend_method(self, args, kwargs):
          return self.interpreter.backend.name
  
      @noPosargs
      @permittedKwargs({})
      def source_root_method(self, args, kwargs):
          return self.interpreter.environment.source_dir
  
      @noPosargs
      @permittedKwargs({})
      def build_root_method(self, args, kwargs):
          return self.interpreter.environment.build_dir
  
      @noPosargs
      @permittedKwargs({})
      def has_exe_wrapper_method(self, args, kwargs):
          if self.is_cross_build_method(None, None) and \
             'binaries' in self.build.environment.cross_info.config and \
             self.build.environment.cross_info.need_exe_wrapper():
              exe_wrap = self.build.environment.cross_info.config['binaries'].get('exe_wrapper', None)
              if exe_wrap is None:
                  return False
          # We return True when exe_wrap is defined, when it's not needed, and
          # when we're compiling natively. The last two are semantically confusing.
          # Need to revisit this.
          return True
  
      @noPosargs
      @permittedKwargs({})
      def is_cross_build_method(self, args, kwargs):
          return self.build.environment.is_cross_build()
  
      @permittedKwargs({'native'})
      def get_compiler_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('get_compiler_method must have one and only one argument.')
          cname = args[0]
          native = kwargs.get('native', None)
          if native is None:
              if self.build.environment.is_cross_build():
                  native = False
              else:
                  native = True
          if not isinstance(native, bool):
              raise InterpreterException('Type of "native" must be a boolean.')
          if native:
              clist = self.build.compilers
          else:
              clist = self.build.cross_compilers
          if cname in clist:
              return CompilerHolder(clist[cname], self.build.environment)
          raise InterpreterException('Tried to access compiler for unspecified language "%s".' % cname)
  
      @noPosargs
      @permittedKwargs({})
      def is_unity_method(self, args, kwargs):
          optval = self.interpreter.environment.coredata.get_builtin_option('unity')
          if optval == 'on' or (optval == 'subprojects' and self.interpreter.subproject != ''):
              return True
          return False
  
      @noPosargs
      @permittedKwargs({})
      def is_subproject_method(self, args, kwargs):
          return self.interpreter.is_subproject()
  
      @permittedKwargs({})
      def install_dependency_manifest_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Must specify manifest install file name')
          if not isinstance(args[0], str):
              raise InterpreterException('Argument must be a string.')
          self.build.dep_manifest_name = args[0]
  
      @FeatureNew('override_find_program', '0.46.0')
      @permittedKwargs({})
      def override_find_program_method(self, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('Override needs two arguments')
          name = args[0]
          exe = args[1]
          if not isinstance(name, str):
              raise InterpreterException('First argument must be a string')
          if hasattr(exe, 'held_object'):
              exe = exe.held_object
          if isinstance(exe, mesonlib.File):
              abspath = exe.absolute_path(self.interpreter.environment.source_dir,
                                          self.interpreter.environment.build_dir)
              if not os.path.exists(abspath):
                  raise InterpreterException('Tried to override %s with a file that does not exist.' % name)
              exe = dependencies.ExternalProgram(abspath)
          if not isinstance(exe, dependencies.ExternalProgram):
              # FIXME, make this work if the exe is an Executable target.
              raise InterpreterException('Second argument must be an external program.')
          self.interpreter.add_find_program_override(name, exe)
  
      @noPosargs
      @permittedKwargs({})
      def project_version_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['version']
  
      @FeatureNew('meson.project_license()', '0.45.0')
      @noPosargs
      @permittedKwargs({})
      def project_license_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['license']
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return coredata.version
  
      @noPosargs
      @permittedKwargs({})
      def project_name_method(self, args, kwargs):
          return self.interpreter.active_projectname
  
      @noArgsFlattening
      @permittedKwargs({})
      def get_cross_property_method(self, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InterpreterException('Must have one or two arguments.')
          propname = args[0]
          if not isinstance(propname, str):
              raise InterpreterException('Property name must be string.')
          try:
              props = self.interpreter.environment.cross_info.get_properties()
              return props[propname]
          except Exception:
              if len(args) == 2:
                  return args[1]
              raise InterpreterException('Unknown cross property: %s.' % propname)
  
  
  known_library_kwargs = (
      build.known_shlib_kwargs |
      build.known_stlib_kwargs
  )
  
  known_build_target_kwargs = (
      known_library_kwargs |
      build.known_exe_kwargs |
      build.known_jar_kwargs |
      {'target_type'}
  )
  
  permitted_kwargs = {'add_global_arguments': {'language'},
                      'add_global_link_arguments': {'language'},
                      'add_project_link_arguments': {'language'},
                      'add_languages': {'required'},
                      'add_project_arguments': {'language'},
                      'add_test_setup': {'exe_wrapper', 'gdb', 'timeout_multiplier', 'env'},
                      'benchmark': {'args', 'env', 'should_fail', 'timeout', 'workdir', 'suite'},
                      'build_target': known_build_target_kwargs,
                      'configure_file': {'input', 'output', 'configuration', 'command', 'copy', 'install_dir', 'install_mode', 'capture', 'install', 'format', 'output_format', 'encoding'},
                      'custom_target': {'input', 'output', 'command', 'install', 'install_dir', 'install_mode', 'build_always', 'capture', 'depends', 'depend_files', 'depfile', 'build_by_default', 'build_always_stale'},
                      'dependency': {'default_options', 'fallback', 'language', 'main', 'method', 'modules', 'optional_modules', 'native', 'required', 'static', 'version', 'private_headers'},
                      'declare_dependency': {'include_directories', 'link_with', 'sources', 'dependencies', 'compile_args', 'link_args', 'link_whole', 'version'},
                      'executable': build.known_exe_kwargs,
                      'find_program': {'required', 'native'},
                      'generator': {'arguments', 'output', 'depfile', 'capture', 'preserve_path_from'},
                      'include_directories': {'is_system'},
                      'install_data': {'install_dir', 'install_mode', 'rename', 'sources'},
                      'install_headers': {'install_dir', 'install_mode', 'subdir'},
                      'install_man': {'install_dir', 'install_mode'},
                      'install_subdir': {'exclude_files', 'exclude_directories', 'install_dir', 'install_mode', 'strip_directory'},
                      'jar': build.known_jar_kwargs,
                      'project': {'version', 'meson_version', 'default_options', 'license', 'subproject_dir'},
                      'run_command': {'check', 'capture'},
                      'run_target': {'command', 'depends'},
                      'shared_library': build.known_shlib_kwargs,
                      'shared_module': build.known_shmod_kwargs,
                      'static_library': build.known_stlib_kwargs,
                      'both_libraries': known_library_kwargs,
                      'library': known_library_kwargs,
                      'subdir': {'if_found'},
                      'subproject': {'version', 'default_options'},
                      'test': {'args', 'depends', 'env', 'is_parallel', 'should_fail', 'timeout', 'workdir', 'suite'},
                      'vcs_tag': {'input', 'output', 'fallback', 'command', 'replace_string'},
                      }
  
  
  class Interpreter(InterpreterBase):
  
      def __init__(self, build, backend=None, subproject='', subdir='', subproject_dir='subprojects',
                   modules = None, default_project_options=None):
          super().__init__(build.environment.get_source_dir(), subdir)
          self.an_unpicklable_object = mesonlib.an_unpicklable_object
          self.build = build
          self.environment = build.environment
          self.coredata = self.environment.get_coredata()
          self.backend = backend
          self.subproject = subproject
          if modules is None:
              self.modules = {}
          else:
              self.modules = modules
          # Subproject directory is usually the name of the subproject, but can
          # be different for dependencies provided by wrap files.
          self.subproject_directory_name = subdir.split(os.path.sep)[-1]
          self.subproject_dir = subproject_dir
          self.option_file = os.path.join(self.source_root, self.subdir, 'meson_options.txt')
          self.load_root_meson_file()
          self.sanity_check_ast()
          self.builtin.update({'meson': MesonMain(build, self)})
          self.generators = []
          self.visited_subdirs = {}
          self.project_args_frozen = False
          self.global_args_frozen = False  # implies self.project_args_frozen
          self.subprojects = {}
          self.subproject_stack = []
          # Passed from the outside, only used in subprojects.
          if default_project_options:
              self.default_project_options = default_project_options.copy()
          else:
              self.default_project_options = {}
          self.build_func_dict()
          # build_def_files needs to be defined before parse_project is called
          self.build_def_files = [os.path.join(self.subdir, environment.build_filename)]
          self.parse_project()
          self.builtin['build_machine'] = BuildMachine(self.coredata.compilers)
          if not self.build.environment.is_cross_build():
              self.builtin['host_machine'] = self.builtin['build_machine']
              self.builtin['target_machine'] = self.builtin['build_machine']
          else:
              cross_info = self.build.environment.cross_info
              if cross_info.has_host():
                  self.builtin['host_machine'] = CrossMachineInfo(cross_info.config['host_machine'])
              else:
                  self.builtin['host_machine'] = self.builtin['build_machine']
              if cross_info.has_target():
                  self.builtin['target_machine'] = CrossMachineInfo(cross_info.config['target_machine'])
              else:
                  self.builtin['target_machine'] = self.builtin['host_machine']
  
      def build_func_dict(self):
          self.funcs.update({'add_global_arguments': self.func_add_global_arguments,
                             'add_project_arguments': self.func_add_project_arguments,
                             'add_global_link_arguments': self.func_add_global_link_arguments,
                             'add_project_link_arguments': self.func_add_project_link_arguments,
                             'add_test_setup': self.func_add_test_setup,
                             'add_languages': self.func_add_languages,
                             'assert': self.func_assert,
                             'benchmark': self.func_benchmark,
                             'build_target': self.func_build_target,
                             'configuration_data': self.func_configuration_data,
                             'configure_file': self.func_configure_file,
                             'custom_target': self.func_custom_target,
                             'declare_dependency': self.func_declare_dependency,
                             'dependency': self.func_dependency,
                             'disabler': self.func_disabler,
                             'environment': self.func_environment,
                             'error': self.func_error,
                             'executable': self.func_executable,
                             'generator': self.func_generator,
                             'gettext': self.func_gettext,
                             'get_option': self.func_get_option,
                             'get_variable': self.func_get_variable,
                             'files': self.func_files,
                             'find_library': self.func_find_library,
                             'find_program': self.func_find_program,
                             'include_directories': self.func_include_directories,
                             'import': self.func_import,
                             'install_data': self.func_install_data,
                             'install_headers': self.func_install_headers,
                             'install_man': self.func_install_man,
                             'install_subdir': self.func_install_subdir,
                             'is_variable': self.func_is_variable,
                             'jar': self.func_jar,
                             'join_paths': self.func_join_paths,
                             'library': self.func_library,
                             'message': self.func_message,
                             'warning': self.func_warning,
                             'option': self.func_option,
                             'project': self.func_project,
                             'run_target': self.func_run_target,
                             'run_command': self.func_run_command,
                             'set_variable': self.func_set_variable,
                             'subdir': self.func_subdir,
                             'subdir_done': self.func_subdir_done,
                             'subproject': self.func_subproject,
                             'shared_library': self.func_shared_lib,
                             'shared_module': self.func_shared_module,
                             'static_library': self.func_static_lib,
                             'both_libraries': self.func_both_lib,
                             'test': self.func_test,
                             'vcs_tag': self.func_vcs_tag
                             })
          if 'MESON_UNIT_TEST' in os.environ:
              self.funcs.update({'exception': self.func_exception})
  
      def holderify(self, item):
          if isinstance(item, list):
              return [self.holderify(x) for x in item]
          if isinstance(item, build.CustomTarget):
              return CustomTargetHolder(item, self)
          elif isinstance(item, (int, str)) or item is None:
              return item
          elif isinstance(item, build.Executable):
              return ExecutableHolder(item, self)
          elif isinstance(item, build.GeneratedList):
              return GeneratedListHolder(item)
          elif isinstance(item, build.RunTarget):
              raise RuntimeError('This is not a pipe.')
          elif isinstance(item, build.RunScript):
              raise RuntimeError('Do not do this.')
          elif isinstance(item, build.Data):
              return DataHolder(item)
          elif isinstance(item, dependencies.InternalDependency):
              return InternalDependencyHolder(item)
          elif isinstance(item, dependencies.ExternalDependency):
              return DependencyHolder(item)
          elif isinstance(item, dependencies.ExternalProgram):
              return ExternalProgramHolder(item)
          elif hasattr(item, 'held_object'):
              return item
          else:
              raise InterpreterException('Module returned a value of unknown type.')
  
      def process_new_values(self, invalues):
          invalues = listify(invalues)
          for v in invalues:
              if isinstance(v, (build.BuildTarget, build.CustomTarget, build.RunTarget)):
                  self.add_target(v.name, v)
              elif isinstance(v, list):
                  self.module_method_callback(v)
              elif isinstance(v, build.GeneratedList):
                  pass
              elif isinstance(v, build.RunScript):
                  self.build.install_scripts.append(v)
              elif isinstance(v, build.Data):
                  self.build.data.append(v)
              elif isinstance(v, dependencies.ExternalProgram):
                  return ExternalProgramHolder(v)
              elif isinstance(v, dependencies.InternalDependency):
                  # FIXME: This is special cased and not ideal:
                  # The first source is our new VapiTarget, the rest are deps
                  self.process_new_values(v.sources[0])
              elif hasattr(v, 'held_object'):
                  pass
              else:
                  raise InterpreterException('Module returned a value of unknown type.')
  
      def module_method_callback(self, return_object):
          if not isinstance(return_object, ModuleReturnValue):
              raise InterpreterException('Bug in module, it returned an invalid object')
          invalues = return_object.new_objects
          self.process_new_values(invalues)
          return self.holderify(return_object.return_value)
  
      def get_build_def_files(self):
          return self.build_def_files
  
      def get_variables(self):
          return self.variables
  
      def check_cross_stdlibs(self):
          if self.build.environment.is_cross_build():
              cross_info = self.build.environment.cross_info
              for l, c in self.build.cross_compilers.items():
                  try:
                      di = mesonlib.stringlistify(cross_info.get_stdlib(l))
                      if len(di) != 2:
                          raise InterpreterException('Stdlib definition for %s should have exactly two elements.'
                                                     % l)
                      projname, depname = di
                      subproj = self.do_subproject(projname, {})
                      self.build.cross_stdlibs[l] = subproj.get_variable_method([depname], {})
                  except KeyError:
                      pass
                  except InvalidArguments:
                      pass
  
      @stringArgs
      @noKwargs
      def func_import(self, node, args, kwargs):
          if len(args) != 1:
              raise InvalidCode('Import takes one argument.')
          modname = args[0]
          if modname.startswith('unstable-'):
              plainname = modname.split('-', 1)[1]
              mlog.warning('Module %s has no backwards or forwards compatibility and might not exist in future releases.' % modname, location=node)
              modname = 'unstable_' + plainname
          if modname not in self.modules:
              try:
                  module = importlib.import_module('mesonbuild.modules.' + modname)
              except ImportError:
                  raise InvalidArguments('Module "%s" does not exist' % (modname, ))
              self.modules[modname] = module.initialize(self)
          return ModuleHolder(modname, self.modules[modname], self)
  
      @stringArgs
      @noKwargs
      def func_files(self, node, args, kwargs):
          return [mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, fname) for fname in args]
  
      @FeatureNewKwargs('declare_dependency', '0.46.0', ['link_whole'])
      @permittedKwargs(permitted_kwargs['declare_dependency'])
      @noPosargs
      def func_declare_dependency(self, node, args, kwargs):
          version = kwargs.get('version', self.project_version)
          if not isinstance(version, str):
              raise InterpreterException('Version must be a string.')
          incs = extract_as_list(kwargs, 'include_directories', unholder=True)
          libs = extract_as_list(kwargs, 'link_with', unholder=True)
          libs_whole = extract_as_list(kwargs, 'link_whole', unholder=True)
          sources = extract_as_list(kwargs, 'sources')
          sources = listify(self.source_strings_to_files(sources), unholder=True)
          deps = extract_as_list(kwargs, 'dependencies', unholder=True)
          compile_args = mesonlib.stringlistify(kwargs.get('compile_args', []))
          link_args = mesonlib.stringlistify(kwargs.get('link_args', []))
          final_deps = []
          for d in deps:
              try:
                  d = d.held_object
              except Exception:
                  pass
              if not isinstance(d, (dependencies.Dependency, dependencies.ExternalLibrary, dependencies.InternalDependency)):
                  raise InterpreterException('Dependencies must be external deps')
              final_deps.append(d)
          for l in libs:
              if isinstance(l, dependencies.Dependency):
                  raise InterpreterException('''Entries in "link_with" may only be self-built targets,
  external dependencies (including libraries) must go to "dependencies".''')
          dep = dependencies.InternalDependency(version, incs, compile_args,
                                                link_args, libs, libs_whole, sources, final_deps)
          return DependencyHolder(dep)
  
      @noKwargs
      def func_assert(self, node, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('Assert takes exactly two arguments')
          value, message = args
          if not isinstance(value, bool):
              raise InterpreterException('Assert value not bool.')
          if not isinstance(message, str):
              raise InterpreterException('Assert message not a string.')
          if not value:
              raise InterpreterException('Assert failed: ' + message)
  
      def validate_arguments(self, args, argcount, arg_types):
          if argcount is not None:
              if argcount != len(args):
                  raise InvalidArguments('Expected %d arguments, got %d.' %
                                         (argcount, len(args)))
          for i in range(min(len(args), len(arg_types))):
              wanted = arg_types[i]
              actual = args[i]
              if wanted is not None:
                  if not isinstance(actual, wanted):
                      raise InvalidArguments('Incorrect argument type.')
  
      @FeatureNewKwargs('run_command', '0.47.0', ['check', 'capture'])
      @permittedKwargs(permitted_kwargs['run_command'])
      def func_run_command(self, node, args, kwargs):
          return self.run_command_impl(node, args, kwargs)
  
      def run_command_impl(self, node, args, kwargs, in_builddir=False):
          if len(args) < 1:
              raise InterpreterException('Not enough arguments')
          cmd = args[0]
          cargs = args[1:]
          capture = kwargs.get('capture', True)
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
  
          check = kwargs.get('check', False)
          if not isinstance(check, bool):
              raise InterpreterException('Check must be boolean.')
  
          m = 'must be a string, or the output of find_program(), files() '\
              'or configure_file(), or a compiler object; not {!r}'
          if isinstance(cmd, ExternalProgramHolder):
              cmd = cmd.held_object
          elif isinstance(cmd, CompilerHolder):
              cmd = cmd.compiler.get_exelist()[0]
              prog = ExternalProgram(cmd, silent=True)
              if not prog.found():
                  raise InterpreterException('Program {!r} not found '
                                             'or not executable'.format(cmd))
              cmd = prog
          else:
              if isinstance(cmd, mesonlib.File):
                  cmd = cmd.absolute_path(srcdir, builddir)
              elif not isinstance(cmd, str):
                  raise InterpreterException('First argument ' + m.format(cmd))
              # Prefer scripts in the current source directory
              search_dir = os.path.join(srcdir, self.subdir)
              prog = ExternalProgram(cmd, silent=True, search_dir=search_dir)
              if not prog.found():
                  raise InterpreterException('Program or command {!r} not found '
                                             'or not executable'.format(cmd))
              cmd = prog
          try:
              cmd_path = os.path.relpath(cmd.get_path(), start=srcdir)
          except ValueError:
              # On Windows a relative path can't be evaluated for
              # paths on two different drives (i.e. c:\foo and f:\bar).
              # The only thing left to is is to use the original absolute
              # path.
              cmd_path = cmd.get_path()
          if not cmd_path.startswith('..') and cmd_path not in self.build_def_files:
              self.build_def_files.append(cmd_path)
          expanded_args = []
          for a in listify(cargs):
              if isinstance(a, str):
                  expanded_args.append(a)
              elif isinstance(a, mesonlib.File):
                  expanded_args.append(a.absolute_path(srcdir, builddir))
              elif isinstance(a, ExternalProgramHolder):
                  expanded_args.append(a.held_object.get_path())
              else:
                  raise InterpreterException('Arguments ' + m.format(a))
          for a in expanded_args:
              if not os.path.isabs(a):
                  a = os.path.join(builddir if in_builddir else srcdir, self.subdir, a)
              if os.path.isfile(a):
                  a = os.path.relpath(a, start=srcdir)
                  if not a.startswith('..'):
                      if a not in self.build_def_files:
                          self.build_def_files.append(a)
          return RunProcess(cmd, expanded_args, srcdir, builddir, self.subdir,
                            self.environment.get_build_command() + ['introspect'],
                            in_builddir=in_builddir, check=check, capture=capture)
  
      @stringArgs
      def func_gettext(self, nodes, args, kwargs):
          raise InterpreterException('Gettext() function has been moved to module i18n. Import it and use i18n.gettext() instead')
  
      def func_option(self, nodes, args, kwargs):
          raise InterpreterException('Tried to call option() in build description file. All options must be in the option file.')
  
      @FeatureNewKwargs('subproject', '0.38.0', ['default_options'])
      @permittedKwargs(permitted_kwargs['subproject'])
      @stringArgs
      def func_subproject(self, nodes, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Subproject takes exactly one argument')
          dirname = args[0]
          return self.do_subproject(dirname, kwargs)
  
      def do_subproject(self, dirname, kwargs):
          default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
          default_options = coredata.create_options_dict(default_options)
          if dirname == '':
              raise InterpreterException('Subproject dir name must not be empty.')
          if dirname[0] == '.':
              raise InterpreterException('Subproject dir name must not start with a period.')
          if '..' in dirname:
              raise InterpreterException('Subproject name must not contain a ".." path segment.')
          if os.path.isabs(dirname):
              raise InterpreterException('Subproject name must not be an absolute path.')
          if has_path_sep(dirname):
              mlog.warning('Subproject name has a path separator. This may cause unexpected behaviour.')
          if dirname in self.subproject_stack:
              fullstack = self.subproject_stack + [dirname]
              incpath = ' => '.join(fullstack)
              raise InvalidCode('Recursive include of subprojects: %s.' % incpath)
          if dirname in self.subprojects:
              return self.subprojects[dirname]
          subproject_dir_abs = os.path.join(self.environment.get_source_dir(), self.subproject_dir)
          r = wrap.Resolver(subproject_dir_abs, self.coredata.wrap_mode)
          try:
              resolved = r.resolve(dirname)
          except RuntimeError as e:
              # if the reason subproject execution failed was because
              # the directory doesn't exist, try to give some helpful
              # advice if it's a nested subproject that needs
              # promotion...
              self.print_nested_info(dirname)
  
              msg = 'Subproject directory {!r} does not exist and cannot be downloaded:\n{}'
              raise InterpreterException(msg.format(os.path.join(self.subproject_dir, dirname), e))
          subdir = os.path.join(self.subproject_dir, resolved)
          os.makedirs(os.path.join(self.build.environment.get_build_dir(), subdir), exist_ok=True)
          self.global_args_frozen = True
          mlog.log()
          with mlog.nested():
              mlog.log('\nExecuting subproject ', mlog.bold(dirname), '.\n', sep='')
              subi = Interpreter(self.build, self.backend, dirname, subdir, self.subproject_dir,
                                 self.modules, default_options)
              subi.subprojects = self.subprojects
  
              subi.subproject_stack = self.subproject_stack + [dirname]
              current_active = self.active_projectname
              subi.run()
              mlog.log('\nSubproject', mlog.bold(dirname), 'finished.')
  
          if 'version' in kwargs:
              pv = subi.project_version
              wanted = kwargs['version']
              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))
          self.active_projectname = current_active
          self.build.subprojects[dirname] = subi.project_version
          self.subprojects.update(subi.subprojects)
          self.subprojects[dirname] = SubprojectHolder(subi)
          self.build_def_files += subi.build_def_files
          return self.subprojects[dirname]
  
      def get_option_internal(self, optname):
          undecorated_optname = optname
          try:
              return self.coredata.base_options[optname]
          except KeyError:
              pass
          try:
              return self.coredata.builtins[optname]
          except KeyError:
              pass
          try:
              return self.coredata.compiler_options[optname]
          except KeyError:
              pass
          if not coredata.is_builtin_option(optname) and self.is_subproject():
              optname = self.subproject + ':' + optname
          try:
              opt = self.coredata.user_options[optname]
              if opt.yielding and ':' in optname:
                  # If option not present in superproject, keep the original.
                  opt = self.coredata.user_options.get(undecorated_optname, opt)
              return opt
          except KeyError:
              pass
          # Some base options are not defined in some environments, return the default value.
          try:
              return compilers.base_options[optname]
          except KeyError:
              pass
          raise InterpreterException('Tried to access unknown option "%s".' % optname)
  
      @stringArgs
      @noKwargs
      def func_get_option(self, nodes, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Argument required for get_option.')
          optname = args[0]
          if ':' in optname:
              raise InterpreterException('Having a colon in option name is forbidden, '
                                         'projects are not allowed to directly access '
                                         'options of other subprojects.')
          opt = self.get_option_internal(optname)
          if isinstance(opt, coredata.UserFeatureOption):
              return FeatureOptionHolder(self.environment, opt)
          elif isinstance(opt, coredata.UserOption):
              return opt.value
          return opt
  
      @noKwargs
      def func_configuration_data(self, node, args, kwargs):
          if args:
              raise InterpreterException('configuration_data takes no arguments')
          return ConfigurationDataHolder()
  
      def set_options(self, default_options):
          # Set default options as if they were passed to the command line.
          # Subprojects can only define default for user options.
          for k, v in default_options.items():
              if self.subproject:
                  if optinterpreter.is_invalid_name(k):
                      continue
                  k = self.subproject + ':' + k
              self.environment.cmd_line_options.setdefault(k, v)
  
          # Create a subset of cmd_line_options, keeping only options for this
          # subproject. Also take builtin options if it's the main project.
          # Language and backend specific options will be set later when adding
          # languages and setting the backend (builtin options must be set first
          # to know which backend we'll use).
          options = {}
          for k, v in self.environment.cmd_line_options.items():
              if self.subproject:
                  if not k.startswith(self.subproject + ':'):
                      continue
              elif k not in coredata.get_builtin_options():
                  if ':' in k:
                      continue
                  if optinterpreter.is_invalid_name(k):
                      continue
              options[k] = v
  
          self.coredata.set_options(options, self.subproject)
  
      def set_backend(self):
          # The backend is already set when parsing subprojects
          if self.backend is not None:
              return
          backend = self.coredata.get_builtin_option('backend')
          if backend == 'ninja':
              from .backend import ninjabackend
              self.backend = ninjabackend.NinjaBackend(self.build)
          elif backend == 'vs':
              from .backend import vs2010backend
              self.backend = vs2010backend.autodetect_vs_version(self.build)
              self.coredata.set_builtin_option('backend', self.backend.name)
              mlog.log('Auto detected Visual Studio backend:', mlog.bold(self.backend.name))
          elif backend == 'vs2010':
              from .backend import vs2010backend
              self.backend = vs2010backend.Vs2010Backend(self.build)
          elif backend == 'vs2015':
              from .backend import vs2015backend
              self.backend = vs2015backend.Vs2015Backend(self.build)
          elif backend == 'vs2017':
              from .backend import vs2017backend
              self.backend = vs2017backend.Vs2017Backend(self.build)
          elif backend == 'xcode':
              from .backend import xcodebackend
              self.backend = xcodebackend.XCodeBackend(self.build)
          else:
              raise InterpreterException('Unknown backend "%s".' % backend)
  
          # Only init backend options on first invocation otherwise it would
          # override values previously set from command line.
          if self.environment.first_invocation:
              self.coredata.init_backend_options(backend)
  
          options = {k: v for k, v in self.environment.cmd_line_options.items() if k.startswith('backend_')}
          self.coredata.set_options(options)
  
      @stringArgs
      @permittedKwargs(permitted_kwargs['project'])
      def func_project(self, node, args, kwargs):
          if len(args) < 1:
              raise InvalidArguments('Not enough arguments to project(). Needs at least the project name.')
          proj_name = args[0]
          proj_langs = args[1:]
          if ':' in proj_name:
              raise InvalidArguments("Project name {!r} must not contain ':'".format(proj_name))
  
          if os.path.exists(self.option_file):
              oi = optinterpreter.OptionInterpreter(self.subproject)
              oi.process(self.option_file)
              self.coredata.merge_user_options(oi.options)
  
          # Do not set default_options on reconfigure otherwise it would override
          # values previously set from command line. That means that changing
          # default_options in a project will trigger a reconfigure but won't
          # have any effect.
          if self.environment.first_invocation:
              default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
              default_options = coredata.create_options_dict(default_options)
              default_options.update(self.default_project_options)
          else:
              default_options = {}
          self.set_options(default_options)
          self.set_backend()
  
          if not self.is_subproject():
              self.build.project_name = proj_name
          self.active_projectname = proj_name
          self.project_version = kwargs.get('version', 'undefined')
          if self.build.project_version is None:
              self.build.project_version = self.project_version
          proj_license = mesonlib.stringlistify(kwargs.get('license', 'unknown'))
          self.build.dep_manifest[proj_name] = {'version': self.project_version,
                                                'license': proj_license}
          if self.subproject in self.build.projects:
              raise InvalidCode('Second call to project().')
          if not self.is_subproject() and 'subproject_dir' in kwargs:
              spdirname = kwargs['subproject_dir']
              if not isinstance(spdirname, str):
                  raise InterpreterException('Subproject_dir must be a string')
              if os.path.isabs(spdirname):
                  raise InterpreterException('Subproject_dir must not be an absolute path.')
              if spdirname.startswith('.'):
                  raise InterpreterException('Subproject_dir must not begin with a period.')
              if '..' in spdirname:
                  raise InterpreterException('Subproject_dir must not contain a ".." segment.')
              self.subproject_dir = spdirname
  
          self.build.subproject_dir = self.subproject_dir
  
          if 'meson_version' in kwargs:
              cv = coredata.version
              pv = kwargs['meson_version']
              mesonlib.target_version = pv
              if not mesonlib.version_compare(cv, pv):
                  raise InterpreterException('Meson version is %s but project requires %s.' % (cv, pv))
          self.build.projects[self.subproject] = proj_name
          mlog.log('Project name: ', mlog.bold(proj_name), sep='')
          mlog.log('Project version: ', mlog.bold(self.project_version), sep='')
          self.add_languages(proj_langs, True)
          langs = self.coredata.compilers.keys()
          if 'vala' in langs:
              if 'c' not in langs:
                  raise InterpreterException('Compiling Vala requires C. Add C to your project languages and rerun Meson.')
          if not self.is_subproject():
              self.check_cross_stdlibs()
  
      @permittedKwargs(permitted_kwargs['add_languages'])
      @stringArgs
      def func_add_languages(self, node, args, kwargs):
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              for lang in sorted(args, key=compilers.sort_clink):
                  mlog.log('Compiler for language', mlog.bold(lang), 'skipped: feature', mlog.bold(feature), 'disabled')
              return False
          return self.add_languages(args, required)
  
      def get_message_string_arg(self, node):
          # reduce arguments again to avoid flattening posargs
          (posargs, _) = self.reduce_arguments(node.args)
          if len(posargs) != 1:
              raise InvalidArguments('Expected 1 argument, got %d' % len(posargs))
  
          arg = posargs[0]
          if isinstance(arg, list):
              argstr = stringifyUserArguments(arg)
          elif isinstance(arg, dict):
              argstr = stringifyUserArguments(arg)
          elif isinstance(arg, str):
              argstr = arg
          elif isinstance(arg, int):
              argstr = str(arg)
          else:
              raise InvalidArguments('Function accepts only strings, integers, lists and lists thereof.')
  
          return argstr
  
      @noKwargs
      def func_message(self, node, args, kwargs):
          argstr = self.get_message_string_arg(node)
          mlog.log(mlog.bold('Message:'), argstr)
  
      @FeatureNew('warning()', '0.44.0')
      @noKwargs
      def func_warning(self, node, args, kwargs):
          argstr = self.get_message_string_arg(node)
          mlog.warning(argstr, location=node)
  
      @noKwargs
      def func_error(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          raise InterpreterException('Problem encountered: ' + args[0])
  
      @noKwargs
      def func_exception(self, node, args, kwargs):
          self.validate_arguments(args, 0, [])
          raise Exception()
  
      def detect_compilers(self, lang, need_cross_compiler):
          cross_comp = None
          if lang == 'c':
              comp = self.environment.detect_c_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_c_compiler(True)
          elif lang == 'cpp':
              comp = self.environment.detect_cpp_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_cpp_compiler(True)
          elif lang == 'objc':
              comp = self.environment.detect_objc_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_objc_compiler(True)
          elif lang == 'objcpp':
              comp = self.environment.detect_objcpp_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_objcpp_compiler(True)
          elif lang == 'java':
              comp = self.environment.detect_java_compiler()
              if need_cross_compiler:
                  cross_comp = comp  # Java is platform independent.
          elif lang == 'cs':
              comp = self.environment.detect_cs_compiler()
              if need_cross_compiler:
                  cross_comp = comp  # C# is platform independent.
          elif lang == 'vala':
              comp = self.environment.detect_vala_compiler()
              if need_cross_compiler:
                  cross_comp = comp  # Vala compiles to platform-independent C
          elif lang == 'd':
              comp = self.environment.detect_d_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_d_compiler(True)
          elif lang == 'rust':
              comp = self.environment.detect_rust_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_rust_compiler(True)
          elif lang == 'fortran':
              comp = self.environment.detect_fortran_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_fortran_compiler(True)
          elif lang == 'swift':
              comp = self.environment.detect_swift_compiler()
              if need_cross_compiler:
                  raise InterpreterException('Cross compilation with Swift is not working yet.')
                  # cross_comp = self.environment.detect_fortran_compiler(True)
          else:
              raise InvalidCode('Tried to use unknown language "%s".' % lang)
          comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
          self.coredata.compilers[lang] = comp
          # Native compiler always exist so always add its options.
          new_options = comp.get_options()
          if cross_comp is not None:
              cross_comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
              self.coredata.cross_compilers[lang] = cross_comp
              new_options.update(cross_comp.get_options())
  
          optprefix = lang + '_'
          for k, o in new_options.items():
              if not k.startswith(optprefix):
                  raise InterpreterException('Internal error, %s has incorrect prefix.' % k)
              if k in self.environment.cmd_line_options:
                  o.set_value(self.environment.cmd_line_options[k])
              self.coredata.compiler_options.setdefault(k, o)
  
          # Unlike compiler and linker flags, preprocessor flags are not in
          # compiler_options because they are not visible to user.
          preproc_flags = comp.get_preproc_flags()
          preproc_flags = shlex.split(preproc_flags)
          self.coredata.external_preprocess_args.setdefault(lang, preproc_flags)
  
          return comp, cross_comp
  
      def add_languages(self, args, required):
          success = True
          need_cross_compiler = self.environment.is_cross_build() and self.environment.cross_info.need_cross_compiler()
          for lang in sorted(args, key=compilers.sort_clink):
              lang = lang.lower()
              if lang in self.coredata.compilers:
                  comp = self.coredata.compilers[lang]
                  cross_comp = self.coredata.cross_compilers.get(lang, None)
              else:
                  try:
                      (comp, cross_comp) = self.detect_compilers(lang, need_cross_compiler)
                  except Exception:
                      if not required:
                          mlog.log('Compiler for language', mlog.bold(lang), 'not found.')
                          success = False
                          continue
                      else:
                          raise
              if comp.full_version is not None:
                  version_string = ' (%s %s "%s")' % (comp.id, comp.version, comp.full_version)
              else:
                  version_string = ' (%s %s)' % (comp.id, comp.version)
              mlog.log('Native %s compiler: ' % comp.get_display_language(), mlog.bold(' '.join(comp.get_exelist())), version_string, sep='')
  
              self.build.add_compiler(comp)
              if need_cross_compiler:
                  mlog.log('Cross %s compiler: ' % cross_comp.get_display_language(), mlog.bold(' '.join(cross_comp.get_exelist())), ' (%s %s)' % (cross_comp.id, cross_comp.version), sep='')
                  self.build.add_cross_compiler(cross_comp)
              if self.environment.is_cross_build() and not need_cross_compiler:
                  self.build.add_cross_compiler(comp)
              self.add_base_options(comp)
          return success
  
      def emit_base_options_warnings(self, enabled_opts):
          if 'b_bitcode' in enabled_opts:
              mlog.warning('Base option \'b_bitcode\' is enabled, which is incompatible with many linker options. Incompatible options such as such as \'b_asneeded\' have been disabled.')
              mlog.warning('Please see https://mesonbuild.com/Builtin-options.html#Notes_about_Apple_Bitcode_support for more details.')
  
      def add_base_options(self, compiler):
          enabled_opts = []
          for optname in compiler.base_options:
              if optname in self.coredata.base_options:
                  continue
              oobj = compilers.base_options[optname]
              if optname in self.environment.cmd_line_options:
                  oobj.set_value(self.environment.cmd_line_options[optname])
                  enabled_opts.append(optname)
              self.coredata. base_options[optname] = oobj
          self.emit_base_options_warnings(enabled_opts)
  
      def program_from_cross_file(self, prognames, silent=False):
          bins = self.environment.cross_info.config['binaries']
          for p in prognames:
              if hasattr(p, 'held_object'):
                  p = p.held_object
              if isinstance(p, mesonlib.File):
                  continue # Always points to a local (i.e. self generated) file.
              if not isinstance(p, str):
                  raise InterpreterException('Executable name must be a string.')
              if p in bins:
                  exename = bins[p]
                  extprog = dependencies.ExternalProgram(exename, silent=silent)
                  progobj = ExternalProgramHolder(extprog)
                  return progobj
  
      def program_from_system(self, args, silent=False):
          # Search for scripts relative to current subdir.
          # Do not cache found programs because find_program('foobar')
          # might give different results when run from different source dirs.
          source_dir = os.path.join(self.environment.get_source_dir(), self.subdir)
          for exename in args:
              if isinstance(exename, mesonlib.File):
                  if exename.is_built:
                      search_dir = os.path.join(self.environment.get_build_dir(),
                                                exename.subdir)
                  else:
                      search_dir = os.path.join(self.environment.get_source_dir(),
                                                exename.subdir)
                  exename = exename.fname
              elif isinstance(exename, str):
                  search_dir = source_dir
              else:
                  raise InvalidArguments('find_program only accepts strings and '
                                         'files, not {!r}'.format(exename))
              extprog = dependencies.ExternalProgram(exename, search_dir=search_dir,
                                                     silent=silent)
              progobj = ExternalProgramHolder(extprog)
              if progobj.found():
                  return progobj
  
      def program_from_overrides(self, command_names, silent=False):
          for name in command_names:
              if not isinstance(name, str):
                  continue
              if name in self.build.find_overrides:
                  exe = self.build.find_overrides[name]
                  if not silent:
                      mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
                               '(overridden: %s)' % ' '.join(exe.command))
                  return ExternalProgramHolder(exe)
          return None
  
      def store_name_lookups(self, command_names):
          for name in command_names:
              if isinstance(name, str):
                  self.build.searched_programs.add(name)
  
      def add_find_program_override(self, name, exe):
          if name in self.build.searched_programs:
              raise InterpreterException('Tried to override finding of executable "%s" which has already been found.'
                                         % name)
          if name in self.build.find_overrides:
              raise InterpreterException('Tried to override executable "%s" which has already been overridden.'
                                         % name)
          self.build.find_overrides[name] = exe
  
      def find_program_impl(self, args, native=False, required=True, silent=True):
          if not isinstance(args, list):
              args = [args]
          progobj = self.program_from_overrides(args, silent=silent)
          if progobj is None and self.build.environment.is_cross_build():
              if not native:
                  progobj = self.program_from_cross_file(args, silent=silent)
          if progobj is None:
              progobj = self.program_from_system(args, silent=silent)
          if required and (progobj is None or not progobj.found()):
              raise InvalidArguments('Program(s) {!r} not found or not executable'.format(args))
          if progobj is None:
              return ExternalProgramHolder(dependencies.NonExistingExternalProgram())
          # Only store successful lookups
          self.store_name_lookups(args)
          return progobj
  
      @permittedKwargs(permitted_kwargs['find_program'])
      def func_find_program(self, node, args, kwargs):
          if not args:
              raise InterpreterException('No program name specified.')
  
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              mlog.log('Program', mlog.bold(' '.join(args)), 'skipped: feature', mlog.bold(feature), 'disabled')
              return ExternalProgramHolder(dependencies.NonExistingExternalProgram())
  
          if not isinstance(required, bool):
              raise InvalidArguments('"required" argument must be a boolean.')
          use_native = kwargs.get('native', False)
          if not isinstance(use_native, bool):
              raise InvalidArguments('Argument to "native" must be a boolean.')
          return self.find_program_impl(args, native=use_native, required=required, silent=False)
  
      def func_find_library(self, node, args, kwargs):
          raise InvalidCode('find_library() is removed, use meson.get_compiler(\'name\').find_library() instead.\n'
                            'Look here for documentation: http://mesonbuild.com/Reference-manual.html#compiler-object\n'
                            'Look here for example: http://mesonbuild.com/howtox.html#add-math-library-lm-portably\n'
                            )
  
      def _find_cached_dep(self, name, kwargs):
          # Check if we want this as a cross-dep or a native-dep
          # FIXME: Not all dependencies support such a distinction right now,
          # and we repeat this check inside dependencies that do. We need to
          # consolidate this somehow.
          is_cross = self.environment.is_cross_build()
          if 'native' in kwargs and is_cross:
              want_cross = not kwargs['native']
          else:
              want_cross = is_cross
          identifier = dependencies.get_dep_identifier(name, kwargs, want_cross)
          cached_dep = None
          # Check if we've already searched for and found this dep
          if identifier in self.coredata.deps:
              cached_dep = self.coredata.deps[identifier]
              mlog.log('Dependency', mlog.bold(name),
                       'found:', mlog.green('YES'), '(cached)')
          else:
              # Check if exactly the same dep with different version requirements
              # was found already.
              wanted = identifier[1]
              for trial, trial_dep in self.coredata.deps.items():
                  # trial[1], identifier[1] are the version requirements
                  if trial[0] != identifier[0] or trial[2:] != identifier[2:]:
                      continue
                  found = trial_dep.get_version()
                  if not wanted or mesonlib.version_compare_many(found, wanted)[0]:
                      # We either don't care about the version, or our
                      # version requirements matched the trial dep's version.
                      cached_dep = trial_dep
                      break
          return identifier, cached_dep
  
      @staticmethod
      def check_subproject_version(wanted, found):
          if wanted == 'undefined':
              return True
          if found == 'undefined' or not mesonlib.version_compare_many(found, wanted)[0]:
              return False
          return True
  
      def get_subproject_dep(self, name, dirname, varname, required):
          try:
              dep = self.subprojects[dirname].get_variable_method([varname], {})
          except InvalidArguments as e:
              if required:
                  raise DependencyException('Could not find dependency {} in subproject {}; {}'
                                            ''.format(varname, dirname, str(e)))
              # If the dependency is not required, don't raise an exception
              subproj_path = os.path.join(self.subproject_dir, dirname)
              mlog.log('Dependency', mlog.bold(name), 'from subproject',
                       mlog.bold(subproj_path), 'found:', mlog.red('NO'))
              return None
          if not isinstance(dep, DependencyHolder):
              raise InvalidCode('Fetched variable {!r} in the subproject {!r} is '
                                'not a dependency object.'.format(varname, dirname))
          return dep
  
      def _find_cached_fallback_dep(self, name, dirname, varname, wanted, required):
          if dirname not in self.subprojects:
              return False
          dep = self.get_subproject_dep(name, dirname, varname, required)
          if not dep:
              return False
          found = dep.version_method([], {})
          if self.check_subproject_version(wanted, found):
              subproj_path = os.path.join(self.subproject_dir, dirname)
              mlog.log('Dependency', mlog.bold(name), 'from subproject',
                       mlog.bold(subproj_path), 'found:', mlog.green('YES'), '(cached)')
              return dep
          if required:
              raise DependencyException('Version {} of subproject dependency {} already '
                                        'cached, requested incompatible version {} for '
                                        'dep {}'.format(found, dirname, wanted, name))
          return None
  
      @FeatureNewKwargs('dependency', '0.40.0', ['method'])
      @FeatureNewKwargs('dependency', '0.38.0', ['default_options'])
      @permittedKwargs(permitted_kwargs['dependency'])
      def func_dependency(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          name = args[0]
  
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              mlog.log('Dependency', mlog.bold(name), 'skipped: feature', mlog.bold(feature), 'disabled')
              return DependencyHolder(NotFoundDependency(self.environment))
  
          if name == '':
              if required:
                  raise InvalidArguments('Dependency is both required and not-found')
              return DependencyHolder(NotFoundDependency(self.environment))
  
          if '<' in name or '>' in name or '=' in name:
              raise InvalidArguments('Characters <, > and = are forbidden in dependency names. To specify'
                                     'version\n requirements use the \'version\' keyword argument instead.')
          identifier, cached_dep = self._find_cached_dep(name, kwargs)
  
          if cached_dep:
              if required and not cached_dep.found():
                  m = 'Dependency {!r} was already checked and was not found'
                  raise DependencyException(m.format(name))
              dep = cached_dep
          else:
              # If the dependency has already been configured, possibly by
              # a higher level project, try to use it first.
              if 'fallback' in kwargs:
                  dirname, varname = self.get_subproject_infos(kwargs)
                  wanted = kwargs.get('version', 'undefined')
                  dep = self._find_cached_fallback_dep(name, dirname, varname, wanted, required)
                  if dep:
                      return dep
  
              # We need to actually search for this dep
              exception = None
              dep = NotFoundDependency(self.environment)
  
              # Search for it outside the project
              if self.coredata.wrap_mode != WrapMode.forcefallback or 'fallback' not in kwargs:
                  try:
                      dep = dependencies.find_external_dependency(name, self.environment, kwargs)
                  except DependencyException as e:
                      exception = e
              else:
                  exception = DependencyException("fallback for %s not found" % name)
  
              # Search inside the projects list
              if not dep.found():
                  if 'fallback' in kwargs:
                      fallback_dep = self.dependency_fallback(name, kwargs)
                      if fallback_dep:
                          # Never add fallback deps to self.coredata.deps since we
                          # cannot cache them. They must always be evaluated else
                          # we won't actually read all the build files.
                          return fallback_dep
                  if required:
                      assert(exception is not None)
                      raise exception
  
          # Only store found-deps in the cache
          if dep.found():
              self.coredata.deps[identifier] = dep
          return DependencyHolder(dep)
  
      @FeatureNew('disabler', '0.44.0')
      @noKwargs
      @noPosargs
      def func_disabler(self, node, args, kwargs):
          return Disabler()
  
      def print_nested_info(self, dependency_name):
          message_templ = '''\nDependency %s not found but it is available in a sub-subproject.
  To use it in the current project, promote it by going in the project source
  root and issuing %s.
  
  '''
          sprojs = mesonlib.detect_subprojects('subprojects', self.source_root)
          if dependency_name not in sprojs:
              return
          found = sprojs[dependency_name]
          if len(found) > 1:
              suffix = 'one of the following commands'
          else:
              suffix = 'the following command'
          message = message_templ % (dependency_name, suffix)
          cmds = []
          command_templ = 'meson wrap promote '
          for l in found:
              cmds.append(command_templ + l[len(self.source_root) + 1:])
          final_message = message + '\n'.join(cmds)
          print(final_message)
  
      def get_subproject_infos(self, kwargs):
          fbinfo = kwargs['fallback']
          check_stringlist(fbinfo)
          if len(fbinfo) != 2:
              raise InterpreterException('Fallback info must have exactly two items.')
          return fbinfo
  
      def dependency_fallback(self, name, kwargs):
          if self.coredata.wrap_mode in (WrapMode.nofallback, WrapMode.nodownload):
              mlog.log('Not looking for a fallback subproject for the dependency',
                       mlog.bold(name), 'because:\nUse of fallback'
                       'dependencies is disabled.')
              return None
          elif self.coredata.wrap_mode == WrapMode.forcefallback:
              mlog.log('Looking for a fallback subproject for the dependency',
                       mlog.bold(name), 'because:\nUse of fallback dependencies is forced.')
          else:
              mlog.log('Looking for a fallback subproject for the dependency',
                       mlog.bold(name))
          dirname, varname = self.get_subproject_infos(kwargs)
          # Try to execute the subproject
          try:
              sp_kwargs = {}
              try:
                  sp_kwargs['default_options'] = kwargs['default_options']
              except KeyError:
                  pass
              self.do_subproject(dirname, sp_kwargs)
          # Invalid code is always an error
          except InvalidCode:
              raise
          # If the subproject execution failed in a non-fatal way, don't raise an
          # exception; let the caller handle things.
          except Exception as e:
              mlog.log('Couldn\'t use fallback subproject in',
                       mlog.bold(os.path.join(self.subproject_dir, dirname)),
                       'for the dependency', mlog.bold(name), '\nReason:', str(e))
              return None
          dep = self.get_subproject_dep(name, dirname, varname, kwargs.get('required', True))
          if not dep:
              return None
          subproj_path = os.path.join(self.subproject_dir, dirname)
          # Check if the version of the declared dependency matches what we want
          if 'version' in kwargs:
              wanted = kwargs['version']
              found = dep.version_method([], {})
              if not self.check_subproject_version(wanted, found):
                  mlog.log('Subproject', mlog.bold(subproj_path), 'dependency',
                           mlog.bold(varname), 'version is', mlog.bold(found),
                           'but', mlog.bold(wanted), 'is required.')
                  return None
          mlog.log('Dependency', mlog.bold(name), 'from subproject',
                   mlog.bold(subproj_path), 'found:', mlog.green('YES'))
          return dep
  
      @FeatureNewKwargs('executable', '0.42.0', ['implib'])
      @permittedKwargs(permitted_kwargs['executable'])
      def func_executable(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, ExecutableHolder)
  
      @permittedKwargs(permitted_kwargs['static_library'])
      def func_static_lib(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, StaticLibraryHolder)
  
      @permittedKwargs(permitted_kwargs['shared_library'])
      def func_shared_lib(self, node, args, kwargs):
          holder = self.build_target(node, args, kwargs, SharedLibraryHolder)
          holder.held_object.shared_library_only = True
          return holder
  
      @permittedKwargs(permitted_kwargs['both_libraries'])
      def func_both_lib(self, node, args, kwargs):
          return self.build_both_libraries(node, args, kwargs)
  
      @FeatureNew('Shared Modules', '0.37.0')
      @permittedKwargs(permitted_kwargs['shared_module'])
      def func_shared_module(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, SharedModuleHolder)
  
      @permittedKwargs(permitted_kwargs['library'])
      def func_library(self, node, args, kwargs):
          return self.build_library(node, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['jar'])
      def func_jar(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, JarHolder)
  
      @FeatureNewKwargs('build_target', '0.40.0', ['link_whole', 'override_options'])
      @permittedKwargs(permitted_kwargs['build_target'])
      def func_build_target(self, node, args, kwargs):
          if 'target_type' not in kwargs:
              raise InterpreterException('Missing target_type keyword argument')
          target_type = kwargs.pop('target_type')
          if target_type == 'executable':
              return self.build_target(node, args, kwargs, ExecutableHolder)
          elif target_type == 'shared_library':
              return self.build_target(node, args, kwargs, SharedLibraryHolder)
          elif target_type == 'static_library':
              return self.build_target(node, args, kwargs, StaticLibraryHolder)
          elif target_type == 'both_libraries':
              return self.build_both_libraries(node, args, kwargs)
          elif target_type == 'library':
              return self.build_library(node, args, kwargs)
          elif target_type == 'jar':
              return self.build_target(node, args, kwargs, JarHolder)
          else:
              raise InterpreterException('Unknown target_type.')
  
      @permittedKwargs(permitted_kwargs['vcs_tag'])
      def func_vcs_tag(self, node, args, kwargs):
          if 'input' not in kwargs or 'output' not in kwargs:
              raise InterpreterException('Keyword arguments input and output must exist')
          if 'fallback' not in kwargs:
              FeatureNew('Optional fallback in vcs_tag', '0.41.0').use()
          fallback = kwargs.pop('fallback', self.project_version)
          if not isinstance(fallback, str):
              raise InterpreterException('Keyword argument fallback must be a string.')
          replace_string = kwargs.pop('replace_string', '@VCS_TAG@')
          regex_selector = '(.*)' # default regex selector for custom command: use complete output
          vcs_cmd = kwargs.get('command', None)
          if vcs_cmd and not isinstance(vcs_cmd, list):
              vcs_cmd = [vcs_cmd]
          source_dir = os.path.normpath(os.path.join(self.environment.get_source_dir(), self.subdir))
          if vcs_cmd:
              # Is the command an executable in path or maybe a script in the source tree?
              vcs_cmd[0] = shutil.which(vcs_cmd[0]) or os.path.join(source_dir, vcs_cmd[0])
          else:
              vcs = mesonlib.detect_vcs(source_dir)
              if vcs:
                  mlog.log('Found %s repository at %s' % (vcs['name'], vcs['wc_dir']))
                  vcs_cmd = vcs['get_rev'].split()
                  regex_selector = vcs['rev_regex']
              else:
                  vcs_cmd = [' '] # executing this cmd will fail in vcstagger.py and force to use the fallback string
          # vcstagger.py parameters: infile, outfile, fallback, source_dir, replace_string, regex_selector, command...
          kwargs['command'] = self.environment.get_build_command() + \
              ['--internal',
               'vcstagger',
               '@INPUT0@',
               '@OUTPUT0@',
               fallback,
               source_dir,
               replace_string,
               regex_selector] + vcs_cmd
          kwargs.setdefault('build_by_default', True)
          kwargs.setdefault('build_always_stale', True)
          return self.func_custom_target(node, [kwargs['output']], kwargs)
  
      @FeatureNew('subdir_done', '0.46.0')
      @stringArgs
      def func_subdir_done(self, node, args, kwargs):
          if len(kwargs) > 0:
              raise InterpreterException('exit does not take named arguments')
          if len(args) > 0:
              raise InterpreterException('exit does not take any arguments')
          raise SubdirDoneRequest()
  
      @stringArgs
      @FeatureNewKwargs('custom_target', '0.47.0', ['install_mode', 'build_always_stale'])
      @FeatureNewKwargs('custom_target', '0.40.0', ['build_by_default'])
      @permittedKwargs(permitted_kwargs['custom_target'])
      def func_custom_target(self, node, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('custom_target: Only one positional argument is allowed, and it must be a string name')
          if 'depfile' in kwargs and ('@BASENAME@' in kwargs['depfile'] or '@PLAINNAME@' in kwargs['depfile']):
              FeatureNew('substitutions in custom_target depfile', '0.47.0').use()
          name = args[0]
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          tg = CustomTargetHolder(build.CustomTarget(name, self.subdir, self.subproject, kwargs), self)
          self.add_target(name, tg.held_object)
          return tg
  
      @permittedKwargs(permitted_kwargs['run_target'])
      def func_run_target(self, node, args, kwargs):
          if len(args) > 1:
              raise InvalidCode('Run_target takes only one positional argument: the target name.')
          elif len(args) == 1:
              if 'command' not in kwargs:
                  raise InterpreterException('Missing "command" keyword argument')
              all_args = extract_as_list(kwargs, 'command')
              deps = extract_as_list(kwargs, 'depends', unholder=True)
          else:
              raise InterpreterException('Run_target needs at least one positional argument.')
  
          cleaned_args = []
          for i in listify(all_args, unholder=True):
              if not isinstance(i, (str, build.BuildTarget, build.CustomTarget, dependencies.ExternalProgram, mesonlib.File)):
                  mlog.debug('Wrong type:', str(i))
                  raise InterpreterException('Invalid argument to run_target.')
              cleaned_args.append(i)
          name = args[0]
          if not isinstance(name, str):
              raise InterpreterException('First argument must be a string.')
          cleaned_deps = []
          for d in deps:
              if not isinstance(d, (build.BuildTarget, build.CustomTarget)):
                  raise InterpreterException('Depends items must be build targets.')
              cleaned_deps.append(d)
          command = cleaned_args[0]
          cmd_args = cleaned_args[1:]
          tg = RunTargetHolder(name, command, cmd_args, cleaned_deps, self.subdir, self.subproject)
          self.add_target(name, tg.held_object)
          return tg
  
      @permittedKwargs(permitted_kwargs['generator'])
      def func_generator(self, node, args, kwargs):
          gen = GeneratorHolder(self, args, kwargs)
          self.generators.append(gen)
          return gen
  
      @permittedKwargs(permitted_kwargs['benchmark'])
      def func_benchmark(self, node, args, kwargs):
          self.add_test(node, args, kwargs, False)
  
      @FeatureNewKwargs('test', '0.46.0', ['depends'])
      @permittedKwargs(permitted_kwargs['test'])
      def func_test(self, node, args, kwargs):
          self.add_test(node, args, kwargs, True)
  
      def unpack_env_kwarg(self, kwargs):
          envlist = kwargs.get('env', EnvironmentVariablesHolder())
          if isinstance(envlist, EnvironmentVariablesHolder):
              env = envlist.held_object
          else:
              envlist = listify(envlist)
              # Convert from array to environment object
              env = EnvironmentVariablesHolder()
              for e in envlist:
                  if '=' not in e:
                      raise InterpreterException('Env var definition must be of type key=val.')
                  (k, val) = e.split('=', 1)
                  k = k.strip()
                  val = val.strip()
                  if ' ' in k:
                      raise InterpreterException('Env var key must not have spaces in it.')
                  env.set_method([k, val], {})
              env = env.held_object
          return env
  
      def add_test(self, node, args, kwargs, is_base_test):
          if len(args) != 2:
              raise InterpreterException('Incorrect number of arguments')
          if not isinstance(args[0], str):
              raise InterpreterException('First argument of test must be a string.')
          exe = args[1]
          if not isinstance(exe, (ExecutableHolder, JarHolder, ExternalProgramHolder)):
              if isinstance(exe, mesonlib.File):
                  exe = self.func_find_program(node, args[1], {})
              else:
                  raise InterpreterException('Second argument must be executable.')
          par = kwargs.get('is_parallel', True)
          if not isinstance(par, bool):
              raise InterpreterException('Keyword argument is_parallel must be a boolean.')
          cmd_args = extract_as_list(kwargs, 'args', unholder=True)
          for i in cmd_args:
              if not isinstance(i, (str, mesonlib.File, build.Target)):
                  raise InterpreterException('Command line arguments must be strings, files or targets.')
          env = self.unpack_env_kwarg(kwargs)
          should_fail = kwargs.get('should_fail', False)
          if not isinstance(should_fail, bool):
              raise InterpreterException('Keyword argument should_fail must be a boolean.')
          timeout = kwargs.get('timeout', 30)
          if 'workdir' in kwargs:
              workdir = kwargs['workdir']
              if not isinstance(workdir, str):
                  raise InterpreterException('Workdir keyword argument must be a string.')
              if not os.path.isabs(workdir):
                  raise InterpreterException('Workdir keyword argument must be an absolute path.')
          else:
              workdir = None
          if not isinstance(timeout, int):
              raise InterpreterException('Timeout must be an integer.')
          suite = []
          prj = self.subproject if self.is_subproject() else self.build.project_name
          for s in mesonlib.stringlistify(kwargs.get('suite', '')):
              if len(s) > 0:
                  s = ':' + s
              suite.append(prj.replace(' ', '_').replace(':', '_') + s)
          depends = extract_as_list(kwargs, 'depends', unholder=True)
          for dep in depends:
              if not isinstance(dep, (build.CustomTarget, build.BuildTarget)):
                  raise InterpreterException('Depends items must be build targets.')
          t = Test(args[0], prj, suite, exe.held_object, depends, par, cmd_args,
                   env, should_fail, timeout, workdir)
          if is_base_test:
              self.build.tests.append(t)
              mlog.debug('Adding test "', mlog.bold(args[0]), '".', sep='')
          else:
              self.build.benchmarks.append(t)
              mlog.debug('Adding benchmark "', mlog.bold(args[0]), '".', sep='')
  
      @FeatureNewKwargs('install_headers', '0.47.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_headers'])
      def func_install_headers(self, node, args, kwargs):
          source_files = self.source_strings_to_files(args)
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          h = Headers(source_files, kwargs)
          self.build.headers.append(h)
          return h
  
      @FeatureNewKwargs('install_man', '0.47.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_man'])
      def func_install_man(self, node, args, kwargs):
          fargs = self.source_strings_to_files(args)
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          m = Man(fargs, kwargs)
          self.build.man.append(m)
          return m
  
      @FeatureNewKwargs('subdir', '0.44.0', ['if_found'])
      @permittedKwargs(permitted_kwargs['subdir'])
      def func_subdir(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          mesonlib.check_direntry_issues(args)
          if '..' in args[0]:
              raise InvalidArguments('Subdir contains ..')
          if self.subdir == '' and args[0] == self.subproject_dir:
              raise InvalidArguments('Must not go into subprojects dir with subdir(), use subproject() instead.')
          if self.subdir == '' and args[0].startswith('meson-'):
              raise InvalidArguments('The "meson-" prefix is reserved and cannot be used for top-level subdir().')
          for i in mesonlib.extract_as_list(kwargs, 'if_found'):
              if not hasattr(i, 'found_method'):
                  raise InterpreterException('Object used in if_found does not have a found method.')
              if not i.found_method([], {}):
                  return
          prev_subdir = self.subdir
          subdir = os.path.join(prev_subdir, args[0])
          if os.path.isabs(subdir):
              raise InvalidArguments('Subdir argument must be a relative path.')
          absdir = os.path.join(self.environment.get_source_dir(), subdir)
          symlinkless_dir = os.path.realpath(absdir)
          if symlinkless_dir in self.visited_subdirs:
              raise InvalidArguments('Tried to enter directory "%s", which has already been visited.'
                                     % subdir)
          self.visited_subdirs[symlinkless_dir] = True
          self.subdir = subdir
          os.makedirs(os.path.join(self.environment.build_dir, subdir), exist_ok=True)
          buildfilename = os.path.join(self.subdir, environment.build_filename)
          self.build_def_files.append(buildfilename)
          absname = os.path.join(self.environment.get_source_dir(), buildfilename)
          if not os.path.isfile(absname):
              self.subdir = prev_subdir
              raise InterpreterException('Non-existent build file {!r}'.format(buildfilename))
          with open(absname, encoding='utf8') as f:
              code = f.read()
          assert(isinstance(code, str))
          try:
              codeblock = mparser.Parser(code, self.subdir).parse()
          except mesonlib.MesonException as me:
              me.file = buildfilename
              raise me
          try:
              self.evaluate_codeblock(codeblock)
          except SubdirDoneRequest:
              pass
          self.subdir = prev_subdir
  
      def _get_kwarg_install_mode(self, kwargs):
          if kwargs.get('install_mode', None) is None:
              return None
          install_mode = []
          mode = mesonlib.typeslistify(kwargs.get('install_mode', []), (str, int))
          for m in mode:
              # We skip any arguments that are set to `false`
              if m is False:
                  m = None
              install_mode.append(m)
          if len(install_mode) > 3:
              raise InvalidArguments('Keyword argument install_mode takes at '
                                     'most 3 arguments.')
          if len(install_mode) > 0 and install_mode[0] is not None and \
             not isinstance(install_mode[0], str):
              raise InvalidArguments('Keyword argument install_mode requires the '
                                     'permissions arg to be a string or false')
          return FileMode(*install_mode)
  
      @FeatureNewKwargs('install_data', '0.46.0', ['rename'])
      @FeatureNewKwargs('install_data', '0.38.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_data'])
      def func_install_data(self, node, args, kwargs):
          kwsource = mesonlib.stringlistify(kwargs.get('sources', []))
          raw_sources = args + kwsource
          sources = []
          source_strings = []
          for s in raw_sources:
              if isinstance(s, mesonlib.File):
                  sources.append(s)
              else:
                  source_strings.append(s)
          sources += self.source_strings_to_files(source_strings)
          install_dir = kwargs.get('install_dir', None)
          if not isinstance(install_dir, (str, type(None))):
              raise InvalidArguments('Keyword argument install_dir not a string.')
          install_mode = self._get_kwarg_install_mode(kwargs)
          rename = kwargs.get('rename', None)
          data = DataHolder(build.Data(sources, install_dir, install_mode, rename))
          self.build.data.append(data.held_object)
          return data
  
      @FeatureNewKwargs('install_subdir', '0.42.0', ['exclude_files', 'exclude_directories'])
      @FeatureNewKwargs('install_subdir', '0.38.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_subdir'])
      @stringArgs
      def func_install_subdir(self, node, args, kwargs):
          if len(args) != 1:
              raise InvalidArguments('Install_subdir requires exactly one argument.')
          subdir = args[0]
          if 'install_dir' not in kwargs:
              raise InvalidArguments('Missing keyword argument install_dir')
          install_dir = kwargs['install_dir']
          if not isinstance(install_dir, str):
              raise InvalidArguments('Keyword argument install_dir not a string.')
          if 'strip_directory' in kwargs:
              if not isinstance(kwargs['strip_directory'], bool):
                  raise InterpreterException('"strip_directory" keyword must be a boolean.')
              strip_directory = kwargs['strip_directory']
          else:
              strip_directory = False
          if 'exclude_files' in kwargs:
              exclude = extract_as_list(kwargs, 'exclude_files')
              for f in exclude:
                  if not isinstance(f, str):
                      raise InvalidArguments('Exclude argument not a string.')
                  elif os.path.isabs(f):
                      raise InvalidArguments('Exclude argument cannot be absolute.')
              exclude_files = set(exclude)
          else:
              exclude_files = set()
          if 'exclude_directories' in kwargs:
              exclude = extract_as_list(kwargs, 'exclude_directories')
              for d in exclude:
                  if not isinstance(d, str):
                      raise InvalidArguments('Exclude argument not a string.')
                  elif os.path.isabs(d):
                      raise InvalidArguments('Exclude argument cannot be absolute.')
              exclude_directories = set(exclude)
          else:
              exclude_directories = set()
          exclude = (exclude_files, exclude_directories)
          install_mode = self._get_kwarg_install_mode(kwargs)
          idir = InstallDir(self.subdir, subdir, install_dir, install_mode, exclude, strip_directory)
          self.build.install_dirs.append(idir)
          return idir
  
      @FeatureNewKwargs('configure_file', '0.47.0', ['copy', 'output_format', 'install_mode', 'encoding'])
      @FeatureNewKwargs('configure_file', '0.46.0', ['format'])
      @FeatureNewKwargs('configure_file', '0.41.0', ['capture'])
      @permittedKwargs(permitted_kwargs['configure_file'])
      def func_configure_file(self, node, args, kwargs):
          if len(args) > 0:
              raise InterpreterException("configure_file takes only keyword arguments.")
          if 'output' not in kwargs:
              raise InterpreterException('Required keyword argument "output" not defined.')
          actions = set(['configuration', 'command', 'copy']).intersection(kwargs.keys())
          if len(actions) == 0:
              raise InterpreterException('Must specify an action with one of these '
                                         'keyword arguments: \'configuration\', '
                                         '\'command\', or \'copy\'.')
          elif len(actions) == 2:
              raise InterpreterException('Must not specify both {!r} and {!r} '
                                         'keyword arguments since they are '
                                         'mutually exclusive.'.format(*actions))
          elif len(actions) == 3:
              raise InterpreterException('Must specify one of {!r}, {!r}, and '
                                         '{!r} keyword arguments since they are '
                                         'mutually exclusive.'.format(*actions))
          if 'capture' in kwargs:
              if not isinstance(kwargs['capture'], bool):
                  raise InterpreterException('"capture" keyword must be a boolean.')
              if 'command' not in kwargs:
                  raise InterpreterException('"capture" keyword requires "command" keyword.')
  
          if 'format' in kwargs:
              fmt = kwargs['format']
              if not isinstance(fmt, str):
                  raise InterpreterException('"format" keyword must be a string.')
          else:
              fmt = 'meson'
  
          if fmt not in ('meson', 'cmake', 'cmake@'):
              raise InterpreterException('"format" possible values are "meson", "cmake" or "cmake@".')
  
          if 'output_format' in kwargs:
              output_format = kwargs['output_format']
              if not isinstance(output_format, str):
                  raise InterpreterException('"output_format" keyword must be a string.')
          else:
              output_format = 'c'
  
          if output_format not in ('c', 'nasm'):
              raise InterpreterException('"format" possible values are "c" or "nasm".')
  
          # Validate input
          inputfile = None
          ifile_abs = None
          if 'input' in kwargs:
              inputfile = kwargs['input']
              if isinstance(inputfile, list):
                  if len(inputfile) != 1:
                      m = "Keyword argument 'input' requires exactly one file"
                      raise InterpreterException(m)
                  inputfile = inputfile[0]
              if not isinstance(inputfile, (str, mesonlib.File)):
                  raise InterpreterException('Input must be a string or a file')
              if isinstance(inputfile, str):
                  inputfile = mesonlib.File.from_source_file(self.environment.source_dir,
                                                             self.subdir, inputfile)
              ifile_abs = inputfile.absolute_path(self.environment.source_dir,
                                                  self.environment.build_dir)
          elif 'command' in kwargs and '@INPUT@' in kwargs['command']:
              raise InterpreterException('@INPUT@ used as command argument, but no input file specified.')
          # Validate output
          output = kwargs['output']
          if not isinstance(output, str):
              raise InterpreterException('Output file name must be a string')
          if ifile_abs:
              values = mesonlib.get_filenames_templates_dict([ifile_abs], None)
              outputs = mesonlib.substitute_values([output], values)
              output = outputs[0]
          if os.path.dirname(output) != '':
              raise InterpreterException('Output file name must not contain a subdirectory.')
          (ofile_path, ofile_fname) = os.path.split(os.path.join(self.subdir, output))
          ofile_abs = os.path.join(self.environment.build_dir, ofile_path, ofile_fname)
          # Optimize copies by not doing substitution if there's nothing to
          # substitute, and warn about this legacy hack
          if 'configuration' in kwargs:
              conf = kwargs['configuration']
              if not isinstance(conf, ConfigurationDataHolder):
                  raise InterpreterException('Argument "configuration" must be of type configuration_data')
              if ifile_abs and not conf.keys():
                  del kwargs['configuration']
                  kwargs['copy'] = True
                  mlog.warning('Got an empty configuration_data() object: '
                               'optimizing copy automatically; if you want to '
                               'copy a file to the build dir, use the \'copy:\' '
                               'keyword argument added in 0.47.0', location=node)
                  conf.mark_used()
          # Perform the appropriate action
          if 'configuration' in kwargs:
              conf = kwargs['configuration']
              if not isinstance(conf, ConfigurationDataHolder):
                  raise InterpreterException('Argument "configuration" is not of type configuration_data')
              mlog.log('Configuring', mlog.bold(output), 'using configuration')
              if inputfile is not None:
                  os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
                  file_encoding = kwargs.setdefault('encoding', 'utf-8')
                  missing_variables = mesonlib.do_conf_file(ifile_abs, ofile_abs,
                                                            conf.held_object, fmt,
                                                            file_encoding)
                  if missing_variables:
                      var_list = ", ".join(map(repr, sorted(missing_variables)))
                      mlog.warning(
                          "The variable(s) %s in the input file %s are not "
                          "present in the given configuration data." % (
                              var_list, inputfile), location=node)
              else:
                  mesonlib.dump_conf_header(ofile_abs, conf.held_object, output_format)
              conf.mark_used()
          elif 'command' in kwargs:
              # We use absolute paths for input and output here because the cwd
              # that the command is run from is 'unspecified', so it could change.
              # Currently it's builddir/subdir for in_builddir else srcdir/subdir.
              if ifile_abs:
                  values = mesonlib.get_filenames_templates_dict([ifile_abs], [ofile_abs])
              else:
                  values = mesonlib.get_filenames_templates_dict(None, [ofile_abs])
              # Substitute @INPUT@, @OUTPUT@, etc here.
              cmd = mesonlib.substitute_values(kwargs['command'], values)
              mlog.log('Configuring', mlog.bold(output), 'with command')
              res = self.run_command_impl(node, cmd,  {}, True)
              if res.returncode != 0:
                  raise InterpreterException('Running configure command failed.\n%s\n%s' %
                                             (res.stdout, res.stderr))
              if 'capture' in kwargs and kwargs['capture']:
                  dst_tmp = ofile_abs + '~'
                  file_encoding = kwargs.setdefault('encoding', 'utf-8')
                  with open(dst_tmp, 'w', encoding=file_encoding) as f:
                      f.writelines(res.stdout)
                  if ifile_abs:
                      shutil.copymode(ifile_abs, dst_tmp)
                  mesonlib.replace_if_different(ofile_abs, dst_tmp)
          elif 'copy' in kwargs:
              os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
              shutil.copyfile(ifile_abs, ofile_abs)
              shutil.copymode(ifile_abs, ofile_abs)
          else:
              # Not reachable
              raise AssertionError
          # If the input is a source file, add it to the list of files that we
          # need to reconfigure on when they change. FIXME: Do the same for
          # files() objects in the command: kwarg.
          if inputfile and not inputfile.is_built:
              # Normalize the path of the conffile (relative to the
              # source root) to avoid duplicates. This is especially
              # important to convert '/' to '\' on Windows
              conffile = os.path.normpath(inputfile.relative_name())
              if conffile not in self.build_def_files:
                  self.build_def_files.append(conffile)
          # Install file if requested, we check for the empty string
          # for backwards compatibility. That was the behaviour before
          # 0.45.0 so preserve it.
          idir = kwargs.get('install_dir', None)
          if isinstance(idir, str) and idir:
              cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
              install_mode = self._get_kwarg_install_mode(kwargs)
              self.build.data.append(build.Data([cfile], idir, install_mode))
          return mesonlib.File.from_built_file(self.subdir, output)
  
      @permittedKwargs(permitted_kwargs['include_directories'])
      @stringArgs
      def func_include_directories(self, node, args, kwargs):
          return self.build_incdir_object(args, kwargs.get('is_system', False))
  
      def build_incdir_object(self, incdir_strings, is_system=False):
          if not isinstance(is_system, bool):
              raise InvalidArguments('Is_system must be boolean.')
          src_root = self.environment.get_source_dir()
          build_root = self.environment.get_build_dir()
          absbase_src = os.path.join(src_root, self.subdir)
          absbase_build = os.path.join(build_root, self.subdir)
  
          for a in incdir_strings:
              if a.startswith(src_root):
                  raise InvalidArguments('''Tried to form an absolute path to a source dir. You should not do that but use
  relative paths instead.
  
  To get include path to any directory relative to the current dir do
  
  incdir = include_directories(dirname)
  
  After this incdir will contain both the current source dir as well as the
  corresponding build dir. It can then be used in any subdirectory and
  Meson will take care of all the busywork to make paths work.
  
  Dirname can even be '.' to mark the current directory. Though you should
  remember that the current source and build directories are always
  put in the include directories by default so you only need to do
  include_directories('.') if you intend to use the result in a
  different subdirectory.
  ''')
              absdir_src = os.path.join(absbase_src, a)
              absdir_build = os.path.join(absbase_build, a)
              if not os.path.isdir(absdir_src) and not os.path.isdir(absdir_build):
                  raise InvalidArguments('Include dir %s does not exist.' % a)
          i = IncludeDirsHolder(build.IncludeDirs(self.subdir, incdir_strings, is_system))
          return i
  
      @permittedKwargs(permitted_kwargs['add_test_setup'])
      @stringArgs
      def func_add_test_setup(self, node, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Add_test_setup needs one argument for the setup name.')
          setup_name = args[0]
          if re.fullmatch('([_a-zA-Z][_0-9a-zA-Z]*:)?[_a-zA-Z][_0-9a-zA-Z]*', setup_name) is None:
              raise InterpreterException('Setup name may only contain alphanumeric characters.')
          if ":" not in setup_name:
              setup_name = (self.subproject if self.subproject else self.build.project_name) + ":" + setup_name
          try:
              inp = extract_as_list(kwargs, 'exe_wrapper', unholder=True)
              exe_wrapper = []
              for i in inp:
                  if isinstance(i, str):
                      exe_wrapper.append(i)
                  elif isinstance(i, dependencies.ExternalProgram):
                      if not i.found():
                          raise InterpreterException('Tried to use non-found executable.')
                      exe_wrapper += i.get_command()
                  else:
                      raise InterpreterException('Exe wrapper can only contain strings or external binaries.')
          except KeyError:
              exe_wrapper = None
          gdb = kwargs.get('gdb', False)
          if not isinstance(gdb, bool):
              raise InterpreterException('Gdb option must be a boolean')
          timeout_multiplier = kwargs.get('timeout_multiplier', 1)
          if not isinstance(timeout_multiplier, int):
              raise InterpreterException('Timeout multiplier must be a number.')
          env = self.unpack_env_kwarg(kwargs)
          self.build.test_setups[setup_name] = build.TestSetup(exe_wrapper=exe_wrapper,
                                                               gdb=gdb,
                                                               timeout_multiplier=timeout_multiplier,
                                                               env=env)
  
      @permittedKwargs(permitted_kwargs['add_global_arguments'])
      @stringArgs
      def func_add_global_arguments(self, node, args, kwargs):
          self.add_global_arguments(node, self.build.global_args, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['add_global_link_arguments'])
      @stringArgs
      def func_add_global_link_arguments(self, node, args, kwargs):
          self.add_global_arguments(node, self.build.global_link_args, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['add_project_arguments'])
      @stringArgs
      def func_add_project_arguments(self, node, args, kwargs):
          self.add_project_arguments(node, self.build.projects_args, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['add_project_link_arguments'])
      @stringArgs
      def func_add_project_link_arguments(self, node, args, kwargs):
          self.add_project_arguments(node, self.build.projects_link_args, args, kwargs)
  
      def add_global_arguments(self, node, argsdict, args, kwargs):
          if self.subproject != '':
              msg = 'Function \'{}\' cannot be used in subprojects because ' \
                    'there is no way to make that reliable.\nPlease only call ' \
                    'this if is_subproject() returns false. Alternatively, ' \
                    'define a variable that\ncontains your language-specific ' \
                    'arguments and add it to the appropriate *_args kwarg ' \
                    'in each target.'.format(node.func_name)
              raise InvalidCode(msg)
          frozen = self.project_args_frozen or self.global_args_frozen
          self.add_arguments(node, argsdict, frozen, args, kwargs)
  
      def add_project_arguments(self, node, argsdict, args, kwargs):
          if self.subproject not in argsdict:
              argsdict[self.subproject] = {}
          self.add_arguments(node, argsdict[self.subproject],
                             self.project_args_frozen, args, kwargs)
  
      def add_arguments(self, node, argsdict, args_frozen, args, kwargs):
          if args_frozen:
              msg = 'Tried to use \'{}\' after a build target has been declared.\n' \
                    'This is not permitted. Please declare all ' \
                    'arguments before your targets.'.format(node.func_name)
              raise InvalidCode(msg)
  
          if 'language' not in kwargs:
              raise InvalidCode('Missing language definition in {}'.format(node.func_name))
  
          for lang in mesonlib.stringlistify(kwargs['language']):
              lang = lang.lower()
              argsdict[lang] = argsdict.get(lang, []) + args
  
      @noKwargs
      @noPosargs
      def func_environment(self, node, args, kwargs):
          return EnvironmentVariablesHolder()
  
      @stringArgs
      @noKwargs
      def func_join_paths(self, node, args, kwargs):
          return os.path.join(*args).replace('\\', '/')
  
      def run(self):
          super().run()
          mlog.log('Build targets in project:', mlog.bold(str(len(self.build.targets))))
          FeatureNew.called_features_report()
          FeatureDeprecated.called_features_report()
  
      def evaluate_subproject_info(self, path_from_source_root, subproject_dirname):
          depth = 0
          subproj_name = ''
          segs = PurePath(path_from_source_root).parts
          segs_spd = PurePath(subproject_dirname).parts
          while segs and segs[0] == segs_spd[0]:
              if len(segs_spd) == 1:
                  subproj_name = segs[1]
                  segs = segs[2:]
                  depth += 1
              else:
                  segs_spd = segs_spd[1:]
                  segs = segs[1:]
          return (depth, subproj_name)
  
      # Check that the indicated file is within the same subproject
      # as we currently are. This is to stop people doing
      # nasty things like:
      #
      # f = files('../../master_src/file.c')
      #
      # Note that this is validated only when the file
      # object is generated. The result can be used in a different
      # subproject than it is defined in (due to e.g. a
      # declare_dependency).
      def validate_within_subproject(self, subdir, fname):
          norm = os.path.normpath(os.path.join(subdir, fname))
          if os.path.isabs(norm):
              if not norm.startswith(self.environment.source_dir):
                  # Grabbing files outside the source tree is ok.
                  # This is for vendor stuff like:
                  #
                  # /opt/vendorsdk/src/file_with_license_restrictions.c
                  return
              norm = os.path.relpath(norm, self.environment.source_dir)
              assert(not os.path.isabs(norm))
          (num_sps, sproj_name) = self.evaluate_subproject_info(norm, self.subproject_dir)
          plain_filename = os.path.basename(norm)
          if num_sps == 0:
              if self.subproject == '':
                  return
              raise InterpreterException('Sandbox violation: Tried to grab file %s from a different subproject.' % plain_filename)
          if num_sps > 1:
              raise InterpreterException('Sandbox violation: Tried to grab file %s from a nested subproject.' % plain_filename)
          if sproj_name != self.subproject_directory_name:
              raise InterpreterException('Sandbox violation: Tried to grab file %s from a different subproject.' % plain_filename)
  
      def source_strings_to_files(self, sources):
          results = []
          mesonlib.check_direntry_issues(sources)
          if not isinstance(sources, list):
              sources = [sources]
          for s in sources:
              if isinstance(s, (mesonlib.File, GeneratedListHolder,
                                CustomTargetHolder, CustomTargetIndexHolder)):
                  pass
              elif isinstance(s, str):
                  self.validate_within_subproject(self.subdir, s)
                  s = mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, s)
              else:
                  raise InterpreterException('Source item is {!r} instead of '
                                             'string or File-type object'.format(s))
              results.append(s)
          return results
  
      def add_target(self, name, tobj):
          if name == '':
              raise InterpreterException('Target name must not be empty.')
          if name.strip() == '':
              raise InterpreterException('Target name must not consist only of whitespace.')
          if name.startswith('meson-'):
              raise InvalidArguments("Target names starting with 'meson-' are reserved "
                                     "for Meson's internal use. Please rename.")
          if name in coredata.forbidden_target_names:
              raise InvalidArguments("Target name '%s' is reserved for Meson's "
                                     "internal use. Please rename." % name)
          # To permit an executable and a shared library to have the
          # same name, such as "foo.exe" and "libfoo.a".
          idname = tobj.get_id()
          if idname in self.build.targets:
              raise InvalidCode('Tried to create target "%s", but a target of that name already exists.' % name)
          self.build.targets[idname] = tobj
          if idname not in self.coredata.target_guids:
              self.coredata.target_guids[idname] = str(uuid.uuid4()).upper()
  
      @FeatureNew('both_libraries', '0.46.0')
      def build_both_libraries(self, node, args, kwargs):
          shared_holder = self.build_target(node, args, kwargs, SharedLibraryHolder)
  
          # Check if user forces non-PIC static library.
          pic = True
          if 'pic' in kwargs:
              pic = kwargs['pic']
          elif 'b_staticpic' in self.environment.coredata.base_options:
              pic = self.environment.coredata.base_options['b_staticpic'].value
  
          if pic:
              # Exclude sources from args and kwargs to avoid building them twice
              static_args = [args[0]]
              static_kwargs = kwargs.copy()
              static_kwargs['sources'] = []
              static_kwargs['objects'] = shared_holder.held_object.extract_all_objects()
          else:
              static_args = args
              static_kwargs = kwargs
  
          static_holder = self.build_target(node, static_args, static_kwargs, StaticLibraryHolder)
  
          return BothLibrariesHolder(shared_holder, static_holder, self)
  
      def build_library(self, node, args, kwargs):
          default_library = self.coredata.get_builtin_option('default_library')
          if default_library == 'shared':
              return self.build_target(node, args, kwargs, SharedLibraryHolder)
          elif default_library == 'static':
              return self.build_target(node, args, kwargs, StaticLibraryHolder)
          elif default_library == 'both':
              return self.build_both_libraries(node, args, kwargs)
          else:
              raise InterpreterException('Unknown default_library value: %s.', default_library)
  
      def build_target(self, node, args, kwargs, targetholder):
          if not args:
              raise InterpreterException('Target does not have a name.')
          name = args[0]
          sources = listify(args[1:])
          if self.environment.is_cross_build():
              if kwargs.get('native', False):
                  is_cross = False
              else:
                  is_cross = True
          else:
              is_cross = False
          if 'sources' in kwargs:
              sources += listify(kwargs['sources'])
          sources = self.source_strings_to_files(sources)
          objs = extract_as_list(kwargs, 'objects')
          kwargs['dependencies'] = extract_as_list(kwargs, 'dependencies')
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          if 'extra_files' in kwargs:
              ef = extract_as_list(kwargs, 'extra_files')
              kwargs['extra_files'] = self.source_strings_to_files(ef)
          self.check_sources_exist(os.path.join(self.source_root, self.subdir), sources)
          if targetholder is ExecutableHolder:
              targetclass = build.Executable
          elif targetholder is SharedLibraryHolder:
              targetclass = build.SharedLibrary
          elif targetholder is SharedModuleHolder:
              targetclass = build.SharedModule
          elif targetholder is StaticLibraryHolder:
              targetclass = build.StaticLibrary
          elif targetholder is JarHolder:
              targetclass = build.Jar
          else:
              mlog.debug('Unknown target type:', str(targetholder))
              raise RuntimeError('Unreachable code')
          self.kwarg_strings_to_includedirs(kwargs)
  
          # Filter out kwargs from other target types. For example 'soversion'
          # passed to library() when default_library == 'static'.
          kwargs = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs}
  
          target = targetclass(name, self.subdir, self.subproject, is_cross, sources, objs, self.environment, kwargs)
  
          if is_cross:
              self.add_cross_stdlib_info(target)
          l = targetholder(target, self)
          self.add_target(name, l.held_object)
          self.project_args_frozen = True
          return l
  
      def kwarg_strings_to_includedirs(self, kwargs):
          if 'd_import_dirs' in kwargs:
              items = mesonlib.extract_as_list(kwargs, 'd_import_dirs')
              cleaned_items = []
              for i in items:
                  if isinstance(i, str):
                      # BW compatibility. This was permitted so we must support it
                      # for a few releases so people can transition to "correct"
                      # path declarations.
                      if i.startswith(self.environment.get_source_dir()):
                          mlog.warning('''Building a path to the source dir is not supported. Use a relative path instead.
  This will become a hard error in the future.''')
                          i = os.path.relpath(i, os.path.join(self.environment.get_source_dir(), self.subdir))
                          i = self.build_incdir_object([i])
                  cleaned_items.append(i)
              kwargs['d_import_dirs'] = cleaned_items
  
      def get_used_languages(self, target):
          result = {}
          for i in target.sources:
              for lang, c in self.build.compilers.items():
                  if c.can_compile(i):
                      result[lang] = True
                      break
          return result
  
      def add_cross_stdlib_info(self, target):
          for l in self.get_used_languages(target):
              if self.environment.cross_info.has_stdlib(l) \
                      and self.subproject != self.environment.cross_info.get_stdlib(l)[0]:
                  target.add_deps(self.build.cross_stdlibs[l])
  
      def check_sources_exist(self, subdir, sources):
          for s in sources:
              if not isinstance(s, str):
                  continue # This means a generated source and they always exist.
              fname = os.path.join(subdir, s)
              if not os.path.isfile(fname):
                  raise InterpreterException('Tried to add non-existing source file %s.' % s)
  
      def format_string(self, templ, args):
          if isinstance(args, mparser.ArgumentNode):
              args = args.arguments
          arg_strings = []
          for arg in args:
              arg = self.evaluate_statement(arg)
              if isinstance(arg, bool): # Python boolean is upper case.
                  arg = str(arg).lower()
              arg_strings.append(str(arg))
  
          def arg_replace(match):
              idx = int(match.group(1))
              if idx >= len(arg_strings):
                  raise InterpreterException('Format placeholder @{}@ out of range.'.format(idx))
              return arg_strings[idx]
  
          return re.sub(r'@(\d+)@', arg_replace, templ)
  
      # Only permit object extraction from the same subproject
      def validate_extraction(self, buildtarget):
          if not self.subdir.startswith(self.subproject_dir):
              if buildtarget.subdir.startswith(self.subproject_dir):
                  raise InterpreterException('Tried to extract objects from a subproject target.')
          else:
              if not buildtarget.subdir.startswith(self.subproject_dir):
                  raise InterpreterException('Tried to extract objects from the main project from a subproject.')
              if self.subdir.split('/')[1] != buildtarget.subdir.split('/')[1]:
                  raise InterpreterException('Tried to extract objects from a different subproject.')
  
      def check_contains(self, obj, args):
          if len(args) != 1:
              raise InterpreterException('Contains method takes exactly one argument.')
          item = args[0]
          for element in obj:
              if isinstance(element, list):
                  found = self.check_contains(element, args)
                  if found:
                      return True
              if element == item:
                  return True
          return False
  
      def is_subproject(self):
          return self.subproject != ''
  
      @noKwargs
      @noArgsFlattening
      def func_set_variable(self, node, args, kwargs):
          if len(args) != 2:
              raise InvalidCode('Set_variable takes two arguments.')
          varname = args[0]
          value = args[1]
          self.set_variable(varname, value)
  
      @noKwargs
      @noArgsFlattening
      def func_get_variable(self, node, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InvalidCode('Get_variable takes one or two arguments.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('First argument must be a string.')
          try:
              return self.variables[varname]
          except KeyError:
              pass
          if len(args) == 2:
              return args[1]
          raise InterpreterException('Tried to get unknown variable "%s".' % varname)
  
      @stringArgs
      @noKwargs
      def func_is_variable(self, node, args, kwargs):
          if len(args) != 1:
              raise InvalidCode('Is_variable takes two arguments.')
          varname = args[0]
          return varname in self.variables
  
files: mesonbuild/interpreter.py
files: # Copyright 2012-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.
  
  from . import mparser
  from . import environment
  from . import coredata
  from . import dependencies
  from . import mlog
  from . import build
  from . import optinterpreter
  from . import compilers
  from .wrap import wrap, WrapMode
  from . import mesonlib
  from .mesonlib import FileMode, Popen_safe, listify, extract_as_list, has_path_sep
  from .dependencies import ExternalProgram
  from .dependencies import InternalDependency, Dependency, NotFoundDependency, DependencyException
  from .interpreterbase import InterpreterBase
  from .interpreterbase import check_stringlist, flatten, noPosargs, noKwargs, stringArgs, permittedKwargs, noArgsFlattening
  from .interpreterbase import InterpreterException, InvalidArguments, InvalidCode, SubdirDoneRequest
  from .interpreterbase import InterpreterObject, MutableInterpreterObject, Disabler
  from .interpreterbase import FeatureNew, FeatureDeprecated, FeatureNewKwargs
  from .modules import ModuleReturnValue
  
  import os, sys, shutil, uuid
  import re, shlex
  import subprocess
  from collections import namedtuple
  from pathlib import PurePath
  
  import importlib
  
  permitted_method_kwargs = {
      'partial_dependency': {'compile_args', 'link_args', 'links', 'includes',
                             'sources'},
  }
  
  def stringifyUserArguments(args):
      if isinstance(args, list):
          return '[%s]' % ', '.join([stringifyUserArguments(x) for x in args])
      elif isinstance(args, dict):
          return '{%s}' % ', '.join(['%s : %s' % (stringifyUserArguments(k), stringifyUserArguments(v)) for k, v in args.items()])
      elif isinstance(args, int):
          return str(args)
      elif isinstance(args, str):
          return "'%s'" % args
      raise InvalidArguments('Function accepts only strings, integers, lists and lists thereof.')
  
  
  class ObjectHolder:
      def __init__(self, obj):
          self.held_object = obj
  
      def __repr__(self):
          return '<Holder: {!r}>'.format(self.held_object)
  
  class FeatureOptionHolder(InterpreterObject, ObjectHolder):
      def __init__(self, env, option):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, option)
          if option.is_auto():
              self.held_object = env.coredata.builtins['auto_features']
          self.name = option.name
          self.methods.update({'enabled': self.enabled_method,
                               'disabled': self.disabled_method,
                               'auto': self.auto_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def enabled_method(self, args, kwargs):
          return self.held_object.is_enabled()
  
      @noPosargs
      @permittedKwargs({})
      def disabled_method(self, args, kwargs):
          return self.held_object.is_disabled()
  
      @noPosargs
      @permittedKwargs({})
      def auto_method(self, args, kwargs):
          return self.held_object.is_auto()
  
  def extract_required_kwarg(kwargs):
      val = kwargs.get('required', True)
      disabled = False
      required = False
      feature = None
      if isinstance(val, FeatureOptionHolder):
          option = val.held_object
          feature = val.name
          if option.is_disabled():
              disabled = True
          elif option.is_enabled():
              required = True
      elif isinstance(required, bool):
          required = val
      else:
          raise InterpreterException('required keyword argument must be boolean or a feature option')
  
      # Keep boolean value in kwargs to simplify other places where this kwarg is
      # checked.
      kwargs['required'] = required
  
      return disabled, required, feature
  
  class TryRunResultHolder(InterpreterObject):
      def __init__(self, res):
          super().__init__()
          self.res = res
          self.methods.update({'returncode': self.returncode_method,
                               'compiled': self.compiled_method,
                               'stdout': self.stdout_method,
                               'stderr': self.stderr_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def returncode_method(self, args, kwargs):
          return self.res.returncode
  
      @noPosargs
      @permittedKwargs({})
      def compiled_method(self, args, kwargs):
          return self.res.compiled
  
      @noPosargs
      @permittedKwargs({})
      def stdout_method(self, args, kwargs):
          return self.res.stdout
  
      @noPosargs
      @permittedKwargs({})
      def stderr_method(self, args, kwargs):
          return self.res.stderr
  
  class RunProcess(InterpreterObject):
  
      def __init__(self, cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir=False, check=False, capture=True):
          super().__init__()
          if not isinstance(cmd, ExternalProgram):
              raise AssertionError('BUG: RunProcess must be passed an ExternalProgram')
          self.capture = capture
          pc, self.stdout, self.stderr = self.run_command(cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check)
          self.returncode = pc.returncode
          self.methods.update({'returncode': self.returncode_method,
                               'stdout': self.stdout_method,
                               'stderr': self.stderr_method,
                               })
  
      def run_command(self, cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check=False):
          command_array = cmd.get_command() + args
          env = {'MESON_SOURCE_ROOT': source_dir,
                 'MESON_BUILD_ROOT': build_dir,
                 'MESON_SUBDIR': subdir,
                 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in mesonintrospect]),
                 }
          if in_builddir:
              cwd = os.path.join(build_dir, subdir)
          else:
              cwd = os.path.join(source_dir, subdir)
          child_env = os.environ.copy()
          child_env.update(env)
          stdout = subprocess.PIPE if self.capture else subprocess.DEVNULL
          mlog.debug('Running command:', ' '.join(command_array))
          try:
              p, o, e = Popen_safe(command_array, stdout=stdout, env=child_env, cwd=cwd)
              if self.capture:
                  mlog.debug('--- stdout ---')
                  mlog.debug(o)
              else:
                  o = ''
                  mlog.debug('--- stdout disabled ---')
              mlog.debug('--- stderr ---')
              mlog.debug(e)
              mlog.debug('')
  
              if check and p.returncode != 0:
                  raise InterpreterException('Command "{}" failed with status {}.'.format(' '.join(command_array), p.returncode))
  
              return p, o, e
          except FileNotFoundError:
              raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array))
  
      @noPosargs
      @permittedKwargs({})
      def returncode_method(self, args, kwargs):
          return self.returncode
  
      @noPosargs
      @permittedKwargs({})
      def stdout_method(self, args, kwargs):
          return self.stdout
  
      @noPosargs
      @permittedKwargs({})
      def stderr_method(self, args, kwargs):
          return self.stderr
  
  class ConfigureFileHolder(InterpreterObject, ObjectHolder):
  
      def __init__(self, subdir, sourcename, targetname, configuration_data):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, build.ConfigureFile(subdir, sourcename,
                                                          targetname, configuration_data))
  
  
  class EnvironmentVariablesHolder(MutableInterpreterObject, ObjectHolder):
      def __init__(self):
          MutableInterpreterObject.__init__(self)
          ObjectHolder.__init__(self, build.EnvironmentVariables())
          self.methods.update({'set': self.set_method,
                               'append': self.append_method,
                               'prepend': self.prepend_method,
                               })
  
      def __repr__(self):
          repr_str = "<{0}: {1}>"
          return repr_str.format(self.__class__.__name__, self.held_object.envvars)
  
      def add_var(self, method, args, kwargs):
          if not isinstance(kwargs.get("separator", ""), str):
              raise InterpreterException("EnvironmentVariablesHolder methods 'separator'"
                                         " argument needs to be a string.")
          if len(args) < 2:
              raise InterpreterException("EnvironmentVariablesHolder methods require at least"
                                         "2 arguments, first is the name of the variable and"
                                         " following one are values")
          self.held_object.envvars.append((method, args[0], args[1:], kwargs))
  
      @stringArgs
      @permittedKwargs({'separator'})
      def set_method(self, args, kwargs):
          self.add_var(self.held_object.set, args, kwargs)
  
      @stringArgs
      @permittedKwargs({'separator'})
      def append_method(self, args, kwargs):
          self.add_var(self.held_object.append, args, kwargs)
  
      @stringArgs
      @permittedKwargs({'separator'})
      def prepend_method(self, args, kwargs):
          self.add_var(self.held_object.prepend, args, kwargs)
  
  
  class ConfigurationDataHolder(MutableInterpreterObject, ObjectHolder):
      def __init__(self):
          MutableInterpreterObject.__init__(self)
          self.used = False # These objects become immutable after use in configure_file.
          ObjectHolder.__init__(self, build.ConfigurationData())
          self.methods.update({'set': self.set_method,
                               'set10': self.set10_method,
                               'set_quoted': self.set_quoted_method,
                               'has': self.has_method,
                               'get': self.get_method,
                               'get_unquoted': self.get_unquoted_method,
                               'merge_from': self.merge_from_method,
                               })
  
      def is_used(self):
          return self.used
  
      def mark_used(self):
          self.used = True
  
      def validate_args(self, args, kwargs):
          if len(args) == 1 and isinstance(args[0], list) and len(args[0]) == 2:
              mlog.log(mlog.red('DEPRECATION:'),
                       '''Passing a list as the single argument to configuration_data.set is deprecated.
  This will become a hard error in the future''')
              args = args[0]
  
          if len(args) != 2:
              raise InterpreterException("Configuration set requires 2 arguments.")
          if self.used:
              raise InterpreterException("Can not set values on configuration object that has been used.")
          name = args[0]
          val = args[1]
          desc = kwargs.get('description', None)
          if not isinstance(name, str):
              raise InterpreterException("First argument to set must be a string.")
          if desc is not None and not isinstance(desc, str):
              raise InterpreterException('Description must be a string.')
  
          return name, val, desc
  
      @noArgsFlattening
      def set_method(self, args, kwargs):
          (name, val, desc) = self.validate_args(args, kwargs)
          self.held_object.values[name] = (val, desc)
  
      def set_quoted_method(self, args, kwargs):
          (name, val, desc) = self.validate_args(args, kwargs)
          if not isinstance(val, str):
              raise InterpreterException("Second argument to set_quoted must be a string.")
          escaped_val = '\\"'.join(val.split('"'))
          self.held_object.values[name] = ('"' + escaped_val + '"', desc)
  
      def set10_method(self, args, kwargs):
          (name, val, desc) = self.validate_args(args, kwargs)
          if val:
              self.held_object.values[name] = (1, desc)
          else:
              self.held_object.values[name] = (0, desc)
  
      def has_method(self, args, kwargs):
          return args[0] in self.held_object.values
  
      @FeatureNew('configuration_data.get()', '0.38.0')
      @noArgsFlattening
      def get_method(self, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InterpreterException('Get method takes one or two arguments.')
          name = args[0]
          if name in self.held_object:
              return self.held_object.get(name)[0]
          if len(args) > 1:
              return args[1]
          raise InterpreterException('Entry %s not in configuration data.' % name)
  
      @FeatureNew('get_unquoted', '0.44.0')
      def get_unquoted_method(self, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InterpreterException('Get method takes one or two arguments.')
          name = args[0]
          if name in self.held_object:
              val = self.held_object.get(name)[0]
          elif len(args) > 1:
              val = args[1]
          else:
              raise InterpreterException('Entry %s not in configuration data.' % name)
          if val[0] == '"' and val[-1] == '"':
              return val[1:-1]
          return val
  
      def get(self, name):
          return self.held_object.values[name] # (val, desc)
  
      def keys(self):
          return self.held_object.values.keys()
  
      def merge_from_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Merge_from takes one positional argument.')
          from_object = args[0]
          if not isinstance(from_object, ConfigurationDataHolder):
              raise InterpreterException('Merge_from argument must be a configuration data object.')
          from_object = from_object.held_object
          for k, v in from_object.values.items():
              self.held_object.values[k] = v
  
  # Interpreter objects can not be pickled so we must have
  # these wrappers.
  
  class DependencyHolder(InterpreterObject, ObjectHolder):
      def __init__(self, dep):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, dep)
          self.methods.update({'found': self.found_method,
                               'type_name': self.type_name_method,
                               'version': self.version_method,
                               'get_pkgconfig_variable': self.pkgconfig_method,
                               'get_configtool_variable': self.configtool_method,
                               'partial_dependency': self.partial_dependency_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def type_name_method(self, args, kwargs):
          return self.held_object.type_name
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          if self.held_object.type_name == 'internal':
              return True
          return self.held_object.found()
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
      @permittedKwargs({'define_variable'})
      def pkgconfig_method(self, args, kwargs):
          args = listify(args)
          if len(args) != 1:
              raise InterpreterException('get_pkgconfig_variable takes exactly one argument.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('Variable name must be a string.')
          return self.held_object.get_pkgconfig_variable(varname, kwargs)
  
      @FeatureNew('get_configtool_variable', '0.44.0')
      @permittedKwargs({})
      def configtool_method(self, args, kwargs):
          args = listify(args)
          if len(args) != 1:
              raise InterpreterException('get_configtool_variable takes exactly one argument.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('Variable name must be a string.')
          return self.held_object.get_configtool_variable(varname)
  
      @FeatureNew('dep.partial_dependency', '0.46.0')
      @noPosargs
      @permittedKwargs(permitted_method_kwargs['partial_dependency'])
      def partial_dependency_method(self, args, kwargs):
          return DependencyHolder(self.held_object.get_partial_dependency(**kwargs))
  
  class InternalDependencyHolder(InterpreterObject, ObjectHolder):
      def __init__(self, dep):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, dep)
          self.methods.update({'found': self.found_method,
                               'version': self.version_method,
                               'partial_dependency': self.partial_dependency_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          return True
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
      @FeatureNew('dep.partial_dependency', '0.46.0')
      @noPosargs
      @permittedKwargs(permitted_method_kwargs['partial_dependency'])
      def partial_dependency_method(self, args, kwargs):
          return DependencyHolder(self.held_object.get_partial_dependency(**kwargs))
  
  class ExternalProgramHolder(InterpreterObject, ObjectHolder):
      def __init__(self, ep):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, ep)
          self.methods.update({'found': self.found_method,
                               'path': self.path_method})
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          return self.found()
  
      @noPosargs
      @permittedKwargs({})
      def path_method(self, args, kwargs):
          return self.held_object.get_path()
  
      def found(self):
          return self.held_object.found()
  
      def get_command(self):
          return self.held_object.get_command()
  
      def get_name(self):
          return self.held_object.get_name()
  
  class ExternalLibraryHolder(InterpreterObject, ObjectHolder):
      def __init__(self, el):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, el)
          self.methods.update({'found': self.found_method,
                               'partial_dependency': self.partial_dependency_method,
                               })
  
      def found(self):
          return self.held_object.found()
  
      @noPosargs
      @permittedKwargs({})
      def found_method(self, args, kwargs):
          return self.found()
  
      def get_name(self):
          return self.held_object.name
  
      def get_compile_args(self):
          return self.held_object.get_compile_args()
  
      def get_link_args(self):
          return self.held_object.get_link_args()
  
      def get_exe_args(self):
          return self.held_object.get_exe_args()
  
      @FeatureNew('dep.partial_dependency', '0.46.0')
      @noPosargs
      @permittedKwargs(permitted_method_kwargs['partial_dependency'])
      def partial_dependency_method(self, args, kwargs):
          return DependencyHolder(self.held_object.get_partial_dependency(**kwargs))
  
  class GeneratorHolder(InterpreterObject, ObjectHolder):
      def __init__(self, interpreter, args, kwargs):
          InterpreterObject.__init__(self)
          self.interpreter = interpreter
          ObjectHolder.__init__(self, build.Generator(args, kwargs))
          self.methods.update({'process': self.process_method})
  
      @FeatureNewKwargs('generator.process', '0.45.0', ['preserve_path_from'])
      @permittedKwargs({'extra_args', 'preserve_path_from'})
      def process_method(self, args, kwargs):
          extras = mesonlib.stringlistify(kwargs.get('extra_args', []))
          if 'preserve_path_from' in kwargs:
              preserve_path_from = kwargs['preserve_path_from']
              if not isinstance(preserve_path_from, str):
                  raise InvalidArguments('Preserve_path_from must be a string.')
              preserve_path_from = os.path.normpath(preserve_path_from)
              if not os.path.isabs(preserve_path_from):
                  # This is a bit of a hack. Fix properly before merging.
                  raise InvalidArguments('Preserve_path_from must be an absolute path for now. Sorry.')
          else:
              preserve_path_from = None
          gl = self.held_object.process_files('Generator', args, self.interpreter,
                                              preserve_path_from, extra_args=extras)
          return GeneratedListHolder(gl)
  
  
  class GeneratedListHolder(InterpreterObject, ObjectHolder):
      def __init__(self, arg1, extra_args=[]):
          InterpreterObject.__init__(self)
          if isinstance(arg1, GeneratorHolder):
              ObjectHolder.__init__(self, build.GeneratedList(arg1.held_object, extra_args))
          else:
              ObjectHolder.__init__(self, arg1)
  
      def __repr__(self):
          r = '<{}: {!r}>'
          return r.format(self.__class__.__name__, self.held_object.get_outputs())
  
      def add_file(self, a):
          self.held_object.add_file(a)
  
  class BuildMachine(InterpreterObject, ObjectHolder):
      def __init__(self, compilers):
          self.compilers = compilers
          InterpreterObject.__init__(self)
          held_object = environment.MachineInfo(environment.detect_system(),
                                                environment.detect_cpu_family(self.compilers),
                                                environment.detect_cpu(self.compilers),
                                                sys.byteorder)
          ObjectHolder.__init__(self, held_object)
          self.methods.update({'system': self.system_method,
                               'cpu_family': self.cpu_family_method,
                               'cpu': self.cpu_method,
                               'endian': self.endian_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      @noPosargs
      @permittedKwargs({})
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      @noPosargs
      @permittedKwargs({})
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      @noPosargs
      @permittedKwargs({})
      def endian_method(self, args, kwargs):
          return self.held_object.endian
  
  # This class will provide both host_machine and
  # target_machine
  class CrossMachineInfo(InterpreterObject, ObjectHolder):
      def __init__(self, cross_info):
          InterpreterObject.__init__(self)
          minimum_cross_info = {'cpu', 'cpu_family', 'endian', 'system'}
          if set(cross_info) < minimum_cross_info:
              raise InterpreterException(
                  'Machine info is currently {}\n'.format(cross_info) +
                  'but is missing {}.'.format(minimum_cross_info - set(cross_info)))
          self.info = cross_info
          minfo = environment.MachineInfo(cross_info['system'],
                                          cross_info['cpu_family'],
                                          cross_info['cpu'],
                                          cross_info['endian'])
          ObjectHolder.__init__(self, minfo)
          self.methods.update({'system': self.system_method,
                               'cpu': self.cpu_method,
                               'cpu_family': self.cpu_family_method,
                               'endian': self.endian_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      @noPosargs
      @permittedKwargs({})
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      @noPosargs
      @permittedKwargs({})
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      @noPosargs
      @permittedKwargs({})
      def endian_method(self, args, kwargs):
          return self.held_object.endian
  
  class IncludeDirsHolder(InterpreterObject, ObjectHolder):
      def __init__(self, idobj):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, idobj)
  
  class Headers(InterpreterObject):
  
      def __init__(self, sources, kwargs):
          InterpreterObject.__init__(self)
          self.sources = sources
          self.install_subdir = kwargs.get('subdir', '')
          self.custom_install_dir = kwargs.get('install_dir', None)
          self.custom_install_mode = kwargs.get('install_mode', None)
          if self.custom_install_dir is not None:
              if not isinstance(self.custom_install_dir, str):
                  raise InterpreterException('Custom_install_dir must be a string.')
  
      def set_install_subdir(self, subdir):
          self.install_subdir = subdir
  
      def get_install_subdir(self):
          return self.install_subdir
  
      def get_sources(self):
          return self.sources
  
      def get_custom_install_dir(self):
          return self.custom_install_dir
  
      def get_custom_install_mode(self):
          return self.custom_install_mode
  
  class DataHolder(InterpreterObject, ObjectHolder):
      def __init__(self, data):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, data)
  
      def get_source_subdir(self):
          return self.held_object.source_subdir
  
      def get_sources(self):
          return self.held_object.sources
  
      def get_install_dir(self):
          return self.held_object.install_dir
  
  class InstallDir(InterpreterObject):
      def __init__(self, src_subdir, inst_subdir, install_dir, install_mode, exclude, strip_directory):
          InterpreterObject.__init__(self)
          self.source_subdir = src_subdir
          self.installable_subdir = inst_subdir
          self.install_dir = install_dir
          self.install_mode = install_mode
          self.exclude = exclude
          self.strip_directory = strip_directory
  
  class Man(InterpreterObject):
  
      def __init__(self, sources, kwargs):
          InterpreterObject.__init__(self)
          self.sources = sources
          self.validate_sources()
          self.custom_install_dir = kwargs.get('install_dir', None)
          self.custom_install_mode = kwargs.get('install_mode', None)
          if self.custom_install_dir is not None and not isinstance(self.custom_install_dir, str):
              raise InterpreterException('Custom_install_dir must be a string.')
  
      def validate_sources(self):
          for s in self.sources:
              try:
                  num = int(s.split('.')[-1])
              except (IndexError, ValueError):
                  num = 0
              if num < 1 or num > 8:
                  raise InvalidArguments('Man file must have a file extension of a number between 1 and 8')
  
      def get_custom_install_dir(self):
          return self.custom_install_dir
  
      def get_custom_install_mode(self):
          return self.custom_install_mode
  
      def get_sources(self):
          return self.sources
  
  class GeneratedObjectsHolder(InterpreterObject, ObjectHolder):
      def __init__(self, held_object):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, held_object)
  
  class TargetHolder(InterpreterObject, ObjectHolder):
      def __init__(self, target, interp):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, target)
          self.interpreter = interp
  
  class BuildTargetHolder(TargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
          self.methods.update({'extract_objects': self.extract_objects_method,
                               'extract_all_objects': self.extract_all_objects_method,
                               'get_id': self.get_id_method,
                               'outdir': self.outdir_method,
                               'full_path': self.full_path_method,
                               'private_dir_include': self.private_dir_include_method,
                               })
  
      def __repr__(self):
          r = '<{} {}: {}>'
          h = self.held_object
          return r.format(self.__class__.__name__, h.get_id(), h.filename)
  
      def is_cross(self):
          return self.held_object.is_cross()
  
      @noPosargs
      @permittedKwargs({})
      def private_dir_include_method(self, args, kwargs):
          return IncludeDirsHolder(build.IncludeDirs('', [], False,
                                                     [self.interpreter.backend.get_target_private_dir(self.held_object)]))
  
      @noPosargs
      @permittedKwargs({})
      def full_path_method(self, args, kwargs):
          return self.interpreter.backend.get_target_filename_abs(self.held_object)
  
      @noPosargs
      @permittedKwargs({})
      def outdir_method(self, args, kwargs):
          return self.interpreter.backend.get_target_dir(self.held_object)
  
      @permittedKwargs({})
      def extract_objects_method(self, args, kwargs):
          gobjs = self.held_object.extract_objects(args)
          return GeneratedObjectsHolder(gobjs)
  
      @FeatureNewKwargs('extract_all_objects', '0.46.0', ['recursive'])
      @noPosargs
      @permittedKwargs({'recursive'})
      def extract_all_objects_method(self, args, kwargs):
          recursive = kwargs.get('recursive', False)
          gobjs = self.held_object.extract_all_objects(recursive)
          if gobjs.objlist and 'recursive' not in kwargs:
              mlog.warning('extract_all_objects called without setting recursive '
                           'keyword argument. Meson currently defaults to '
                           'non-recursive to maintain backward compatibility but '
                           'the default will be changed in the future.')
          return GeneratedObjectsHolder(gobjs)
  
      @noPosargs
      @permittedKwargs({})
      def get_id_method(self, args, kwargs):
          return self.held_object.get_id()
  
  class ExecutableHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class StaticLibraryHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class SharedLibraryHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
          # Set to True only when called from self.func_shared_lib().
          target.shared_library_only = False
  
  class BothLibrariesHolder(BuildTargetHolder):
      def __init__(self, shared_holder, static_holder, interp):
          # FIXME: This build target always represents the shared library, but
          # that should be configurable.
          super().__init__(shared_holder.held_object, interp)
          self.shared_holder = shared_holder
          self.static_holder = static_holder
          self.methods.update({'get_shared_lib': self.get_shared_lib_method,
                               'get_static_lib': self.get_static_lib_method,
                               })
  
      def __repr__(self):
          r = '<{} {}: {}, {}: {}>'
          h1 = self.shared_holder.held_object
          h2 = self.static_holder.held_object
          return r.format(self.__class__.__name__, h1.get_id(), h1.filename, h2.get_id(), h2.filename)
  
      @noPosargs
      @permittedKwargs({})
      def get_shared_lib_method(self, args, kwargs):
          return self.shared_holder
  
      @noPosargs
      @permittedKwargs({})
      def get_static_lib_method(self, args, kwargs):
          return self.static_holder
  
  class SharedModuleHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class JarHolder(BuildTargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
  
  class CustomTargetIndexHolder(InterpreterObject, ObjectHolder):
      def __init__(self, object_to_hold):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, object_to_hold)
  
  class CustomTargetHolder(TargetHolder):
      def __init__(self, target, interp):
          super().__init__(target, interp)
          self.methods.update({'full_path': self.full_path_method,
                               })
  
      def __repr__(self):
          r = '<{} {}: {}>'
          h = self.held_object
          return r.format(self.__class__.__name__, h.get_id(), h.command)
  
      @noPosargs
      @permittedKwargs({})
      def full_path_method(self, args, kwargs):
          return self.interpreter.backend.get_target_filename_abs(self.held_object)
  
      def __getitem__(self, index):
          return CustomTargetIndexHolder(self.held_object[index])
  
      def __setitem__(self, index, value):
          raise InterpreterException('Cannot set a member of a CustomTarget')
  
      def __delitem__(self, index):
          raise InterpreterException('Cannot delete a member of a CustomTarget')
  
      def outdir_include(self):
          return IncludeDirsHolder(build.IncludeDirs('', [], False,
                                                     [os.path.join('@BUILD_ROOT@', self.interpreter.backend.get_target_dir(self.held_object))]))
  
  class RunTargetHolder(InterpreterObject, ObjectHolder):
      def __init__(self, name, command, args, dependencies, subdir, subproject):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, build.RunTarget(name, command, args, dependencies, subdir, subproject))
  
      def __repr__(self):
          r = '<{} {}: {}>'
          h = self.held_object
          return r.format(self.__class__.__name__, h.get_id(), h.command)
  
  class Test(InterpreterObject):
      def __init__(self, name, project, suite, exe, depends, is_parallel,
                   cmd_args, env, should_fail, timeout, workdir):
          InterpreterObject.__init__(self)
          self.name = name
          self.suite = suite
          self.project_name = project
          self.exe = exe
          self.depends = depends
          self.is_parallel = is_parallel
          self.cmd_args = cmd_args
          self.env = env
          self.should_fail = should_fail
          self.timeout = timeout
          self.workdir = workdir
  
      def get_exe(self):
          return self.exe
  
      def get_name(self):
          return self.name
  
  class SubprojectHolder(InterpreterObject, ObjectHolder):
  
      def __init__(self, subinterpreter):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, subinterpreter)
          self.methods.update({'get_variable': self.get_variable_method,
                               })
  
      @permittedKwargs({})
      def get_variable_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Get_variable takes one argument.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('Get_variable takes a string argument.')
          if varname not in self.held_object.variables:
              raise InvalidArguments('Requested variable "{0}" not found.'.format(varname))
          return self.held_object.variables[varname]
  
  class CompilerHolder(InterpreterObject):
      def __init__(self, compiler, env):
          InterpreterObject.__init__(self)
          self.compiler = compiler
          self.environment = env
          self.methods.update({'compiles': self.compiles_method,
                               'links': self.links_method,
                               'get_id': self.get_id_method,
                               'compute_int': self.compute_int_method,
                               'sizeof': self.sizeof_method,
                               'get_define': self.get_define_method,
                               'check_header': self.check_header_method,
                               'has_header': self.has_header_method,
                               'has_header_symbol': self.has_header_symbol_method,
                               'run': self.run_method,
                               'has_function': self.has_function_method,
                               'has_member': self.has_member_method,
                               'has_members': self.has_members_method,
                               'has_type': self.has_type_method,
                               'alignment': self.alignment_method,
                               'version': self.version_method,
                               'cmd_array': self.cmd_array_method,
                               'find_library': self.find_library_method,
                               'has_argument': self.has_argument_method,
                               'has_multi_arguments': self.has_multi_arguments_method,
                               'get_supported_arguments': self.get_supported_arguments_method,
                               'first_supported_argument': self.first_supported_argument_method,
                               'has_link_argument': self.has_link_argument_method,
                               'has_multi_link_arguments': self.has_multi_link_arguments_method,
                               'get_supported_link_arguments': self.get_supported_link_arguments_method,
                               'first_supported_link_argument': self.first_supported_link_argument_method,
                               'unittest_args': self.unittest_args_method,
                               'symbols_have_underscore_prefix': self.symbols_have_underscore_prefix_method,
                               })
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return self.compiler.version
  
      @noPosargs
      @permittedKwargs({})
      def cmd_array_method(self, args, kwargs):
          return self.compiler.exelist
  
      def determine_args(self, kwargs):
          nobuiltins = kwargs.get('no_builtin_args', False)
          if not isinstance(nobuiltins, bool):
              raise InterpreterException('Type of no_builtin_args not a boolean.')
          args = []
          incdirs = extract_as_list(kwargs, 'include_directories')
          for i in incdirs:
              if not isinstance(i, IncludeDirsHolder):
                  raise InterpreterException('Include directories argument must be an include_directories object.')
              for idir in i.held_object.get_incdirs():
                  idir = os.path.join(self.environment.get_source_dir(),
                                      i.held_object.get_curdir(), idir)
                  args += self.compiler.get_include_args(idir, False)
          if not nobuiltins:
              opts = self.environment.coredata.compiler_options
              args += self.compiler.get_option_compile_args(opts)
              args += self.compiler.get_option_link_args(opts)
          args += mesonlib.stringlistify(kwargs.get('args', []))
          return args
  
      def determine_dependencies(self, kwargs):
          deps = kwargs.get('dependencies', None)
          if deps is not None:
              deps = listify(deps)
              final_deps = []
              for d in deps:
                  try:
                      d = d.held_object
                  except Exception:
                      pass
                  if isinstance(d, InternalDependency) or not isinstance(d, Dependency):
                      raise InterpreterException('Dependencies must be external dependencies')
                  final_deps.append(d)
              deps = final_deps
          return deps
  
      @permittedKwargs({
          'prefix',
          'args',
          'dependencies',
      })
      def alignment_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Alignment method takes exactly one positional argument.')
          check_stringlist(args)
          typename = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of sizeof must be a string.')
          extra_args = mesonlib.stringlistify(kwargs.get('args', []))
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.alignment(typename, prefix, self.environment, extra_args, deps)
          mlog.log('Checking for alignment of "', mlog.bold(typename), '": ', result, sep='')
          return result
  
      @permittedKwargs({
          'name',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def run_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Run method takes exactly one positional argument.')
          code = args[0]
          if isinstance(code, mesonlib.File):
              code = mesonlib.File.from_absolute_file(
                  code.rel_to_builddir(self.environment.source_dir))
          elif not isinstance(code, str):
              raise InvalidArguments('Argument must be string or file.')
          testname = kwargs.get('name', '')
          if not isinstance(testname, str):
              raise InterpreterException('Testname argument must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.run(code, self.environment, extra_args, deps)
          if len(testname) > 0:
              if not result.compiled:
                  h = mlog.red('DID NOT COMPILE')
              elif result.returncode == 0:
                  h = mlog.green('YES')
              else:
                  h = mlog.red('NO (%d)' % result.returncode)
              mlog.log('Checking if "', mlog.bold(testname), '" runs: ', h, sep='')
          return TryRunResultHolder(result)
  
      @noPosargs
      @permittedKwargs({})
      def get_id_method(self, args, kwargs):
          return self.compiler.get_id()
  
      @noPosargs
      @permittedKwargs({})
      def symbols_have_underscore_prefix_method(self, args, kwargs):
          '''
          Check if the compiler prefixes _ (underscore) to global C symbols
          See: https://en.wikipedia.org/wiki/Name_mangling#C
          '''
          return self.compiler.symbols_have_underscore_prefix(self.environment)
  
      @noPosargs
      @permittedKwargs({})
      def unittest_args_method(self, args, kwargs):
          '''
          This function is deprecated and should not be used.
          It can be removed in a future version of Meson.
          '''
          if not hasattr(self.compiler, 'get_feature_args'):
              raise InterpreterException('This {} compiler has no feature arguments.'.format(self.compiler.get_display_language()))
          build_to_src = os.path.relpath(self.environment.get_source_dir(), self.environment.get_build_dir())
          return self.compiler.get_feature_args({'unittest': 'true'}, build_to_src)
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_member_method(self, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('Has_member takes exactly two arguments.')
          check_stringlist(args)
          typename = args[0]
          membername = args[1]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_member must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_members(typename, [membername], prefix,
                                          self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          mlog.log('Checking whether type "', mlog.bold(typename),
                   '" has member "', mlog.bold(membername), '": ', hadtxt, sep='')
          return had
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_members_method(self, args, kwargs):
          if len(args) < 2:
              raise InterpreterException('Has_members needs at least two arguments.')
          check_stringlist(args)
          typename = args[0]
          membernames = args[1:]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_members must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_members(typename, membernames, prefix,
                                          self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          members = mlog.bold(', '.join(['"{}"'.format(m) for m in membernames]))
          mlog.log('Checking whether type "', mlog.bold(typename),
                   '" has members ', members, ': ', hadtxt, sep='')
          return had
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_function_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Has_function takes exactly one argument.')
          check_stringlist(args)
          funcname = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_function must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_function(funcname, prefix, self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          mlog.log('Checking for function "', mlog.bold(funcname), '": ', hadtxt, sep='')
          return had
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_type_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Has_type takes exactly one argument.')
          check_stringlist(args)
          typename = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_type must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          had = self.compiler.has_type(typename, prefix, self.environment, extra_args, deps)
          if had:
              hadtxt = mlog.green('YES')
          else:
              hadtxt = mlog.red('NO')
          mlog.log('Checking for type "', mlog.bold(typename), '": ', hadtxt, sep='')
          return had
  
      @FeatureNew('compiler.compute_int', '0.40.0')
      @permittedKwargs({
          'prefix',
          'low',
          'high',
          'guess',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def compute_int_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Compute_int takes exactly one argument.')
          check_stringlist(args)
          expression = args[0]
          prefix = kwargs.get('prefix', '')
          low = kwargs.get('low', None)
          high = kwargs.get('high', None)
          guess = kwargs.get('guess', None)
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of compute_int must be a string.')
          if low is not None and not isinstance(low, int):
              raise InterpreterException('Low argument of compute_int must be an int.')
          if high is not None and not isinstance(high, int):
              raise InterpreterException('High argument of compute_int must be an int.')
          if guess is not None and not isinstance(guess, int):
              raise InterpreterException('Guess argument of compute_int must be an int.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          res = self.compiler.compute_int(expression, low, high, guess, prefix, self.environment, extra_args, deps)
          mlog.log('Computing int of "%s": %d' % (expression, res))
          return res
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def sizeof_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Sizeof takes exactly one argument.')
          check_stringlist(args)
          element = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of sizeof must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          esize = self.compiler.sizeof(element, prefix, self.environment, extra_args, deps)
          mlog.log('Checking for size of "%s": %d' % (element, esize))
          return esize
  
      @FeatureNew('compiler.get_define', '0.40.0')
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def get_define_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('get_define() takes exactly one argument.')
          check_stringlist(args)
          element = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of get_define() must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          value = self.compiler.get_define(element, prefix, self.environment, extra_args, deps)
          mlog.log('Fetching value of define "%s": %s' % (element, value))
          return value
  
      @permittedKwargs({
          'name',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def compiles_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('compiles method takes exactly one argument.')
          code = args[0]
          if isinstance(code, mesonlib.File):
              code = mesonlib.File.from_absolute_file(
                  code.rel_to_builddir(self.environment.source_dir))
          elif not isinstance(code, str):
              raise InvalidArguments('Argument must be string or file.')
          testname = kwargs.get('name', '')
          if not isinstance(testname, str):
              raise InterpreterException('Testname argument must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.compiles(code, self.environment, extra_args, deps)
          if len(testname) > 0:
              if result:
                  h = mlog.green('YES')
              else:
                  h = mlog.red('NO')
              mlog.log('Checking if "', mlog.bold(testname), '" compiles: ', h, sep='')
          return result
  
      @permittedKwargs({
          'name',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def links_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('links method takes exactly one argument.')
          code = args[0]
          if isinstance(code, mesonlib.File):
              code = mesonlib.File.from_absolute_file(
                  code.rel_to_builddir(self.environment.source_dir))
          elif not isinstance(code, str):
              raise InvalidArguments('Argument must be string or file.')
          testname = kwargs.get('name', '')
          if not isinstance(testname, str):
              raise InterpreterException('Testname argument must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          result = self.compiler.links(code, self.environment, extra_args, deps)
          if len(testname) > 0:
              if result:
                  h = mlog.green('YES')
              else:
                  h = mlog.red('NO')
              mlog.log('Checking if "', mlog.bold(testname), '" links: ', h, sep='')
          return result
  
      @FeatureNew('check_header', '0.47.0')
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def check_header_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('check_header method takes exactly one argument.')
          check_stringlist(args)
          hname = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_header must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          haz = self.compiler.check_header(hname, prefix, self.environment, extra_args, deps)
          if haz:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Check usable header "%s":' % hname, h)
          return haz
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_header_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('has_header method takes exactly one argument.')
          check_stringlist(args)
          hname = args[0]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_header must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          haz = self.compiler.has_header(hname, prefix, self.environment, extra_args, deps)
          if haz:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Has header "%s":' % hname, h)
          return haz
  
      @permittedKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_header_symbol_method(self, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('has_header_symbol method takes exactly two arguments.')
          check_stringlist(args)
          hname = args[0]
          symbol = args[1]
          prefix = kwargs.get('prefix', '')
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of has_header_symbol must be a string.')
          extra_args = self.determine_args(kwargs)
          deps = self.determine_dependencies(kwargs)
          haz = self.compiler.has_header_symbol(hname, symbol, prefix, self.environment, extra_args, deps)
          if haz:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Header <{0}> has symbol "{1}":'.format(hname, symbol), h)
          return haz
  
      @permittedKwargs({
          'required',
          'dirs',
      })
      def find_library_method(self, args, kwargs):
          # TODO add dependencies support?
          if len(args) != 1:
              raise InterpreterException('find_library method takes one argument.')
          libname = args[0]
          if not isinstance(libname, str):
              raise InterpreterException('Library name not a string.')
  
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              mlog.log('Library', mlog.bold(libname), 'skipped: feature', mlog.bold(feature), 'disabled')
              lib = dependencies.ExternalLibrary(libname, None,
                                                 self.environment,
                                                 self.compiler.language,
                                                 silent=True)
              return ExternalLibraryHolder(lib)
  
          search_dirs = mesonlib.stringlistify(kwargs.get('dirs', []))
          for i in search_dirs:
              if not os.path.isabs(i):
                  raise InvalidCode('Search directory %s is not an absolute path.' % i)
          linkargs = self.compiler.find_library(libname, self.environment, search_dirs)
          if required and not linkargs:
              raise InterpreterException('{} library {!r} not found'.format(self.compiler.get_display_language(), libname))
          lib = dependencies.ExternalLibrary(libname, linkargs, self.environment,
                                             self.compiler.language)
          return ExternalLibraryHolder(lib)
  
      @permittedKwargs({})
      def has_argument_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          if len(args) != 1:
              raise InterpreterException('has_argument takes exactly one argument.')
          return self.has_multi_arguments_method(args, kwargs)
  
      @permittedKwargs({})
      def has_multi_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          result = self.compiler.has_multi_arguments(args, self.environment)
          if result:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log(
              'Compiler for {} supports arguments {}:'.format(
                  self.compiler.get_display_language(), ' '.join(args)),
              h)
          return result
  
      @FeatureNew('compiler.get_supported_arguments', '0.43.0')
      @permittedKwargs({})
      def get_supported_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          supported_args = []
          for arg in args:
              if self.has_argument_method(arg, kwargs):
                  supported_args.append(arg)
          return supported_args
  
      @permittedKwargs({})
      def first_supported_argument_method(self, args, kwargs):
          for i in mesonlib.stringlistify(args):
              if self.has_argument_method(i, kwargs):
                  mlog.log('First supported argument:', mlog.bold(i))
                  return [i]
          mlog.log('First supported argument:', mlog.red('None'))
          return []
  
      @FeatureNew('has_link_argument', '0.46.0')
      @permittedKwargs({})
      def has_link_argument_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          if len(args) != 1:
              raise InterpreterException('has_link_argument takes exactly one argument.')
          return self.has_multi_link_arguments_method(args, kwargs)
  
      @FeatureNew('has_multi_link_argument', '0.46.0')
      @permittedKwargs({})
      def has_multi_link_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          result = self.compiler.has_multi_link_arguments(args, self.environment)
          if result:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log(
              'Compiler for {} supports link arguments {}:'.format(
                  self.compiler.get_display_language(), ' '.join(args)),
              h)
          return result
  
      @FeatureNew('get_supported_link_arguments_method', '0.46.0')
      @permittedKwargs({})
      def get_supported_link_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          supported_args = []
          for arg in args:
              if self.has_link_argument_method(arg, kwargs):
                  supported_args.append(arg)
          return supported_args
  
      @FeatureNew('first_supported_link_argument_method', '0.46.0')
      @permittedKwargs({})
      def first_supported_link_argument_method(self, args, kwargs):
          for i in mesonlib.stringlistify(args):
              if self.has_link_argument_method(i, kwargs):
                  mlog.log('First supported link argument:', mlog.bold(i))
                  return [i]
          mlog.log('First supported link argument:', mlog.red('None'))
          return []
  
  ModuleState = namedtuple('ModuleState', [
      'build_to_src', 'subproject', 'subdir', 'current_lineno', 'environment',
      'project_name', 'project_version', 'backend', 'compilers', 'targets',
      'data', 'headers', 'man', 'global_args', 'project_args', 'build_machine',
      'host_machine', 'target_machine'])
  
  class ModuleHolder(InterpreterObject, ObjectHolder):
      def __init__(self, modname, module, interpreter):
          InterpreterObject.__init__(self)
          ObjectHolder.__init__(self, module)
          self.modname = modname
          self.interpreter = interpreter
  
      def method_call(self, method_name, args, kwargs):
          try:
              fn = getattr(self.held_object, method_name)
          except AttributeError:
              raise InvalidArguments('Module %s does not have method %s.' % (self.modname, method_name))
          if method_name.startswith('_'):
              raise InvalidArguments('Function {!r} in module {!r} is private.'.format(method_name, self.modname))
          if not getattr(fn, 'no-args-flattening', False):
              args = flatten(args)
          # This is not 100% reliable but we can't use hash()
          # because the Build object contains dicts and lists.
          num_targets = len(self.interpreter.build.targets)
          state = ModuleState(
              build_to_src=os.path.relpath(self.interpreter.environment.get_source_dir(),
                                           self.interpreter.environment.get_build_dir()),
              subproject=self.interpreter.subproject,
              subdir=self.interpreter.subdir,
              current_lineno=self.interpreter.current_lineno,
              environment=self.interpreter.environment,
              project_name=self.interpreter.build.project_name,
              project_version=self.interpreter.build.dep_manifest[self.interpreter.active_projectname],
              # The backend object is under-used right now, but we will need it:
              # https://github.com/mesonbuild/meson/issues/1419
              backend=self.interpreter.backend,
              compilers=self.interpreter.build.compilers,
              targets=self.interpreter.build.targets,
              data=self.interpreter.build.data,
              headers=self.interpreter.build.get_headers(),
              man=self.interpreter.build.get_man(),
              global_args=self.interpreter.build.global_args,
              project_args=self.interpreter.build.projects_args.get(self.interpreter.subproject, {}),
              build_machine=self.interpreter.builtin['build_machine'].held_object,
              host_machine=self.interpreter.builtin['host_machine'].held_object,
              target_machine=self.interpreter.builtin['target_machine'].held_object,
          )
          if self.held_object.is_snippet(method_name):
              value = fn(self.interpreter, state, args, kwargs)
              return self.interpreter.holderify(value)
          else:
              value = fn(state, args, kwargs)
              if num_targets != len(self.interpreter.build.targets):
                  raise InterpreterException('Extension module altered internal state illegally.')
              return self.interpreter.module_method_callback(value)
  
  class MesonMain(InterpreterObject):
      def __init__(self, build, interpreter):
          InterpreterObject.__init__(self)
          self.build = build
          self.interpreter = interpreter
          self._found_source_scripts = {}
          self.methods.update({'get_compiler': self.get_compiler_method,
                               'is_cross_build': self.is_cross_build_method,
                               'has_exe_wrapper': self.has_exe_wrapper_method,
                               'is_unity': self.is_unity_method,
                               'is_subproject': self.is_subproject_method,
                               'current_source_dir': self.current_source_dir_method,
                               'current_build_dir': self.current_build_dir_method,
                               'source_root': self.source_root_method,
                               'build_root': self.build_root_method,
                               'add_install_script': self.add_install_script_method,
                               'add_postconf_script': self.add_postconf_script_method,
                               'install_dependency_manifest': self.install_dependency_manifest_method,
                               'override_find_program': self.override_find_program_method,
                               'project_version': self.project_version_method,
                               'project_license': self.project_license_method,
                               'version': self.version_method,
                               'project_name': self.project_name_method,
                               'get_cross_property': self.get_cross_property_method,
                               'backend': self.backend_method,
                               })
  
      def _find_source_script(self, name, args):
          # Prefer scripts in the current source directory
          search_dir = os.path.join(self.interpreter.environment.source_dir,
                                    self.interpreter.subdir)
          key = (name, search_dir)
          if key in self._found_source_scripts:
              found = self._found_source_scripts[key]
          else:
              found = dependencies.ExternalProgram(name, search_dir=search_dir)
              if found.found():
                  self._found_source_scripts[key] = found
              else:
                  m = 'Script or command {!r} not found or not executable'
                  raise InterpreterException(m.format(name))
          return build.RunScript(found.get_command(), args)
  
      @permittedKwargs({})
      def add_install_script_method(self, args, kwargs):
          if len(args) < 1:
              raise InterpreterException('add_install_script takes one or more arguments')
          check_stringlist(args, 'add_install_script args must be strings')
          script = self._find_source_script(args[0], args[1:])
          self.build.install_scripts.append(script)
  
      @permittedKwargs({})
      def add_postconf_script_method(self, args, kwargs):
          if len(args) < 1:
              raise InterpreterException('add_postconf_script takes one or more arguments')
          check_stringlist(args, 'add_postconf_script arguments must be strings')
          script = self._find_source_script(args[0], args[1:])
          self.build.postconf_scripts.append(script)
  
      @noPosargs
      @permittedKwargs({})
      def current_source_dir_method(self, args, kwargs):
          src = self.interpreter.environment.source_dir
          sub = self.interpreter.subdir
          if sub == '':
              return src
          return os.path.join(src, sub)
  
      @noPosargs
      @permittedKwargs({})
      def current_build_dir_method(self, args, kwargs):
          src = self.interpreter.environment.build_dir
          sub = self.interpreter.subdir
          if sub == '':
              return src
          return os.path.join(src, sub)
  
      @noPosargs
      @permittedKwargs({})
      def backend_method(self, args, kwargs):
          return self.interpreter.backend.name
  
      @noPosargs
      @permittedKwargs({})
      def source_root_method(self, args, kwargs):
          return self.interpreter.environment.source_dir
  
      @noPosargs
      @permittedKwargs({})
      def build_root_method(self, args, kwargs):
          return self.interpreter.environment.build_dir
  
      @noPosargs
      @permittedKwargs({})
      def has_exe_wrapper_method(self, args, kwargs):
          if self.is_cross_build_method(None, None) and \
             'binaries' in self.build.environment.cross_info.config and \
             self.build.environment.cross_info.need_exe_wrapper():
              exe_wrap = self.build.environment.cross_info.config['binaries'].get('exe_wrapper', None)
              if exe_wrap is None:
                  return False
          # We return True when exe_wrap is defined, when it's not needed, and
          # when we're compiling natively. The last two are semantically confusing.
          # Need to revisit this.
          return True
  
      @noPosargs
      @permittedKwargs({})
      def is_cross_build_method(self, args, kwargs):
          return self.build.environment.is_cross_build()
  
      @permittedKwargs({'native'})
      def get_compiler_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('get_compiler_method must have one and only one argument.')
          cname = args[0]
          native = kwargs.get('native', None)
          if native is None:
              if self.build.environment.is_cross_build():
                  native = False
              else:
                  native = True
          if not isinstance(native, bool):
              raise InterpreterException('Type of "native" must be a boolean.')
          if native:
              clist = self.build.compilers
          else:
              clist = self.build.cross_compilers
          if cname in clist:
              return CompilerHolder(clist[cname], self.build.environment)
          raise InterpreterException('Tried to access compiler for unspecified language "%s".' % cname)
  
      @noPosargs
      @permittedKwargs({})
      def is_unity_method(self, args, kwargs):
          optval = self.interpreter.environment.coredata.get_builtin_option('unity')
          if optval == 'on' or (optval == 'subprojects' and self.interpreter.subproject != ''):
              return True
          return False
  
      @noPosargs
      @permittedKwargs({})
      def is_subproject_method(self, args, kwargs):
          return self.interpreter.is_subproject()
  
      @permittedKwargs({})
      def install_dependency_manifest_method(self, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Must specify manifest install file name')
          if not isinstance(args[0], str):
              raise InterpreterException('Argument must be a string.')
          self.build.dep_manifest_name = args[0]
  
      @FeatureNew('override_find_program', '0.46.0')
      @permittedKwargs({})
      def override_find_program_method(self, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('Override needs two arguments')
          name = args[0]
          exe = args[1]
          if not isinstance(name, str):
              raise InterpreterException('First argument must be a string')
          if hasattr(exe, 'held_object'):
              exe = exe.held_object
          if isinstance(exe, mesonlib.File):
              abspath = exe.absolute_path(self.interpreter.environment.source_dir,
                                          self.interpreter.environment.build_dir)
              if not os.path.exists(abspath):
                  raise InterpreterException('Tried to override %s with a file that does not exist.' % name)
              exe = dependencies.ExternalProgram(abspath)
          if not isinstance(exe, dependencies.ExternalProgram):
              # FIXME, make this work if the exe is an Executable target.
              raise InterpreterException('Second argument must be an external program.')
          self.interpreter.add_find_program_override(name, exe)
  
      @noPosargs
      @permittedKwargs({})
      def project_version_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['version']
  
      @FeatureNew('meson.project_license()', '0.45.0')
      @noPosargs
      @permittedKwargs({})
      def project_license_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['license']
  
      @noPosargs
      @permittedKwargs({})
      def version_method(self, args, kwargs):
          return coredata.version
  
      @noPosargs
      @permittedKwargs({})
      def project_name_method(self, args, kwargs):
          return self.interpreter.active_projectname
  
      @noArgsFlattening
      @permittedKwargs({})
      def get_cross_property_method(self, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InterpreterException('Must have one or two arguments.')
          propname = args[0]
          if not isinstance(propname, str):
              raise InterpreterException('Property name must be string.')
          try:
              props = self.interpreter.environment.cross_info.get_properties()
              return props[propname]
          except Exception:
              if len(args) == 2:
                  return args[1]
              raise InterpreterException('Unknown cross property: %s.' % propname)
  
  
  known_library_kwargs = (
      build.known_shlib_kwargs |
      build.known_stlib_kwargs
  )
  
  known_build_target_kwargs = (
      known_library_kwargs |
      build.known_exe_kwargs |
      build.known_jar_kwargs |
      {'target_type'}
  )
  
  permitted_kwargs = {'add_global_arguments': {'language'},
                      'add_global_link_arguments': {'language'},
                      'add_project_link_arguments': {'language'},
                      'add_languages': {'required'},
                      'add_project_arguments': {'language'},
                      'add_test_setup': {'exe_wrapper', 'gdb', 'timeout_multiplier', 'env'},
                      'benchmark': {'args', 'env', 'should_fail', 'timeout', 'workdir', 'suite'},
                      'build_target': known_build_target_kwargs,
                      'configure_file': {'input', 'output', 'configuration', 'command', 'copy', 'install_dir', 'install_mode', 'capture', 'install', 'format', 'output_format', 'encoding'},
                      'custom_target': {'input', 'output', 'command', 'install', 'install_dir', 'install_mode', 'build_always', 'capture', 'depends', 'depend_files', 'depfile', 'build_by_default', 'build_always_stale'},
                      'dependency': {'default_options', 'fallback', 'language', 'main', 'method', 'modules', 'optional_modules', 'native', 'required', 'static', 'version', 'private_headers'},
                      'declare_dependency': {'include_directories', 'link_with', 'sources', 'dependencies', 'compile_args', 'link_args', 'link_whole', 'version'},
                      'executable': build.known_exe_kwargs,
                      'find_program': {'required', 'native'},
                      'generator': {'arguments', 'output', 'depfile', 'capture', 'preserve_path_from'},
                      'include_directories': {'is_system'},
                      'install_data': {'install_dir', 'install_mode', 'rename', 'sources'},
                      'install_headers': {'install_dir', 'install_mode', 'subdir'},
                      'install_man': {'install_dir', 'install_mode'},
                      'install_subdir': {'exclude_files', 'exclude_directories', 'install_dir', 'install_mode', 'strip_directory'},
                      'jar': build.known_jar_kwargs,
                      'project': {'version', 'meson_version', 'default_options', 'license', 'subproject_dir'},
                      'run_command': {'check', 'capture'},
                      'run_target': {'command', 'depends'},
                      'shared_library': build.known_shlib_kwargs,
                      'shared_module': build.known_shmod_kwargs,
                      'static_library': build.known_stlib_kwargs,
                      'both_libraries': known_library_kwargs,
                      'library': known_library_kwargs,
                      'subdir': {'if_found'},
                      'subproject': {'version', 'default_options'},
                      'test': {'args', 'depends', 'env', 'is_parallel', 'should_fail', 'timeout', 'workdir', 'suite'},
                      'vcs_tag': {'input', 'output', 'fallback', 'command', 'replace_string'},
                      }
  
  
  class Interpreter(InterpreterBase):
  
      def __init__(self, build, backend=None, subproject='', subdir='', subproject_dir='subprojects',
                   modules = None, default_project_options=None):
          super().__init__(build.environment.get_source_dir(), subdir)
          self.an_unpicklable_object = mesonlib.an_unpicklable_object
          self.build = build
          self.environment = build.environment
          self.coredata = self.environment.get_coredata()
          self.backend = backend
          self.subproject = subproject
          if modules is None:
              self.modules = {}
          else:
              self.modules = modules
          # Subproject directory is usually the name of the subproject, but can
          # be different for dependencies provided by wrap files.
          self.subproject_directory_name = subdir.split(os.path.sep)[-1]
          self.subproject_dir = subproject_dir
          self.option_file = os.path.join(self.source_root, self.subdir, 'meson_options.txt')
          self.load_root_meson_file()
          self.sanity_check_ast()
          self.builtin.update({'meson': MesonMain(build, self)})
          self.generators = []
          self.visited_subdirs = {}
          self.project_args_frozen = False
          self.global_args_frozen = False  # implies self.project_args_frozen
          self.subprojects = {}
          self.subproject_stack = []
          # Passed from the outside, only used in subprojects.
          if default_project_options:
              self.default_project_options = default_project_options.copy()
          else:
              self.default_project_options = {}
          self.build_func_dict()
          # build_def_files needs to be defined before parse_project is called
          self.build_def_files = [os.path.join(self.subdir, environment.build_filename)]
          self.parse_project()
          self.builtin['build_machine'] = BuildMachine(self.coredata.compilers)
          if not self.build.environment.is_cross_build():
              self.builtin['host_machine'] = self.builtin['build_machine']
              self.builtin['target_machine'] = self.builtin['build_machine']
          else:
              cross_info = self.build.environment.cross_info
              if cross_info.has_host():
                  self.builtin['host_machine'] = CrossMachineInfo(cross_info.config['host_machine'])
              else:
                  self.builtin['host_machine'] = self.builtin['build_machine']
              if cross_info.has_target():
                  self.builtin['target_machine'] = CrossMachineInfo(cross_info.config['target_machine'])
              else:
                  self.builtin['target_machine'] = self.builtin['host_machine']
  
      def build_func_dict(self):
          self.funcs.update({'add_global_arguments': self.func_add_global_arguments,
                             'add_project_arguments': self.func_add_project_arguments,
                             'add_global_link_arguments': self.func_add_global_link_arguments,
                             'add_project_link_arguments': self.func_add_project_link_arguments,
                             'add_test_setup': self.func_add_test_setup,
                             'add_languages': self.func_add_languages,
                             'assert': self.func_assert,
                             'benchmark': self.func_benchmark,
                             'build_target': self.func_build_target,
                             'configuration_data': self.func_configuration_data,
                             'configure_file': self.func_configure_file,
                             'custom_target': self.func_custom_target,
                             'declare_dependency': self.func_declare_dependency,
                             'dependency': self.func_dependency,
                             'disabler': self.func_disabler,
                             'environment': self.func_environment,
                             'error': self.func_error,
                             'executable': self.func_executable,
                             'generator': self.func_generator,
                             'gettext': self.func_gettext,
                             'get_option': self.func_get_option,
                             'get_variable': self.func_get_variable,
                             'files': self.func_files,
                             'find_library': self.func_find_library,
                             'find_program': self.func_find_program,
                             'include_directories': self.func_include_directories,
                             'import': self.func_import,
                             'install_data': self.func_install_data,
                             'install_headers': self.func_install_headers,
                             'install_man': self.func_install_man,
                             'install_subdir': self.func_install_subdir,
                             'is_variable': self.func_is_variable,
                             'jar': self.func_jar,
                             'join_paths': self.func_join_paths,
                             'library': self.func_library,
                             'message': self.func_message,
                             'warning': self.func_warning,
                             'option': self.func_option,
                             'project': self.func_project,
                             'run_target': self.func_run_target,
                             'run_command': self.func_run_command,
                             'set_variable': self.func_set_variable,
                             'subdir': self.func_subdir,
                             'subdir_done': self.func_subdir_done,
                             'subproject': self.func_subproject,
                             'shared_library': self.func_shared_lib,
                             'shared_module': self.func_shared_module,
                             'static_library': self.func_static_lib,
                             'both_libraries': self.func_both_lib,
                             'test': self.func_test,
                             'vcs_tag': self.func_vcs_tag
                             })
          if 'MESON_UNIT_TEST' in os.environ:
              self.funcs.update({'exception': self.func_exception})
  
      def holderify(self, item):
          if isinstance(item, list):
              return [self.holderify(x) for x in item]
          if isinstance(item, build.CustomTarget):
              return CustomTargetHolder(item, self)
          elif isinstance(item, (int, str)) or item is None:
              return item
          elif isinstance(item, build.Executable):
              return ExecutableHolder(item, self)
          elif isinstance(item, build.GeneratedList):
              return GeneratedListHolder(item)
          elif isinstance(item, build.RunTarget):
              raise RuntimeError('This is not a pipe.')
          elif isinstance(item, build.RunScript):
              raise RuntimeError('Do not do this.')
          elif isinstance(item, build.Data):
              return DataHolder(item)
          elif isinstance(item, dependencies.InternalDependency):
              return InternalDependencyHolder(item)
          elif isinstance(item, dependencies.ExternalDependency):
              return DependencyHolder(item)
          elif isinstance(item, dependencies.ExternalProgram):
              return ExternalProgramHolder(item)
          elif hasattr(item, 'held_object'):
              return item
          else:
              raise InterpreterException('Module returned a value of unknown type.')
  
      def process_new_values(self, invalues):
          invalues = listify(invalues)
          for v in invalues:
              if isinstance(v, (build.BuildTarget, build.CustomTarget, build.RunTarget)):
                  self.add_target(v.name, v)
              elif isinstance(v, list):
                  self.module_method_callback(v)
              elif isinstance(v, build.GeneratedList):
                  pass
              elif isinstance(v, build.RunScript):
                  self.build.install_scripts.append(v)
              elif isinstance(v, build.Data):
                  self.build.data.append(v)
              elif isinstance(v, dependencies.ExternalProgram):
                  return ExternalProgramHolder(v)
              elif isinstance(v, dependencies.InternalDependency):
                  # FIXME: This is special cased and not ideal:
                  # The first source is our new VapiTarget, the rest are deps
                  self.process_new_values(v.sources[0])
              elif hasattr(v, 'held_object'):
                  pass
              else:
                  raise InterpreterException('Module returned a value of unknown type.')
  
      def module_method_callback(self, return_object):
          if not isinstance(return_object, ModuleReturnValue):
              raise InterpreterException('Bug in module, it returned an invalid object')
          invalues = return_object.new_objects
          self.process_new_values(invalues)
          return self.holderify(return_object.return_value)
  
      def get_build_def_files(self):
          return self.build_def_files
  
      def get_variables(self):
          return self.variables
  
      def check_cross_stdlibs(self):
          if self.build.environment.is_cross_build():
              cross_info = self.build.environment.cross_info
              for l, c in self.build.cross_compilers.items():
                  try:
                      di = mesonlib.stringlistify(cross_info.get_stdlib(l))
                      if len(di) != 2:
                          raise InterpreterException('Stdlib definition for %s should have exactly two elements.'
                                                     % l)
                      projname, depname = di
                      subproj = self.do_subproject(projname, {})
                      self.build.cross_stdlibs[l] = subproj.get_variable_method([depname], {})
                  except KeyError:
                      pass
                  except InvalidArguments:
                      pass
  
      @stringArgs
      @noKwargs
      def func_import(self, node, args, kwargs):
          if len(args) != 1:
              raise InvalidCode('Import takes one argument.')
          modname = args[0]
          if modname.startswith('unstable-'):
              plainname = modname.split('-', 1)[1]
              mlog.warning('Module %s has no backwards or forwards compatibility and might not exist in future releases.' % modname, location=node)
              modname = 'unstable_' + plainname
          if modname not in self.modules:
              try:
                  module = importlib.import_module('mesonbuild.modules.' + modname)
              except ImportError:
                  raise InvalidArguments('Module "%s" does not exist' % (modname, ))
              self.modules[modname] = module.initialize(self)
          return ModuleHolder(modname, self.modules[modname], self)
  
      @stringArgs
      @noKwargs
      def func_files(self, node, args, kwargs):
          return [mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, fname) for fname in args]
  
      @FeatureNewKwargs('declare_dependency', '0.46.0', ['link_whole'])
      @permittedKwargs(permitted_kwargs['declare_dependency'])
      @noPosargs
      def func_declare_dependency(self, node, args, kwargs):
          version = kwargs.get('version', self.project_version)
          if not isinstance(version, str):
              raise InterpreterException('Version must be a string.')
          incs = extract_as_list(kwargs, 'include_directories', unholder=True)
          libs = extract_as_list(kwargs, 'link_with', unholder=True)
          libs_whole = extract_as_list(kwargs, 'link_whole', unholder=True)
          sources = extract_as_list(kwargs, 'sources')
          sources = listify(self.source_strings_to_files(sources), unholder=True)
          deps = extract_as_list(kwargs, 'dependencies', unholder=True)
          compile_args = mesonlib.stringlistify(kwargs.get('compile_args', []))
          link_args = mesonlib.stringlistify(kwargs.get('link_args', []))
          final_deps = []
          for d in deps:
              try:
                  d = d.held_object
              except Exception:
                  pass
              if not isinstance(d, (dependencies.Dependency, dependencies.ExternalLibrary, dependencies.InternalDependency)):
                  raise InterpreterException('Dependencies must be external deps')
              final_deps.append(d)
          for l in libs:
              if isinstance(l, dependencies.Dependency):
                  raise InterpreterException('''Entries in "link_with" may only be self-built targets,
  external dependencies (including libraries) must go to "dependencies".''')
          dep = dependencies.InternalDependency(version, incs, compile_args,
                                                link_args, libs, libs_whole, sources, final_deps)
          return DependencyHolder(dep)
  
      @noKwargs
      def func_assert(self, node, args, kwargs):
          if len(args) != 2:
              raise InterpreterException('Assert takes exactly two arguments')
          value, message = args
          if not isinstance(value, bool):
              raise InterpreterException('Assert value not bool.')
          if not isinstance(message, str):
              raise InterpreterException('Assert message not a string.')
          if not value:
              raise InterpreterException('Assert failed: ' + message)
  
      def validate_arguments(self, args, argcount, arg_types):
          if argcount is not None:
              if argcount != len(args):
                  raise InvalidArguments('Expected %d arguments, got %d.' %
                                         (argcount, len(args)))
          for i in range(min(len(args), len(arg_types))):
              wanted = arg_types[i]
              actual = args[i]
              if wanted is not None:
                  if not isinstance(actual, wanted):
                      raise InvalidArguments('Incorrect argument type.')
  
      @FeatureNewKwargs('run_command', '0.47.0', ['check', 'capture'])
      @permittedKwargs(permitted_kwargs['run_command'])
      def func_run_command(self, node, args, kwargs):
          return self.run_command_impl(node, args, kwargs)
  
      def run_command_impl(self, node, args, kwargs, in_builddir=False):
          if len(args) < 1:
              raise InterpreterException('Not enough arguments')
          cmd = args[0]
          cargs = args[1:]
          capture = kwargs.get('capture', True)
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
  
          check = kwargs.get('check', False)
          if not isinstance(check, bool):
              raise InterpreterException('Check must be boolean.')
  
          m = 'must be a string, or the output of find_program(), files() '\
              'or configure_file(), or a compiler object; not {!r}'
          if isinstance(cmd, ExternalProgramHolder):
              cmd = cmd.held_object
          elif isinstance(cmd, CompilerHolder):
              cmd = cmd.compiler.get_exelist()[0]
              prog = ExternalProgram(cmd, silent=True)
              if not prog.found():
                  raise InterpreterException('Program {!r} not found '
                                             'or not executable'.format(cmd))
              cmd = prog
          else:
              if isinstance(cmd, mesonlib.File):
                  cmd = cmd.absolute_path(srcdir, builddir)
              elif not isinstance(cmd, str):
                  raise InterpreterException('First argument ' + m.format(cmd))
              # Prefer scripts in the current source directory
              search_dir = os.path.join(srcdir, self.subdir)
              prog = ExternalProgram(cmd, silent=True, search_dir=search_dir)
              if not prog.found():
                  raise InterpreterException('Program or command {!r} not found '
                                             'or not executable'.format(cmd))
              cmd = prog
          try:
              cmd_path = os.path.relpath(cmd.get_path(), start=srcdir)
          except ValueError:
              # On Windows a relative path can't be evaluated for
              # paths on two different drives (i.e. c:\foo and f:\bar).
              # The only thing left to is is to use the original absolute
              # path.
              cmd_path = cmd.get_path()
          if not cmd_path.startswith('..') and cmd_path not in self.build_def_files:
              self.build_def_files.append(cmd_path)
          expanded_args = []
          for a in listify(cargs):
              if isinstance(a, str):
                  expanded_args.append(a)
              elif isinstance(a, mesonlib.File):
                  expanded_args.append(a.absolute_path(srcdir, builddir))
              elif isinstance(a, ExternalProgramHolder):
                  expanded_args.append(a.held_object.get_path())
              else:
                  raise InterpreterException('Arguments ' + m.format(a))
          for a in expanded_args:
              if not os.path.isabs(a):
                  a = os.path.join(builddir if in_builddir else srcdir, self.subdir, a)
              if os.path.isfile(a):
                  a = os.path.relpath(a, start=srcdir)
                  if not a.startswith('..'):
                      if a not in self.build_def_files:
                          self.build_def_files.append(a)
          return RunProcess(cmd, expanded_args, srcdir, builddir, self.subdir,
                            self.environment.get_build_command() + ['introspect'],
                            in_builddir=in_builddir, check=check, capture=capture)
  
      @stringArgs
      def func_gettext(self, nodes, args, kwargs):
          raise InterpreterException('Gettext() function has been moved to module i18n. Import it and use i18n.gettext() instead')
  
      def func_option(self, nodes, args, kwargs):
          raise InterpreterException('Tried to call option() in build description file. All options must be in the option file.')
  
      @FeatureNewKwargs('subproject', '0.38.0', ['default_options'])
      @permittedKwargs(permitted_kwargs['subproject'])
      @stringArgs
      def func_subproject(self, nodes, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Subproject takes exactly one argument')
          dirname = args[0]
          return self.do_subproject(dirname, kwargs)
  
      def do_subproject(self, dirname, kwargs):
          default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
          default_options = coredata.create_options_dict(default_options)
          if dirname == '':
              raise InterpreterException('Subproject dir name must not be empty.')
          if dirname[0] == '.':
              raise InterpreterException('Subproject dir name must not start with a period.')
          if '..' in dirname:
              raise InterpreterException('Subproject name must not contain a ".." path segment.')
          if os.path.isabs(dirname):
              raise InterpreterException('Subproject name must not be an absolute path.')
          if has_path_sep(dirname):
              mlog.warning('Subproject name has a path separator. This may cause unexpected behaviour.')
          if dirname in self.subproject_stack:
              fullstack = self.subproject_stack + [dirname]
              incpath = ' => '.join(fullstack)
              raise InvalidCode('Recursive include of subprojects: %s.' % incpath)
          if dirname in self.subprojects:
              return self.subprojects[dirname]
          subproject_dir_abs = os.path.join(self.environment.get_source_dir(), self.subproject_dir)
          r = wrap.Resolver(subproject_dir_abs, self.coredata.wrap_mode)
          try:
              resolved = r.resolve(dirname)
          except RuntimeError as e:
              # if the reason subproject execution failed was because
              # the directory doesn't exist, try to give some helpful
              # advice if it's a nested subproject that needs
              # promotion...
              self.print_nested_info(dirname)
  
              msg = 'Subproject directory {!r} does not exist and cannot be downloaded:\n{}'
              raise InterpreterException(msg.format(os.path.join(self.subproject_dir, dirname), e))
          subdir = os.path.join(self.subproject_dir, resolved)
          os.makedirs(os.path.join(self.build.environment.get_build_dir(), subdir), exist_ok=True)
          self.global_args_frozen = True
          mlog.log()
          with mlog.nested():
              mlog.log('\nExecuting subproject ', mlog.bold(dirname), '.\n', sep='')
              subi = Interpreter(self.build, self.backend, dirname, subdir, self.subproject_dir,
                                 self.modules, default_options)
              subi.subprojects = self.subprojects
  
              subi.subproject_stack = self.subproject_stack + [dirname]
              current_active = self.active_projectname
              subi.run()
              mlog.log('\nSubproject', mlog.bold(dirname), 'finished.')
  
          if 'version' in kwargs:
              pv = subi.project_version
              wanted = kwargs['version']
              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))
          self.active_projectname = current_active
          self.build.subprojects[dirname] = subi.project_version
          self.subprojects.update(subi.subprojects)
          self.subprojects[dirname] = SubprojectHolder(subi)
          self.build_def_files += subi.build_def_files
          return self.subprojects[dirname]
  
      def get_option_internal(self, optname):
          undecorated_optname = optname
          try:
              return self.coredata.base_options[optname]
          except KeyError:
              pass
          try:
              return self.coredata.builtins[optname]
          except KeyError:
              pass
          try:
              return self.coredata.compiler_options[optname]
          except KeyError:
              pass
          if not coredata.is_builtin_option(optname) and self.is_subproject():
              optname = self.subproject + ':' + optname
          try:
              opt = self.coredata.user_options[optname]
              if opt.yielding and ':' in optname:
                  # If option not present in superproject, keep the original.
                  opt = self.coredata.user_options.get(undecorated_optname, opt)
              return opt
          except KeyError:
              pass
          # Some base options are not defined in some environments, return the default value.
          try:
              return compilers.base_options[optname]
          except KeyError:
              pass
          raise InterpreterException('Tried to access unknown option "%s".' % optname)
  
      @stringArgs
      @noKwargs
      def func_get_option(self, nodes, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Argument required for get_option.')
          optname = args[0]
          if ':' in optname:
              raise InterpreterException('Having a colon in option name is forbidden, '
                                         'projects are not allowed to directly access '
                                         'options of other subprojects.')
          opt = self.get_option_internal(optname)
          if isinstance(opt, coredata.UserFeatureOption):
              return FeatureOptionHolder(self.environment, opt)
          elif isinstance(opt, coredata.UserOption):
              return opt.value
          return opt
  
      @noKwargs
      def func_configuration_data(self, node, args, kwargs):
          if args:
              raise InterpreterException('configuration_data takes no arguments')
          return ConfigurationDataHolder()
  
      def set_options(self, default_options):
          # Set default options as if they were passed to the command line.
          # Subprojects can only define default for user options.
          for k, v in default_options.items():
              if self.subproject:
                  if optinterpreter.is_invalid_name(k):
                      continue
                  k = self.subproject + ':' + k
              self.environment.cmd_line_options.setdefault(k, v)
  
          # Create a subset of cmd_line_options, keeping only options for this
          # subproject. Also take builtin options if it's the main project.
          # Language and backend specific options will be set later when adding
          # languages and setting the backend (builtin options must be set first
          # to know which backend we'll use).
          options = {}
          for k, v in self.environment.cmd_line_options.items():
              if self.subproject:
                  if not k.startswith(self.subproject + ':'):
                      continue
              elif k not in coredata.get_builtin_options():
                  if ':' in k:
                      continue
                  if optinterpreter.is_invalid_name(k):
                      continue
              options[k] = v
  
          self.coredata.set_options(options, self.subproject)
  
      def set_backend(self):
          # The backend is already set when parsing subprojects
          if self.backend is not None:
              return
          backend = self.coredata.get_builtin_option('backend')
          if backend == 'ninja':
              from .backend import ninjabackend
              self.backend = ninjabackend.NinjaBackend(self.build)
          elif backend == 'vs':
              from .backend import vs2010backend
              self.backend = vs2010backend.autodetect_vs_version(self.build)
              self.coredata.set_builtin_option('backend', self.backend.name)
              mlog.log('Auto detected Visual Studio backend:', mlog.bold(self.backend.name))
          elif backend == 'vs2010':
              from .backend import vs2010backend
              self.backend = vs2010backend.Vs2010Backend(self.build)
          elif backend == 'vs2015':
              from .backend import vs2015backend
              self.backend = vs2015backend.Vs2015Backend(self.build)
          elif backend == 'vs2017':
              from .backend import vs2017backend
              self.backend = vs2017backend.Vs2017Backend(self.build)
          elif backend == 'xcode':
              from .backend import xcodebackend
              self.backend = xcodebackend.XCodeBackend(self.build)
          else:
              raise InterpreterException('Unknown backend "%s".' % backend)
  
          # Only init backend options on first invocation otherwise it would
          # override values previously set from command line.
          if self.environment.first_invocation:
              self.coredata.init_backend_options(backend)
  
          options = {k: v for k, v in self.environment.cmd_line_options.items() if k.startswith('backend_')}
          self.coredata.set_options(options)
  
      @stringArgs
      @permittedKwargs(permitted_kwargs['project'])
      def func_project(self, node, args, kwargs):
          if len(args) < 1:
              raise InvalidArguments('Not enough arguments to project(). Needs at least the project name.')
          proj_name = args[0]
          proj_langs = args[1:]
          if ':' in proj_name:
              raise InvalidArguments("Project name {!r} must not contain ':'".format(proj_name))
  
          if os.path.exists(self.option_file):
              oi = optinterpreter.OptionInterpreter(self.subproject)
              oi.process(self.option_file)
              self.coredata.merge_user_options(oi.options)
  
          # Do not set default_options on reconfigure otherwise it would override
          # values previously set from command line. That means that changing
          # default_options in a project will trigger a reconfigure but won't
          # have any effect.
          if self.environment.first_invocation:
              default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
              default_options = coredata.create_options_dict(default_options)
              default_options.update(self.default_project_options)
          else:
              default_options = {}
          self.set_options(default_options)
          self.set_backend()
  
          if not self.is_subproject():
              self.build.project_name = proj_name
          self.active_projectname = proj_name
          self.project_version = kwargs.get('version', 'undefined')
          if self.build.project_version is None:
              self.build.project_version = self.project_version
          proj_license = mesonlib.stringlistify(kwargs.get('license', 'unknown'))
          self.build.dep_manifest[proj_name] = {'version': self.project_version,
                                                'license': proj_license}
          if self.subproject in self.build.projects:
              raise InvalidCode('Second call to project().')
          if not self.is_subproject() and 'subproject_dir' in kwargs:
              spdirname = kwargs['subproject_dir']
              if not isinstance(spdirname, str):
                  raise InterpreterException('Subproject_dir must be a string')
              if os.path.isabs(spdirname):
                  raise InterpreterException('Subproject_dir must not be an absolute path.')
              if spdirname.startswith('.'):
                  raise InterpreterException('Subproject_dir must not begin with a period.')
              if '..' in spdirname:
                  raise InterpreterException('Subproject_dir must not contain a ".." segment.')
              self.subproject_dir = spdirname
  
          self.build.subproject_dir = self.subproject_dir
  
          if 'meson_version' in kwargs:
              cv = coredata.version
              pv = kwargs['meson_version']
              mesonlib.target_version = pv
              if not mesonlib.version_compare(cv, pv):
                  raise InterpreterException('Meson version is %s but project requires %s.' % (cv, pv))
          self.build.projects[self.subproject] = proj_name
          mlog.log('Project name: ', mlog.bold(proj_name), sep='')
          mlog.log('Project version: ', mlog.bold(self.project_version), sep='')
          self.add_languages(proj_langs, True)
          langs = self.coredata.compilers.keys()
          if 'vala' in langs:
              if 'c' not in langs:
                  raise InterpreterException('Compiling Vala requires C. Add C to your project languages and rerun Meson.')
          if not self.is_subproject():
              self.check_cross_stdlibs()
  
      @permittedKwargs(permitted_kwargs['add_languages'])
      @stringArgs
      def func_add_languages(self, node, args, kwargs):
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              for lang in sorted(args, key=compilers.sort_clike):
                  mlog.log('Compiler for language', mlog.bold(lang), 'skipped: feature', mlog.bold(feature), 'disabled')
              return False
          return self.add_languages(args, required)
  
      def get_message_string_arg(self, node):
          # reduce arguments again to avoid flattening posargs
          (posargs, _) = self.reduce_arguments(node.args)
          if len(posargs) != 1:
              raise InvalidArguments('Expected 1 argument, got %d' % len(posargs))
  
          arg = posargs[0]
          if isinstance(arg, list):
              argstr = stringifyUserArguments(arg)
          elif isinstance(arg, dict):
              argstr = stringifyUserArguments(arg)
          elif isinstance(arg, str):
              argstr = arg
          elif isinstance(arg, int):
              argstr = str(arg)
          else:
              raise InvalidArguments('Function accepts only strings, integers, lists and lists thereof.')
  
          return argstr
  
      @noKwargs
      def func_message(self, node, args, kwargs):
          argstr = self.get_message_string_arg(node)
          mlog.log(mlog.bold('Message:'), argstr)
  
      @FeatureNew('warning()', '0.44.0')
      @noKwargs
      def func_warning(self, node, args, kwargs):
          argstr = self.get_message_string_arg(node)
          mlog.warning(argstr, location=node)
  
      @noKwargs
      def func_error(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          raise InterpreterException('Problem encountered: ' + args[0])
  
      @noKwargs
      def func_exception(self, node, args, kwargs):
          self.validate_arguments(args, 0, [])
          raise Exception()
  
      def detect_compilers(self, lang, need_cross_compiler):
          cross_comp = None
          if lang == 'c':
              comp = self.environment.detect_c_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_c_compiler(True)
          elif lang == 'cpp':
              comp = self.environment.detect_cpp_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_cpp_compiler(True)
          elif lang == 'objc':
              comp = self.environment.detect_objc_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_objc_compiler(True)
          elif lang == 'objcpp':
              comp = self.environment.detect_objcpp_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_objcpp_compiler(True)
          elif lang == 'java':
              comp = self.environment.detect_java_compiler()
              if need_cross_compiler:
                  cross_comp = comp  # Java is platform independent.
          elif lang == 'cs':
              comp = self.environment.detect_cs_compiler()
              if need_cross_compiler:
                  cross_comp = comp  # C# is platform independent.
          elif lang == 'vala':
              comp = self.environment.detect_vala_compiler()
              if need_cross_compiler:
                  cross_comp = comp  # Vala compiles to platform-independent C
          elif lang == 'd':
              comp = self.environment.detect_d_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_d_compiler(True)
          elif lang == 'rust':
              comp = self.environment.detect_rust_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_rust_compiler(True)
          elif lang == 'fortran':
              comp = self.environment.detect_fortran_compiler(False)
              if need_cross_compiler:
                  cross_comp = self.environment.detect_fortran_compiler(True)
          elif lang == 'swift':
              comp = self.environment.detect_swift_compiler()
              if need_cross_compiler:
                  raise InterpreterException('Cross compilation with Swift is not working yet.')
                  # cross_comp = self.environment.detect_fortran_compiler(True)
          else:
              raise InvalidCode('Tried to use unknown language "%s".' % lang)
          comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
          self.coredata.compilers[lang] = comp
          # Native compiler always exist so always add its options.
          new_options = comp.get_options()
          if cross_comp is not None:
              cross_comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
              self.coredata.cross_compilers[lang] = cross_comp
              new_options.update(cross_comp.get_options())
  
          optprefix = lang + '_'
          for k, o in new_options.items():
              if not k.startswith(optprefix):
                  raise InterpreterException('Internal error, %s has incorrect prefix.' % k)
              if k in self.environment.cmd_line_options:
                  o.set_value(self.environment.cmd_line_options[k])
              self.coredata.compiler_options.setdefault(k, o)
  
          # Unlike compiler and linker flags, preprocessor flags are not in
          # compiler_options because they are not visible to user.
          preproc_flags = comp.get_preproc_flags()
          preproc_flags = shlex.split(preproc_flags)
          self.coredata.external_preprocess_args.setdefault(lang, preproc_flags)
  
          return comp, cross_comp
  
      def add_languages(self, args, required):
          success = True
          need_cross_compiler = self.environment.is_cross_build() and self.environment.cross_info.need_cross_compiler()
          for lang in sorted(args, key=compilers.sort_clike):
              lang = lang.lower()
              if lang in self.coredata.compilers:
                  comp = self.coredata.compilers[lang]
                  cross_comp = self.coredata.cross_compilers.get(lang, None)
              else:
                  try:
                      (comp, cross_comp) = self.detect_compilers(lang, need_cross_compiler)
                  except Exception:
                      if not required:
                          mlog.log('Compiler for language', mlog.bold(lang), 'not found.')
                          success = False
                          continue
                      else:
                          raise
              if comp.full_version is not None:
                  version_string = ' (%s %s "%s")' % (comp.id, comp.version, comp.full_version)
              else:
                  version_string = ' (%s %s)' % (comp.id, comp.version)
              mlog.log('Native %s compiler: ' % comp.get_display_language(), mlog.bold(' '.join(comp.get_exelist())), version_string, sep='')
  
              self.build.add_compiler(comp)
              if need_cross_compiler:
                  mlog.log('Cross %s compiler: ' % cross_comp.get_display_language(), mlog.bold(' '.join(cross_comp.get_exelist())), ' (%s %s)' % (cross_comp.id, cross_comp.version), sep='')
                  self.build.add_cross_compiler(cross_comp)
              if self.environment.is_cross_build() and not need_cross_compiler:
                  self.build.add_cross_compiler(comp)
              self.add_base_options(comp)
          return success
  
      def emit_base_options_warnings(self, enabled_opts):
          if 'b_bitcode' in enabled_opts:
              mlog.warning('Base option \'b_bitcode\' is enabled, which is incompatible with many linker options. Incompatible options such as such as \'b_asneeded\' have been disabled.')
              mlog.warning('Please see https://mesonbuild.com/Builtin-options.html#Notes_about_Apple_Bitcode_support for more details.')
  
      def add_base_options(self, compiler):
          enabled_opts = []
          for optname in compiler.base_options:
              if optname in self.coredata.base_options:
                  continue
              oobj = compilers.base_options[optname]
              if optname in self.environment.cmd_line_options:
                  oobj.set_value(self.environment.cmd_line_options[optname])
                  enabled_opts.append(optname)
              self.coredata. base_options[optname] = oobj
          self.emit_base_options_warnings(enabled_opts)
  
      def program_from_cross_file(self, prognames, silent=False):
          bins = self.environment.cross_info.config['binaries']
          for p in prognames:
              if hasattr(p, 'held_object'):
                  p = p.held_object
              if isinstance(p, mesonlib.File):
                  continue # Always points to a local (i.e. self generated) file.
              if not isinstance(p, str):
                  raise InterpreterException('Executable name must be a string.')
              if p in bins:
                  exename = bins[p]
                  extprog = dependencies.ExternalProgram(exename, silent=silent)
                  progobj = ExternalProgramHolder(extprog)
                  return progobj
  
      def program_from_system(self, args, silent=False):
          # Search for scripts relative to current subdir.
          # Do not cache found programs because find_program('foobar')
          # might give different results when run from different source dirs.
          source_dir = os.path.join(self.environment.get_source_dir(), self.subdir)
          for exename in args:
              if isinstance(exename, mesonlib.File):
                  if exename.is_built:
                      search_dir = os.path.join(self.environment.get_build_dir(),
                                                exename.subdir)
                  else:
                      search_dir = os.path.join(self.environment.get_source_dir(),
                                                exename.subdir)
                  exename = exename.fname
              elif isinstance(exename, str):
                  search_dir = source_dir
              else:
                  raise InvalidArguments('find_program only accepts strings and '
                                         'files, not {!r}'.format(exename))
              extprog = dependencies.ExternalProgram(exename, search_dir=search_dir,
                                                     silent=silent)
              progobj = ExternalProgramHolder(extprog)
              if progobj.found():
                  return progobj
  
      def program_from_overrides(self, command_names, silent=False):
          for name in command_names:
              if not isinstance(name, str):
                  continue
              if name in self.build.find_overrides:
                  exe = self.build.find_overrides[name]
                  if not silent:
                      mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
                               '(overridden: %s)' % ' '.join(exe.command))
                  return ExternalProgramHolder(exe)
          return None
  
      def store_name_lookups(self, command_names):
          for name in command_names:
              if isinstance(name, str):
                  self.build.searched_programs.add(name)
  
      def add_find_program_override(self, name, exe):
          if name in self.build.searched_programs:
              raise InterpreterException('Tried to override finding of executable "%s" which has already been found.'
                                         % name)
          if name in self.build.find_overrides:
              raise InterpreterException('Tried to override executable "%s" which has already been overridden.'
                                         % name)
          self.build.find_overrides[name] = exe
  
      def find_program_impl(self, args, native=False, required=True, silent=True):
          if not isinstance(args, list):
              args = [args]
          progobj = self.program_from_overrides(args, silent=silent)
          if progobj is None and self.build.environment.is_cross_build():
              if not native:
                  progobj = self.program_from_cross_file(args, silent=silent)
          if progobj is None:
              progobj = self.program_from_system(args, silent=silent)
          if required and (progobj is None or not progobj.found()):
              raise InvalidArguments('Program(s) {!r} not found or not executable'.format(args))
          if progobj is None:
              return ExternalProgramHolder(dependencies.NonExistingExternalProgram())
          # Only store successful lookups
          self.store_name_lookups(args)
          return progobj
  
      @permittedKwargs(permitted_kwargs['find_program'])
      def func_find_program(self, node, args, kwargs):
          if not args:
              raise InterpreterException('No program name specified.')
  
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              mlog.log('Program', mlog.bold(' '.join(args)), 'skipped: feature', mlog.bold(feature), 'disabled')
              return ExternalProgramHolder(dependencies.NonExistingExternalProgram())
  
          if not isinstance(required, bool):
              raise InvalidArguments('"required" argument must be a boolean.')
          use_native = kwargs.get('native', False)
          if not isinstance(use_native, bool):
              raise InvalidArguments('Argument to "native" must be a boolean.')
          return self.find_program_impl(args, native=use_native, required=required, silent=False)
  
      def func_find_library(self, node, args, kwargs):
          raise InvalidCode('find_library() is removed, use meson.get_compiler(\'name\').find_library() instead.\n'
                            'Look here for documentation: http://mesonbuild.com/Reference-manual.html#compiler-object\n'
                            'Look here for example: http://mesonbuild.com/howtox.html#add-math-library-lm-portably\n'
                            )
  
      def _find_cached_dep(self, name, kwargs):
          # Check if we want this as a cross-dep or a native-dep
          # FIXME: Not all dependencies support such a distinction right now,
          # and we repeat this check inside dependencies that do. We need to
          # consolidate this somehow.
          is_cross = self.environment.is_cross_build()
          if 'native' in kwargs and is_cross:
              want_cross = not kwargs['native']
          else:
              want_cross = is_cross
          identifier = dependencies.get_dep_identifier(name, kwargs, want_cross)
          cached_dep = None
          # Check if we've already searched for and found this dep
          if identifier in self.coredata.deps:
              cached_dep = self.coredata.deps[identifier]
              mlog.log('Dependency', mlog.bold(name),
                       'found:', mlog.green('YES'), '(cached)')
          else:
              # Check if exactly the same dep with different version requirements
              # was found already.
              wanted = identifier[1]
              for trial, trial_dep in self.coredata.deps.items():
                  # trial[1], identifier[1] are the version requirements
                  if trial[0] != identifier[0] or trial[2:] != identifier[2:]:
                      continue
                  found = trial_dep.get_version()
                  if not wanted or mesonlib.version_compare_many(found, wanted)[0]:
                      # We either don't care about the version, or our
                      # version requirements matched the trial dep's version.
                      cached_dep = trial_dep
                      break
          return identifier, cached_dep
  
      @staticmethod
      def check_subproject_version(wanted, found):
          if wanted == 'undefined':
              return True
          if found == 'undefined' or not mesonlib.version_compare_many(found, wanted)[0]:
              return False
          return True
  
      def get_subproject_dep(self, name, dirname, varname, required):
          try:
              dep = self.subprojects[dirname].get_variable_method([varname], {})
          except InvalidArguments as e:
              if required:
                  raise DependencyException('Could not find dependency {} in subproject {}; {}'
                                            ''.format(varname, dirname, str(e)))
              # If the dependency is not required, don't raise an exception
              subproj_path = os.path.join(self.subproject_dir, dirname)
              mlog.log('Dependency', mlog.bold(name), 'from subproject',
                       mlog.bold(subproj_path), 'found:', mlog.red('NO'))
              return None
          if not isinstance(dep, DependencyHolder):
              raise InvalidCode('Fetched variable {!r} in the subproject {!r} is '
                                'not a dependency object.'.format(varname, dirname))
          return dep
  
      def _find_cached_fallback_dep(self, name, dirname, varname, wanted, required):
          if dirname not in self.subprojects:
              return False
          dep = self.get_subproject_dep(name, dirname, varname, required)
          if not dep:
              return False
          found = dep.version_method([], {})
          if self.check_subproject_version(wanted, found):
              subproj_path = os.path.join(self.subproject_dir, dirname)
              mlog.log('Dependency', mlog.bold(name), 'from subproject',
                       mlog.bold(subproj_path), 'found:', mlog.green('YES'), '(cached)')
              return dep
          if required:
              raise DependencyException('Version {} of subproject dependency {} already '
                                        'cached, requested incompatible version {} for '
                                        'dep {}'.format(found, dirname, wanted, name))
          return None
  
      @FeatureNewKwargs('dependency', '0.40.0', ['method'])
      @FeatureNewKwargs('dependency', '0.38.0', ['default_options'])
      @permittedKwargs(permitted_kwargs['dependency'])
      def func_dependency(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          name = args[0]
  
          disabled, required, feature = extract_required_kwarg(kwargs)
          if disabled:
              mlog.log('Dependency', mlog.bold(name), 'skipped: feature', mlog.bold(feature), 'disabled')
              return DependencyHolder(NotFoundDependency(self.environment))
  
          if name == '':
              if required:
                  raise InvalidArguments('Dependency is both required and not-found')
              return DependencyHolder(NotFoundDependency(self.environment))
  
          if '<' in name or '>' in name or '=' in name:
              raise InvalidArguments('Characters <, > and = are forbidden in dependency names. To specify'
                                     'version\n requirements use the \'version\' keyword argument instead.')
          identifier, cached_dep = self._find_cached_dep(name, kwargs)
  
          if cached_dep:
              if required and not cached_dep.found():
                  m = 'Dependency {!r} was already checked and was not found'
                  raise DependencyException(m.format(name))
              dep = cached_dep
          else:
              # If the dependency has already been configured, possibly by
              # a higher level project, try to use it first.
              if 'fallback' in kwargs:
                  dirname, varname = self.get_subproject_infos(kwargs)
                  wanted = kwargs.get('version', 'undefined')
                  dep = self._find_cached_fallback_dep(name, dirname, varname, wanted, required)
                  if dep:
                      return dep
  
              # We need to actually search for this dep
              exception = None
              dep = NotFoundDependency(self.environment)
  
              # Search for it outside the project
              if self.coredata.wrap_mode != WrapMode.forcefallback or 'fallback' not in kwargs:
                  try:
                      dep = dependencies.find_external_dependency(name, self.environment, kwargs)
                  except DependencyException as e:
                      exception = e
              else:
                  exception = DependencyException("fallback for %s not found" % name)
  
              # Search inside the projects list
              if not dep.found():
                  if 'fallback' in kwargs:
                      fallback_dep = self.dependency_fallback(name, kwargs)
                      if fallback_dep:
                          # Never add fallback deps to self.coredata.deps since we
                          # cannot cache them. They must always be evaluated else
                          # we won't actually read all the build files.
                          return fallback_dep
                  if required:
                      assert(exception is not None)
                      raise exception
  
          # Only store found-deps in the cache
          if dep.found():
              self.coredata.deps[identifier] = dep
          return DependencyHolder(dep)
  
      @FeatureNew('disabler', '0.44.0')
      @noKwargs
      @noPosargs
      def func_disabler(self, node, args, kwargs):
          return Disabler()
  
      def print_nested_info(self, dependency_name):
          message_templ = '''\nDependency %s not found but it is available in a sub-subproject.
  To use it in the current project, promote it by going in the project source
  root and issuing %s.
  
  '''
          sprojs = mesonlib.detect_subprojects('subprojects', self.source_root)
          if dependency_name not in sprojs:
              return
          found = sprojs[dependency_name]
          if len(found) > 1:
              suffix = 'one of the following commands'
          else:
              suffix = 'the following command'
          message = message_templ % (dependency_name, suffix)
          cmds = []
          command_templ = 'meson wrap promote '
          for l in found:
              cmds.append(command_templ + l[len(self.source_root) + 1:])
          final_message = message + '\n'.join(cmds)
          print(final_message)
  
      def get_subproject_infos(self, kwargs):
          fbinfo = kwargs['fallback']
          check_stringlist(fbinfo)
          if len(fbinfo) != 2:
              raise InterpreterException('Fallback info must have exactly two items.')
          return fbinfo
  
      def dependency_fallback(self, name, kwargs):
          if self.coredata.wrap_mode in (WrapMode.nofallback, WrapMode.nodownload):
              mlog.log('Not looking for a fallback subproject for the dependency',
                       mlog.bold(name), 'because:\nUse of fallback'
                       'dependencies is disabled.')
              return None
          elif self.coredata.wrap_mode == WrapMode.forcefallback:
              mlog.log('Looking for a fallback subproject for the dependency',
                       mlog.bold(name), 'because:\nUse of fallback dependencies is forced.')
          else:
              mlog.log('Looking for a fallback subproject for the dependency',
                       mlog.bold(name))
          dirname, varname = self.get_subproject_infos(kwargs)
          # Try to execute the subproject
          try:
              sp_kwargs = {}
              try:
                  sp_kwargs['default_options'] = kwargs['default_options']
              except KeyError:
                  pass
              self.do_subproject(dirname, sp_kwargs)
          # Invalid code is always an error
          except InvalidCode:
              raise
          # If the subproject execution failed in a non-fatal way, don't raise an
          # exception; let the caller handle things.
          except Exception as e:
              mlog.log('Couldn\'t use fallback subproject in',
                       mlog.bold(os.path.join(self.subproject_dir, dirname)),
                       'for the dependency', mlog.bold(name), '\nReason:', str(e))
              return None
          dep = self.get_subproject_dep(name, dirname, varname, kwargs.get('required', True))
          if not dep:
              return None
          subproj_path = os.path.join(self.subproject_dir, dirname)
          # Check if the version of the declared dependency matches what we want
          if 'version' in kwargs:
              wanted = kwargs['version']
              found = dep.version_method([], {})
              if not self.check_subproject_version(wanted, found):
                  mlog.log('Subproject', mlog.bold(subproj_path), 'dependency',
                           mlog.bold(varname), 'version is', mlog.bold(found),
                           'but', mlog.bold(wanted), 'is required.')
                  return None
          mlog.log('Dependency', mlog.bold(name), 'from subproject',
                   mlog.bold(subproj_path), 'found:', mlog.green('YES'))
          return dep
  
      @FeatureNewKwargs('executable', '0.42.0', ['implib'])
      @permittedKwargs(permitted_kwargs['executable'])
      def func_executable(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, ExecutableHolder)
  
      @permittedKwargs(permitted_kwargs['static_library'])
      def func_static_lib(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, StaticLibraryHolder)
  
      @permittedKwargs(permitted_kwargs['shared_library'])
      def func_shared_lib(self, node, args, kwargs):
          holder = self.build_target(node, args, kwargs, SharedLibraryHolder)
          holder.held_object.shared_library_only = True
          return holder
  
      @permittedKwargs(permitted_kwargs['both_libraries'])
      def func_both_lib(self, node, args, kwargs):
          return self.build_both_libraries(node, args, kwargs)
  
      @FeatureNew('Shared Modules', '0.37.0')
      @permittedKwargs(permitted_kwargs['shared_module'])
      def func_shared_module(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, SharedModuleHolder)
  
      @permittedKwargs(permitted_kwargs['library'])
      def func_library(self, node, args, kwargs):
          return self.build_library(node, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['jar'])
      def func_jar(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, JarHolder)
  
      @FeatureNewKwargs('build_target', '0.40.0', ['link_whole', 'override_options'])
      @permittedKwargs(permitted_kwargs['build_target'])
      def func_build_target(self, node, args, kwargs):
          if 'target_type' not in kwargs:
              raise InterpreterException('Missing target_type keyword argument')
          target_type = kwargs.pop('target_type')
          if target_type == 'executable':
              return self.build_target(node, args, kwargs, ExecutableHolder)
          elif target_type == 'shared_library':
              return self.build_target(node, args, kwargs, SharedLibraryHolder)
          elif target_type == 'static_library':
              return self.build_target(node, args, kwargs, StaticLibraryHolder)
          elif target_type == 'both_libraries':
              return self.build_both_libraries(node, args, kwargs)
          elif target_type == 'library':
              return self.build_library(node, args, kwargs)
          elif target_type == 'jar':
              return self.build_target(node, args, kwargs, JarHolder)
          else:
              raise InterpreterException('Unknown target_type.')
  
      @permittedKwargs(permitted_kwargs['vcs_tag'])
      def func_vcs_tag(self, node, args, kwargs):
          if 'input' not in kwargs or 'output' not in kwargs:
              raise InterpreterException('Keyword arguments input and output must exist')
          if 'fallback' not in kwargs:
              FeatureNew('Optional fallback in vcs_tag', '0.41.0').use()
          fallback = kwargs.pop('fallback', self.project_version)
          if not isinstance(fallback, str):
              raise InterpreterException('Keyword argument fallback must be a string.')
          replace_string = kwargs.pop('replace_string', '@VCS_TAG@')
          regex_selector = '(.*)' # default regex selector for custom command: use complete output
          vcs_cmd = kwargs.get('command', None)
          if vcs_cmd and not isinstance(vcs_cmd, list):
              vcs_cmd = [vcs_cmd]
          source_dir = os.path.normpath(os.path.join(self.environment.get_source_dir(), self.subdir))
          if vcs_cmd:
              # Is the command an executable in path or maybe a script in the source tree?
              vcs_cmd[0] = shutil.which(vcs_cmd[0]) or os.path.join(source_dir, vcs_cmd[0])
          else:
              vcs = mesonlib.detect_vcs(source_dir)
              if vcs:
                  mlog.log('Found %s repository at %s' % (vcs['name'], vcs['wc_dir']))
                  vcs_cmd = vcs['get_rev'].split()
                  regex_selector = vcs['rev_regex']
              else:
                  vcs_cmd = [' '] # executing this cmd will fail in vcstagger.py and force to use the fallback string
          # vcstagger.py parameters: infile, outfile, fallback, source_dir, replace_string, regex_selector, command...
          kwargs['command'] = self.environment.get_build_command() + \
              ['--internal',
               'vcstagger',
               '@INPUT0@',
               '@OUTPUT0@',
               fallback,
               source_dir,
               replace_string,
               regex_selector] + vcs_cmd
          kwargs.setdefault('build_by_default', True)
          kwargs.setdefault('build_always_stale', True)
          return self.func_custom_target(node, [kwargs['output']], kwargs)
  
      @FeatureNew('subdir_done', '0.46.0')
      @stringArgs
      def func_subdir_done(self, node, args, kwargs):
          if len(kwargs) > 0:
              raise InterpreterException('exit does not take named arguments')
          if len(args) > 0:
              raise InterpreterException('exit does not take any arguments')
          raise SubdirDoneRequest()
  
      @stringArgs
      @FeatureNewKwargs('custom_target', '0.47.0', ['install_mode', 'build_always_stale'])
      @FeatureNewKwargs('custom_target', '0.40.0', ['build_by_default'])
      @permittedKwargs(permitted_kwargs['custom_target'])
      def func_custom_target(self, node, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('custom_target: Only one positional argument is allowed, and it must be a string name')
          if 'depfile' in kwargs and ('@BASENAME@' in kwargs['depfile'] or '@PLAINNAME@' in kwargs['depfile']):
              FeatureNew('substitutions in custom_target depfile', '0.47.0').use()
          name = args[0]
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          tg = CustomTargetHolder(build.CustomTarget(name, self.subdir, self.subproject, kwargs), self)
          self.add_target(name, tg.held_object)
          return tg
  
      @permittedKwargs(permitted_kwargs['run_target'])
      def func_run_target(self, node, args, kwargs):
          if len(args) > 1:
              raise InvalidCode('Run_target takes only one positional argument: the target name.')
          elif len(args) == 1:
              if 'command' not in kwargs:
                  raise InterpreterException('Missing "command" keyword argument')
              all_args = extract_as_list(kwargs, 'command')
              deps = extract_as_list(kwargs, 'depends', unholder=True)
          else:
              raise InterpreterException('Run_target needs at least one positional argument.')
  
          cleaned_args = []
          for i in listify(all_args, unholder=True):
              if not isinstance(i, (str, build.BuildTarget, build.CustomTarget, dependencies.ExternalProgram, mesonlib.File)):
                  mlog.debug('Wrong type:', str(i))
                  raise InterpreterException('Invalid argument to run_target.')
              cleaned_args.append(i)
          name = args[0]
          if not isinstance(name, str):
              raise InterpreterException('First argument must be a string.')
          cleaned_deps = []
          for d in deps:
              if not isinstance(d, (build.BuildTarget, build.CustomTarget)):
                  raise InterpreterException('Depends items must be build targets.')
              cleaned_deps.append(d)
          command = cleaned_args[0]
          cmd_args = cleaned_args[1:]
          tg = RunTargetHolder(name, command, cmd_args, cleaned_deps, self.subdir, self.subproject)
          self.add_target(name, tg.held_object)
          return tg
  
      @permittedKwargs(permitted_kwargs['generator'])
      def func_generator(self, node, args, kwargs):
          gen = GeneratorHolder(self, args, kwargs)
          self.generators.append(gen)
          return gen
  
      @permittedKwargs(permitted_kwargs['benchmark'])
      def func_benchmark(self, node, args, kwargs):
          self.add_test(node, args, kwargs, False)
  
      @FeatureNewKwargs('test', '0.46.0', ['depends'])
      @permittedKwargs(permitted_kwargs['test'])
      def func_test(self, node, args, kwargs):
          self.add_test(node, args, kwargs, True)
  
      def unpack_env_kwarg(self, kwargs):
          envlist = kwargs.get('env', EnvironmentVariablesHolder())
          if isinstance(envlist, EnvironmentVariablesHolder):
              env = envlist.held_object
          else:
              envlist = listify(envlist)
              # Convert from array to environment object
              env = EnvironmentVariablesHolder()
              for e in envlist:
                  if '=' not in e:
                      raise InterpreterException('Env var definition must be of type key=val.')
                  (k, val) = e.split('=', 1)
                  k = k.strip()
                  val = val.strip()
                  if ' ' in k:
                      raise InterpreterException('Env var key must not have spaces in it.')
                  env.set_method([k, val], {})
              env = env.held_object
          return env
  
      def add_test(self, node, args, kwargs, is_base_test):
          if len(args) != 2:
              raise InterpreterException('Incorrect number of arguments')
          if not isinstance(args[0], str):
              raise InterpreterException('First argument of test must be a string.')
          exe = args[1]
          if not isinstance(exe, (ExecutableHolder, JarHolder, ExternalProgramHolder)):
              if isinstance(exe, mesonlib.File):
                  exe = self.func_find_program(node, args[1], {})
              else:
                  raise InterpreterException('Second argument must be executable.')
          par = kwargs.get('is_parallel', True)
          if not isinstance(par, bool):
              raise InterpreterException('Keyword argument is_parallel must be a boolean.')
          cmd_args = extract_as_list(kwargs, 'args', unholder=True)
          for i in cmd_args:
              if not isinstance(i, (str, mesonlib.File, build.Target)):
                  raise InterpreterException('Command line arguments must be strings, files or targets.')
          env = self.unpack_env_kwarg(kwargs)
          should_fail = kwargs.get('should_fail', False)
          if not isinstance(should_fail, bool):
              raise InterpreterException('Keyword argument should_fail must be a boolean.')
          timeout = kwargs.get('timeout', 30)
          if 'workdir' in kwargs:
              workdir = kwargs['workdir']
              if not isinstance(workdir, str):
                  raise InterpreterException('Workdir keyword argument must be a string.')
              if not os.path.isabs(workdir):
                  raise InterpreterException('Workdir keyword argument must be an absolute path.')
          else:
              workdir = None
          if not isinstance(timeout, int):
              raise InterpreterException('Timeout must be an integer.')
          suite = []
          prj = self.subproject if self.is_subproject() else self.build.project_name
          for s in mesonlib.stringlistify(kwargs.get('suite', '')):
              if len(s) > 0:
                  s = ':' + s
              suite.append(prj.replace(' ', '_').replace(':', '_') + s)
          depends = extract_as_list(kwargs, 'depends', unholder=True)
          for dep in depends:
              if not isinstance(dep, (build.CustomTarget, build.BuildTarget)):
                  raise InterpreterException('Depends items must be build targets.')
          t = Test(args[0], prj, suite, exe.held_object, depends, par, cmd_args,
                   env, should_fail, timeout, workdir)
          if is_base_test:
              self.build.tests.append(t)
              mlog.debug('Adding test "', mlog.bold(args[0]), '".', sep='')
          else:
              self.build.benchmarks.append(t)
              mlog.debug('Adding benchmark "', mlog.bold(args[0]), '".', sep='')
  
      @FeatureNewKwargs('install_headers', '0.47.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_headers'])
      def func_install_headers(self, node, args, kwargs):
          source_files = self.source_strings_to_files(args)
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          h = Headers(source_files, kwargs)
          self.build.headers.append(h)
          return h
  
      @FeatureNewKwargs('install_man', '0.47.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_man'])
      def func_install_man(self, node, args, kwargs):
          fargs = self.source_strings_to_files(args)
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          m = Man(fargs, kwargs)
          self.build.man.append(m)
          return m
  
      @FeatureNewKwargs('subdir', '0.44.0', ['if_found'])
      @permittedKwargs(permitted_kwargs['subdir'])
      def func_subdir(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          mesonlib.check_direntry_issues(args)
          if '..' in args[0]:
              raise InvalidArguments('Subdir contains ..')
          if self.subdir == '' and args[0] == self.subproject_dir:
              raise InvalidArguments('Must not go into subprojects dir with subdir(), use subproject() instead.')
          if self.subdir == '' and args[0].startswith('meson-'):
              raise InvalidArguments('The "meson-" prefix is reserved and cannot be used for top-level subdir().')
          for i in mesonlib.extract_as_list(kwargs, 'if_found'):
              if not hasattr(i, 'found_method'):
                  raise InterpreterException('Object used in if_found does not have a found method.')
              if not i.found_method([], {}):
                  return
          prev_subdir = self.subdir
          subdir = os.path.join(prev_subdir, args[0])
          if os.path.isabs(subdir):
              raise InvalidArguments('Subdir argument must be a relative path.')
          absdir = os.path.join(self.environment.get_source_dir(), subdir)
          symlinkless_dir = os.path.realpath(absdir)
          if symlinkless_dir in self.visited_subdirs:
              raise InvalidArguments('Tried to enter directory "%s", which has already been visited.'
                                     % subdir)
          self.visited_subdirs[symlinkless_dir] = True
          self.subdir = subdir
          os.makedirs(os.path.join(self.environment.build_dir, subdir), exist_ok=True)
          buildfilename = os.path.join(self.subdir, environment.build_filename)
          self.build_def_files.append(buildfilename)
          absname = os.path.join(self.environment.get_source_dir(), buildfilename)
          if not os.path.isfile(absname):
              self.subdir = prev_subdir
              raise InterpreterException('Non-existent build file {!r}'.format(buildfilename))
          with open(absname, encoding='utf8') as f:
              code = f.read()
          assert(isinstance(code, str))
          try:
              codeblock = mparser.Parser(code, self.subdir).parse()
          except mesonlib.MesonException as me:
              me.file = buildfilename
              raise me
          try:
              self.evaluate_codeblock(codeblock)
          except SubdirDoneRequest:
              pass
          self.subdir = prev_subdir
  
      def _get_kwarg_install_mode(self, kwargs):
          if kwargs.get('install_mode', None) is None:
              return None
          install_mode = []
          mode = mesonlib.typeslistify(kwargs.get('install_mode', []), (str, int))
          for m in mode:
              # We skip any arguments that are set to `false`
              if m is False:
                  m = None
              install_mode.append(m)
          if len(install_mode) > 3:
              raise InvalidArguments('Keyword argument install_mode takes at '
                                     'most 3 arguments.')
          if len(install_mode) > 0 and install_mode[0] is not None and \
             not isinstance(install_mode[0], str):
              raise InvalidArguments('Keyword argument install_mode requires the '
                                     'permissions arg to be a string or false')
          return FileMode(*install_mode)
  
      @FeatureNewKwargs('install_data', '0.46.0', ['rename'])
      @FeatureNewKwargs('install_data', '0.38.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_data'])
      def func_install_data(self, node, args, kwargs):
          kwsource = mesonlib.stringlistify(kwargs.get('sources', []))
          raw_sources = args + kwsource
          sources = []
          source_strings = []
          for s in raw_sources:
              if isinstance(s, mesonlib.File):
                  sources.append(s)
              else:
                  source_strings.append(s)
          sources += self.source_strings_to_files(source_strings)
          install_dir = kwargs.get('install_dir', None)
          if not isinstance(install_dir, (str, type(None))):
              raise InvalidArguments('Keyword argument install_dir not a string.')
          install_mode = self._get_kwarg_install_mode(kwargs)
          rename = kwargs.get('rename', None)
          data = DataHolder(build.Data(sources, install_dir, install_mode, rename))
          self.build.data.append(data.held_object)
          return data
  
      @FeatureNewKwargs('install_subdir', '0.42.0', ['exclude_files', 'exclude_directories'])
      @FeatureNewKwargs('install_subdir', '0.38.0', ['install_mode'])
      @permittedKwargs(permitted_kwargs['install_subdir'])
      @stringArgs
      def func_install_subdir(self, node, args, kwargs):
          if len(args) != 1:
              raise InvalidArguments('Install_subdir requires exactly one argument.')
          subdir = args[0]
          if 'install_dir' not in kwargs:
              raise InvalidArguments('Missing keyword argument install_dir')
          install_dir = kwargs['install_dir']
          if not isinstance(install_dir, str):
              raise InvalidArguments('Keyword argument install_dir not a string.')
          if 'strip_directory' in kwargs:
              if not isinstance(kwargs['strip_directory'], bool):
                  raise InterpreterException('"strip_directory" keyword must be a boolean.')
              strip_directory = kwargs['strip_directory']
          else:
              strip_directory = False
          if 'exclude_files' in kwargs:
              exclude = extract_as_list(kwargs, 'exclude_files')
              for f in exclude:
                  if not isinstance(f, str):
                      raise InvalidArguments('Exclude argument not a string.')
                  elif os.path.isabs(f):
                      raise InvalidArguments('Exclude argument cannot be absolute.')
              exclude_files = set(exclude)
          else:
              exclude_files = set()
          if 'exclude_directories' in kwargs:
              exclude = extract_as_list(kwargs, 'exclude_directories')
              for d in exclude:
                  if not isinstance(d, str):
                      raise InvalidArguments('Exclude argument not a string.')
                  elif os.path.isabs(d):
                      raise InvalidArguments('Exclude argument cannot be absolute.')
              exclude_directories = set(exclude)
          else:
              exclude_directories = set()
          exclude = (exclude_files, exclude_directories)
          install_mode = self._get_kwarg_install_mode(kwargs)
          idir = InstallDir(self.subdir, subdir, install_dir, install_mode, exclude, strip_directory)
          self.build.install_dirs.append(idir)
          return idir
  
      @FeatureNewKwargs('configure_file', '0.47.0', ['copy', 'output_format', 'install_mode', 'encoding'])
      @FeatureNewKwargs('configure_file', '0.46.0', ['format'])
      @FeatureNewKwargs('configure_file', '0.41.0', ['capture'])
      @permittedKwargs(permitted_kwargs['configure_file'])
      def func_configure_file(self, node, args, kwargs):
          if len(args) > 0:
              raise InterpreterException("configure_file takes only keyword arguments.")
          if 'output' not in kwargs:
              raise InterpreterException('Required keyword argument "output" not defined.')
          actions = set(['configuration', 'command', 'copy']).intersection(kwargs.keys())
          if len(actions) == 0:
              raise InterpreterException('Must specify an action with one of these '
                                         'keyword arguments: \'configuration\', '
                                         '\'command\', or \'copy\'.')
          elif len(actions) == 2:
              raise InterpreterException('Must not specify both {!r} and {!r} '
                                         'keyword arguments since they are '
                                         'mutually exclusive.'.format(*actions))
          elif len(actions) == 3:
              raise InterpreterException('Must specify one of {!r}, {!r}, and '
                                         '{!r} keyword arguments since they are '
                                         'mutually exclusive.'.format(*actions))
          if 'capture' in kwargs:
              if not isinstance(kwargs['capture'], bool):
                  raise InterpreterException('"capture" keyword must be a boolean.')
              if 'command' not in kwargs:
                  raise InterpreterException('"capture" keyword requires "command" keyword.')
  
          if 'format' in kwargs:
              fmt = kwargs['format']
              if not isinstance(fmt, str):
                  raise InterpreterException('"format" keyword must be a string.')
          else:
              fmt = 'meson'
  
          if fmt not in ('meson', 'cmake', 'cmake@'):
              raise InterpreterException('"format" possible values are "meson", "cmake" or "cmake@".')
  
          if 'output_format' in kwargs:
              output_format = kwargs['output_format']
              if not isinstance(output_format, str):
                  raise InterpreterException('"output_format" keyword must be a string.')
          else:
              output_format = 'c'
  
          if output_format not in ('c', 'nasm'):
              raise InterpreterException('"format" possible values are "c" or "nasm".')
  
          # Validate input
          inputfile = None
          ifile_abs = None
          if 'input' in kwargs:
              inputfile = kwargs['input']
              if isinstance(inputfile, list):
                  if len(inputfile) != 1:
                      m = "Keyword argument 'input' requires exactly one file"
                      raise InterpreterException(m)
                  inputfile = inputfile[0]
              if not isinstance(inputfile, (str, mesonlib.File)):
                  raise InterpreterException('Input must be a string or a file')
              if isinstance(inputfile, str):
                  inputfile = mesonlib.File.from_source_file(self.environment.source_dir,
                                                             self.subdir, inputfile)
              ifile_abs = inputfile.absolute_path(self.environment.source_dir,
                                                  self.environment.build_dir)
          elif 'command' in kwargs and '@INPUT@' in kwargs['command']:
              raise InterpreterException('@INPUT@ used as command argument, but no input file specified.')
          # Validate output
          output = kwargs['output']
          if not isinstance(output, str):
              raise InterpreterException('Output file name must be a string')
          if ifile_abs:
              values = mesonlib.get_filenames_templates_dict([ifile_abs], None)
              outputs = mesonlib.substitute_values([output], values)
              output = outputs[0]
          if os.path.dirname(output) != '':
              raise InterpreterException('Output file name must not contain a subdirectory.')
          (ofile_path, ofile_fname) = os.path.split(os.path.join(self.subdir, output))
          ofile_abs = os.path.join(self.environment.build_dir, ofile_path, ofile_fname)
          # Optimize copies by not doing substitution if there's nothing to
          # substitute, and warn about this legacy hack
          if 'configuration' in kwargs:
              conf = kwargs['configuration']
              if not isinstance(conf, ConfigurationDataHolder):
                  raise InterpreterException('Argument "configuration" must be of type configuration_data')
              if ifile_abs and not conf.keys():
                  del kwargs['configuration']
                  kwargs['copy'] = True
                  mlog.warning('Got an empty configuration_data() object: '
                               'optimizing copy automatically; if you want to '
                               'copy a file to the build dir, use the \'copy:\' '
                               'keyword argument added in 0.47.0', location=node)
                  conf.mark_used()
          # Perform the appropriate action
          if 'configuration' in kwargs:
              conf = kwargs['configuration']
              if not isinstance(conf, ConfigurationDataHolder):
                  raise InterpreterException('Argument "configuration" is not of type configuration_data')
              mlog.log('Configuring', mlog.bold(output), 'using configuration')
              if inputfile is not None:
                  os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
                  file_encoding = kwargs.setdefault('encoding', 'utf-8')
                  missing_variables = mesonlib.do_conf_file(ifile_abs, ofile_abs,
                                                            conf.held_object, fmt,
                                                            file_encoding)
                  if missing_variables:
                      var_list = ", ".join(map(repr, sorted(missing_variables)))
                      mlog.warning(
                          "The variable(s) %s in the input file %s are not "
                          "present in the given configuration data." % (
                              var_list, inputfile), location=node)
              else:
                  mesonlib.dump_conf_header(ofile_abs, conf.held_object, output_format)
              conf.mark_used()
          elif 'command' in kwargs:
              # We use absolute paths for input and output here because the cwd
              # that the command is run from is 'unspecified', so it could change.
              # Currently it's builddir/subdir for in_builddir else srcdir/subdir.
              if ifile_abs:
                  values = mesonlib.get_filenames_templates_dict([ifile_abs], [ofile_abs])
              else:
                  values = mesonlib.get_filenames_templates_dict(None, [ofile_abs])
              # Substitute @INPUT@, @OUTPUT@, etc here.
              cmd = mesonlib.substitute_values(kwargs['command'], values)
              mlog.log('Configuring', mlog.bold(output), 'with command')
              res = self.run_command_impl(node, cmd,  {}, True)
              if res.returncode != 0:
                  raise InterpreterException('Running configure command failed.\n%s\n%s' %
                                             (res.stdout, res.stderr))
              if 'capture' in kwargs and kwargs['capture']:
                  dst_tmp = ofile_abs + '~'
                  file_encoding = kwargs.setdefault('encoding', 'utf-8')
                  with open(dst_tmp, 'w', encoding=file_encoding) as f:
                      f.writelines(res.stdout)
                  if ifile_abs:
                      shutil.copymode(ifile_abs, dst_tmp)
                  mesonlib.replace_if_different(ofile_abs, dst_tmp)
          elif 'copy' in kwargs:
              os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
              shutil.copyfile(ifile_abs, ofile_abs)
              shutil.copymode(ifile_abs, ofile_abs)
          else:
              # Not reachable
              raise AssertionError
          # If the input is a source file, add it to the list of files that we
          # need to reconfigure on when they change. FIXME: Do the same for
          # files() objects in the command: kwarg.
          if inputfile and not inputfile.is_built:
              # Normalize the path of the conffile (relative to the
              # source root) to avoid duplicates. This is especially
              # important to convert '/' to '\' on Windows
              conffile = os.path.normpath(inputfile.relative_name())
              if conffile not in self.build_def_files:
                  self.build_def_files.append(conffile)
          # Install file if requested, we check for the empty string
          # for backwards compatibility. That was the behaviour before
          # 0.45.0 so preserve it.
          idir = kwargs.get('install_dir', None)
          if isinstance(idir, str) and idir:
              cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
              install_mode = self._get_kwarg_install_mode(kwargs)
              self.build.data.append(build.Data([cfile], idir, install_mode))
          return mesonlib.File.from_built_file(self.subdir, output)
  
      @permittedKwargs(permitted_kwargs['include_directories'])
      @stringArgs
      def func_include_directories(self, node, args, kwargs):
          return self.build_incdir_object(args, kwargs.get('is_system', False))
  
      def build_incdir_object(self, incdir_strings, is_system=False):
          if not isinstance(is_system, bool):
              raise InvalidArguments('Is_system must be boolean.')
          src_root = self.environment.get_source_dir()
          build_root = self.environment.get_build_dir()
          absbase_src = os.path.join(src_root, self.subdir)
          absbase_build = os.path.join(build_root, self.subdir)
  
          for a in incdir_strings:
              if a.startswith(src_root):
                  raise InvalidArguments('''Tried to form an absolute path to a source dir. You should not do that but use
  relative paths instead.
  
  To get include path to any directory relative to the current dir do
  
  incdir = include_directories(dirname)
  
  After this incdir will contain both the current source dir as well as the
  corresponding build dir. It can then be used in any subdirectory and
  Meson will take care of all the busywork to make paths work.
  
  Dirname can even be '.' to mark the current directory. Though you should
  remember that the current source and build directories are always
  put in the include directories by default so you only need to do
  include_directories('.') if you intend to use the result in a
  different subdirectory.
  ''')
              absdir_src = os.path.join(absbase_src, a)
              absdir_build = os.path.join(absbase_build, a)
              if not os.path.isdir(absdir_src) and not os.path.isdir(absdir_build):
                  raise InvalidArguments('Include dir %s does not exist.' % a)
          i = IncludeDirsHolder(build.IncludeDirs(self.subdir, incdir_strings, is_system))
          return i
  
      @permittedKwargs(permitted_kwargs['add_test_setup'])
      @stringArgs
      def func_add_test_setup(self, node, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Add_test_setup needs one argument for the setup name.')
          setup_name = args[0]
          if re.fullmatch('([_a-zA-Z][_0-9a-zA-Z]*:)?[_a-zA-Z][_0-9a-zA-Z]*', setup_name) is None:
              raise InterpreterException('Setup name may only contain alphanumeric characters.')
          if ":" not in setup_name:
              setup_name = (self.subproject if self.subproject else self.build.project_name) + ":" + setup_name
          try:
              inp = extract_as_list(kwargs, 'exe_wrapper', unholder=True)
              exe_wrapper = []
              for i in inp:
                  if isinstance(i, str):
                      exe_wrapper.append(i)
                  elif isinstance(i, dependencies.ExternalProgram):
                      if not i.found():
                          raise InterpreterException('Tried to use non-found executable.')
                      exe_wrapper += i.get_command()
                  else:
                      raise InterpreterException('Exe wrapper can only contain strings or external binaries.')
          except KeyError:
              exe_wrapper = None
          gdb = kwargs.get('gdb', False)
          if not isinstance(gdb, bool):
              raise InterpreterException('Gdb option must be a boolean')
          timeout_multiplier = kwargs.get('timeout_multiplier', 1)
          if not isinstance(timeout_multiplier, int):
              raise InterpreterException('Timeout multiplier must be a number.')
          env = self.unpack_env_kwarg(kwargs)
          self.build.test_setups[setup_name] = build.TestSetup(exe_wrapper=exe_wrapper,
                                                               gdb=gdb,
                                                               timeout_multiplier=timeout_multiplier,
                                                               env=env)
  
      @permittedKwargs(permitted_kwargs['add_global_arguments'])
      @stringArgs
      def func_add_global_arguments(self, node, args, kwargs):
          self.add_global_arguments(node, self.build.global_args, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['add_global_link_arguments'])
      @stringArgs
      def func_add_global_link_arguments(self, node, args, kwargs):
          self.add_global_arguments(node, self.build.global_link_args, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['add_project_arguments'])
      @stringArgs
      def func_add_project_arguments(self, node, args, kwargs):
          self.add_project_arguments(node, self.build.projects_args, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['add_project_link_arguments'])
      @stringArgs
      def func_add_project_link_arguments(self, node, args, kwargs):
          self.add_project_arguments(node, self.build.projects_link_args, args, kwargs)
  
      def add_global_arguments(self, node, argsdict, args, kwargs):
          if self.subproject != '':
              msg = 'Function \'{}\' cannot be used in subprojects because ' \
                    'there is no way to make that reliable.\nPlease only call ' \
                    'this if is_subproject() returns false. Alternatively, ' \
                    'define a variable that\ncontains your language-specific ' \
                    'arguments and add it to the appropriate *_args kwarg ' \
                    'in each target.'.format(node.func_name)
              raise InvalidCode(msg)
          frozen = self.project_args_frozen or self.global_args_frozen
          self.add_arguments(node, argsdict, frozen, args, kwargs)
  
      def add_project_arguments(self, node, argsdict, args, kwargs):
          if self.subproject not in argsdict:
              argsdict[self.subproject] = {}
          self.add_arguments(node, argsdict[self.subproject],
                             self.project_args_frozen, args, kwargs)
  
      def add_arguments(self, node, argsdict, args_frozen, args, kwargs):
          if args_frozen:
              msg = 'Tried to use \'{}\' after a build target has been declared.\n' \
                    'This is not permitted. Please declare all ' \
                    'arguments before your targets.'.format(node.func_name)
              raise InvalidCode(msg)
  
          if 'language' not in kwargs:
              raise InvalidCode('Missing language definition in {}'.format(node.func_name))
  
          for lang in mesonlib.stringlistify(kwargs['language']):
              lang = lang.lower()
              argsdict[lang] = argsdict.get(lang, []) + args
  
      @noKwargs
      @noPosargs
      def func_environment(self, node, args, kwargs):
          return EnvironmentVariablesHolder()
  
      @stringArgs
      @noKwargs
      def func_join_paths(self, node, args, kwargs):
          return os.path.join(*args).replace('\\', '/')
  
      def run(self):
          super().run()
          mlog.log('Build targets in project:', mlog.bold(str(len(self.build.targets))))
          FeatureNew.called_features_report()
          FeatureDeprecated.called_features_report()
  
      def evaluate_subproject_info(self, path_from_source_root, subproject_dirname):
          depth = 0
          subproj_name = ''
          segs = PurePath(path_from_source_root).parts
          segs_spd = PurePath(subproject_dirname).parts
          while segs and segs[0] == segs_spd[0]:
              if len(segs_spd) == 1:
                  subproj_name = segs[1]
                  segs = segs[2:]
                  depth += 1
              else:
                  segs_spd = segs_spd[1:]
                  segs = segs[1:]
          return (depth, subproj_name)
  
      # Check that the indicated file is within the same subproject
      # as we currently are. This is to stop people doing
      # nasty things like:
      #
      # f = files('../../master_src/file.c')
      #
      # Note that this is validated only when the file
      # object is generated. The result can be used in a different
      # subproject than it is defined in (due to e.g. a
      # declare_dependency).
      def validate_within_subproject(self, subdir, fname):
          norm = os.path.normpath(os.path.join(subdir, fname))
          if os.path.isabs(norm):
              if not norm.startswith(self.environment.source_dir):
                  # Grabbing files outside the source tree is ok.
                  # This is for vendor stuff like:
                  #
                  # /opt/vendorsdk/src/file_with_license_restrictions.c
                  return
              norm = os.path.relpath(norm, self.environment.source_dir)
              assert(not os.path.isabs(norm))
          (num_sps, sproj_name) = self.evaluate_subproject_info(norm, self.subproject_dir)
          plain_filename = os.path.basename(norm)
          if num_sps == 0:
              if self.subproject == '':
                  return
              raise InterpreterException('Sandbox violation: Tried to grab file %s from a different subproject.' % plain_filename)
          if num_sps > 1:
              raise InterpreterException('Sandbox violation: Tried to grab file %s from a nested subproject.' % plain_filename)
          if sproj_name != self.subproject_directory_name:
              raise InterpreterException('Sandbox violation: Tried to grab file %s from a different subproject.' % plain_filename)
  
      def source_strings_to_files(self, sources):
          results = []
          mesonlib.check_direntry_issues(sources)
          if not isinstance(sources, list):
              sources = [sources]
          for s in sources:
              if isinstance(s, (mesonlib.File, GeneratedListHolder,
                                CustomTargetHolder, CustomTargetIndexHolder)):
                  pass
              elif isinstance(s, str):
                  self.validate_within_subproject(self.subdir, s)
                  s = mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, s)
              else:
                  raise InterpreterException('Source item is {!r} instead of '
                                             'string or File-type object'.format(s))
              results.append(s)
          return results
  
      def add_target(self, name, tobj):
          if name == '':
              raise InterpreterException('Target name must not be empty.')
          if name.strip() == '':
              raise InterpreterException('Target name must not consist only of whitespace.')
          if name.startswith('meson-'):
              raise InvalidArguments("Target names starting with 'meson-' are reserved "
                                     "for Meson's internal use. Please rename.")
          if name in coredata.forbidden_target_names:
              raise InvalidArguments("Target name '%s' is reserved for Meson's "
                                     "internal use. Please rename." % name)
          # To permit an executable and a shared library to have the
          # same name, such as "foo.exe" and "libfoo.a".
          idname = tobj.get_id()
          if idname in self.build.targets:
              raise InvalidCode('Tried to create target "%s", but a target of that name already exists.' % name)
          self.build.targets[idname] = tobj
          if idname not in self.coredata.target_guids:
              self.coredata.target_guids[idname] = str(uuid.uuid4()).upper()
  
      @FeatureNew('both_libraries', '0.46.0')
      def build_both_libraries(self, node, args, kwargs):
          shared_holder = self.build_target(node, args, kwargs, SharedLibraryHolder)
  
          # Check if user forces non-PIC static library.
          pic = True
          if 'pic' in kwargs:
              pic = kwargs['pic']
          elif 'b_staticpic' in self.environment.coredata.base_options:
              pic = self.environment.coredata.base_options['b_staticpic'].value
  
          if pic:
              # Exclude sources from args and kwargs to avoid building them twice
              static_args = [args[0]]
              static_kwargs = kwargs.copy()
              static_kwargs['sources'] = []
              static_kwargs['objects'] = shared_holder.held_object.extract_all_objects()
          else:
              static_args = args
              static_kwargs = kwargs
  
          static_holder = self.build_target(node, static_args, static_kwargs, StaticLibraryHolder)
  
          return BothLibrariesHolder(shared_holder, static_holder, self)
  
      def build_library(self, node, args, kwargs):
          default_library = self.coredata.get_builtin_option('default_library')
          if default_library == 'shared':
              return self.build_target(node, args, kwargs, SharedLibraryHolder)
          elif default_library == 'static':
              return self.build_target(node, args, kwargs, StaticLibraryHolder)
          elif default_library == 'both':
              return self.build_both_libraries(node, args, kwargs)
          else:
              raise InterpreterException('Unknown default_library value: %s.', default_library)
  
      def build_target(self, node, args, kwargs, targetholder):
          if not args:
              raise InterpreterException('Target does not have a name.')
          name = args[0]
          sources = listify(args[1:])
          if self.environment.is_cross_build():
              if kwargs.get('native', False):
                  is_cross = False
              else:
                  is_cross = True
          else:
              is_cross = False
          if 'sources' in kwargs:
              sources += listify(kwargs['sources'])
          sources = self.source_strings_to_files(sources)
          objs = extract_as_list(kwargs, 'objects')
          kwargs['dependencies'] = extract_as_list(kwargs, 'dependencies')
          kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
          if 'extra_files' in kwargs:
              ef = extract_as_list(kwargs, 'extra_files')
              kwargs['extra_files'] = self.source_strings_to_files(ef)
          self.check_sources_exist(os.path.join(self.source_root, self.subdir), sources)
          if targetholder is ExecutableHolder:
              targetclass = build.Executable
          elif targetholder is SharedLibraryHolder:
              targetclass = build.SharedLibrary
          elif targetholder is SharedModuleHolder:
              targetclass = build.SharedModule
          elif targetholder is StaticLibraryHolder:
              targetclass = build.StaticLibrary
          elif targetholder is JarHolder:
              targetclass = build.Jar
          else:
              mlog.debug('Unknown target type:', str(targetholder))
              raise RuntimeError('Unreachable code')
          self.kwarg_strings_to_includedirs(kwargs)
  
          # Filter out kwargs from other target types. For example 'soversion'
          # passed to library() when default_library == 'static'.
          kwargs = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs}
  
          target = targetclass(name, self.subdir, self.subproject, is_cross, sources, objs, self.environment, kwargs)
  
          if is_cross:
              self.add_cross_stdlib_info(target)
          l = targetholder(target, self)
          self.add_target(name, l.held_object)
          self.project_args_frozen = True
          return l
  
      def kwarg_strings_to_includedirs(self, kwargs):
          if 'd_import_dirs' in kwargs:
              items = mesonlib.extract_as_list(kwargs, 'd_import_dirs')
              cleaned_items = []
              for i in items:
                  if isinstance(i, str):
                      # BW compatibility. This was permitted so we must support it
                      # for a few releases so people can transition to "correct"
                      # path declarations.
                      if i.startswith(self.environment.get_source_dir()):
                          mlog.warning('''Building a path to the source dir is not supported. Use a relative path instead.
  This will become a hard error in the future.''')
                          i = os.path.relpath(i, os.path.join(self.environment.get_source_dir(), self.subdir))
                          i = self.build_incdir_object([i])
                  cleaned_items.append(i)
              kwargs['d_import_dirs'] = cleaned_items
  
      def get_used_languages(self, target):
          result = {}
          for i in target.sources:
              for lang, c in self.build.compilers.items():
                  if c.can_compile(i):
                      result[lang] = True
                      break
          return result
  
      def add_cross_stdlib_info(self, target):
          for l in self.get_used_languages(target):
              if self.environment.cross_info.has_stdlib(l) \
                      and self.subproject != self.environment.cross_info.get_stdlib(l)[0]:
                  target.add_deps(self.build.cross_stdlibs[l])
  
      def check_sources_exist(self, subdir, sources):
          for s in sources:
              if not isinstance(s, str):
                  continue # This means a generated source and they always exist.
              fname = os.path.join(subdir, s)
              if not os.path.isfile(fname):
                  raise InterpreterException('Tried to add non-existing source file %s.' % s)
  
      def format_string(self, templ, args):
          if isinstance(args, mparser.ArgumentNode):
              args = args.arguments
          arg_strings = []
          for arg in args:
              arg = self.evaluate_statement(arg)
              if isinstance(arg, bool): # Python boolean is upper case.
                  arg = str(arg).lower()
              arg_strings.append(str(arg))
  
          def arg_replace(match):
              idx = int(match.group(1))
              if idx >= len(arg_strings):
                  raise InterpreterException('Format placeholder @{}@ out of range.'.format(idx))
              return arg_strings[idx]
  
          return re.sub(r'@(\d+)@', arg_replace, templ)
  
      # Only permit object extraction from the same subproject
      def validate_extraction(self, buildtarget):
          if not self.subdir.startswith(self.subproject_dir):
              if buildtarget.subdir.startswith(self.subproject_dir):
                  raise InterpreterException('Tried to extract objects from a subproject target.')
          else:
              if not buildtarget.subdir.startswith(self.subproject_dir):
                  raise InterpreterException('Tried to extract objects from the main project from a subproject.')
              if self.subdir.split('/')[1] != buildtarget.subdir.split('/')[1]:
                  raise InterpreterException('Tried to extract objects from a different subproject.')
  
      def check_contains(self, obj, args):
          if len(args) != 1:
              raise InterpreterException('Contains method takes exactly one argument.')
          item = args[0]
          for element in obj:
              if isinstance(element, list):
                  found = self.check_contains(element, args)
                  if found:
                      return True
              if element == item:
                  return True
          return False
  
      def is_subproject(self):
          return self.subproject != ''
  
      @noKwargs
      @noArgsFlattening
      def func_set_variable(self, node, args, kwargs):
          if len(args) != 2:
              raise InvalidCode('Set_variable takes two arguments.')
          varname = args[0]
          value = args[1]
          self.set_variable(varname, value)
  
      @noKwargs
      @noArgsFlattening
      def func_get_variable(self, node, args, kwargs):
          if len(args) < 1 or len(args) > 2:
              raise InvalidCode('Get_variable takes one or two arguments.')
          varname = args[0]
          if not isinstance(varname, str):
              raise InterpreterException('First argument must be a string.')
          try:
              return self.variables[varname]
          except KeyError:
              pass
          if len(args) == 2:
              return args[1]
          raise InterpreterException('Tried to get unknown variable "%s".' % varname)
  
      @stringArgs
      @noKwargs
      def func_is_variable(self, node, args, kwargs):
          if len(args) != 1:
              raise InvalidCode('Is_variable takes two arguments.')
          varname = args[0]
          return varname in self.variables
  
files: mesonbuild/interpreter.py