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 os, pickle, re, shlex, subprocess
  from collections import OrderedDict
  import itertools
  from pathlib import PurePath
  
  from . import backends
  from .. import modules
  from .. import environment, mesonlib
  from .. import build
  from .. import mlog
  from .. import dependencies
  from .. import compilers
  from ..compilers import CompilerArgs
  from ..linkers import ArLinker
  from ..mesonlib import File, MesonException, OrderedSet
  from ..mesonlib import get_compiler_for_source, has_path_sep
  from .backends import CleanTrees, InstallData
  from ..build import InvalidArguments
  
  if mesonlib.is_windows():
      quote_func = lambda s: '"{}"'.format(s)
      execute_wrapper = 'cmd /c'
      rmfile_prefix = 'del /f /s /q {} &&'
  else:
      quote_func = shlex.quote
      execute_wrapper = ''
      rmfile_prefix = 'rm -f {} &&'
  
  def ninja_quote(text, is_build_line=False):
      if is_build_line:
          qcs = ('$', ' ', ':')
      else:
          qcs = ('$', ' ')
      for char in qcs:
          text = text.replace(char, '$' + char)
      if '\n' in text:
          errmsg = '''Ninja does not support newlines in rules. The content was:
  
  %s
  
  Please report this error with a test case to the Meson bug tracker.''' % text
          raise MesonException(errmsg)
      return text
  
  
  class NinjaBuildElement:
      def __init__(self, all_outputs, outfilenames, rule, infilenames):
          if isinstance(outfilenames, str):
              self.outfilenames = [outfilenames]
          else:
              self.outfilenames = outfilenames
          assert(isinstance(rule, str))
          self.rule = rule
          if isinstance(infilenames, str):
              self.infilenames = [infilenames]
          else:
              self.infilenames = infilenames
          self.deps = set()
          self.orderdeps = set()
          self.elems = []
          self.all_outputs = all_outputs
  
      def add_dep(self, dep):
          if isinstance(dep, list):
              self.deps.update(dep)
          else:
              self.deps.add(dep)
  
      def add_orderdep(self, dep):
          if isinstance(dep, list):
              self.orderdeps.update(dep)
          else:
              self.orderdeps.add(dep)
  
      def add_item(self, name, elems):
          if isinstance(elems, str):
              elems = [elems]
          self.elems.append((name, elems))
  
      def write(self, outfile):
          self.check_outputs()
          line = 'build %s: %s %s' % (' '.join([ninja_quote(i, True) for i in self.outfilenames]),
                                      self.rule,
                                      ' '.join([ninja_quote(i, True) for i in self.infilenames]))
          if len(self.deps) > 0:
              line += ' | ' + ' '.join([ninja_quote(x, True) for x in self.deps])
          if len(self.orderdeps) > 0:
              line += ' || ' + ' '.join([ninja_quote(x, True) for x in self.orderdeps])
          line += '\n'
          # This is the only way I could find to make this work on all
          # platforms including Windows command shell. Slash is a dir separator
          # on Windows, too, so all characters are unambiguous and, more importantly,
          # do not require quoting, unless explicitely specified, which is necessary for
          # the csc compiler.
          line = line.replace('\\', '/')
          outfile.write(line)
  
          # All the entries that should remain unquoted
          raw_names = {'DEPFILE', 'DESC', 'pool', 'description'}
  
          for e in self.elems:
              (name, elems) = e
              should_quote = name not in raw_names
              line = ' %s = ' % name
              newelems = []
              for i in elems:
                  if not should_quote or i == '&&': # Hackety hack hack
                      quoter = ninja_quote
                  else:
                      quoter = lambda x: ninja_quote(quote_func(x))
                  i = i.replace('\\', '\\\\')
                  if quote_func('') == '""':
                      i = i.replace('"', '\\"')
                  newelems.append(quoter(i))
              line += ' '.join(newelems)
              line += '\n'
              outfile.write(line)
          outfile.write('\n')
  
      def check_outputs(self):
          for n in self.outfilenames:
              if n in self.all_outputs:
                  raise MesonException('Multiple producers for Ninja target "%s". Please rename your targets.' % n)
              self.all_outputs[n] = True
  
  class NinjaBackend(backends.Backend):
  
      def __init__(self, build):
          super().__init__(build)
          self.name = 'ninja'
          self.ninja_filename = 'build.ninja'
          self.target_arg_cache = {}
          self.fortran_deps = {}
          self.all_outputs = {}
  
      def create_target_alias(self, to_target, outfile):
          # We need to use aliases for targets that might be used as directory
          # names to workaround a Ninja bug that breaks `ninja -t clean`.
          # This is used for 'reserved' targets such as 'test', 'install',
          # 'benchmark', etc, and also for RunTargets.
          # https://github.com/mesonbuild/meson/issues/1644
          if not to_target.startswith('meson-'):
              m = 'Invalid usage of create_target_alias with {!r}'
              raise AssertionError(m.format(to_target))
          from_target = to_target[len('meson-'):]
          elem = NinjaBuildElement(self.all_outputs, from_target, 'phony', to_target)
          elem.write(outfile)
  
      def detect_vs_dep_prefix(self, tempfilename):
          '''VS writes its dependency in a locale dependent format.
          Detect the search prefix to use.'''
          for compiler in self.build.compilers.values():
              # Have to detect the dependency format
              if compiler.id == 'msvc':
                  break
          else:
              # None of our compilers are MSVC, we're done.
              return open(tempfilename, 'a')
          filename = os.path.join(self.environment.get_scratch_dir(),
                                  'incdetect.c')
          with open(filename, 'w') as f:
              f.write('''#include<stdio.h>
  int dummy;
  ''')
  
          # The output of cl dependency information is language
          # and locale dependent. Any attempt at converting it to
          # Python strings leads to failure. We _must_ do this detection
          # in raw byte mode and write the result in raw bytes.
          pc = subprocess.Popen(['cl', '/showIncludes', '/c', 'incdetect.c'],
                                cwd=self.environment.get_scratch_dir(),
                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
          (stdo, _) = pc.communicate()
  
          # We want to match 'Note: including file: ' in the line
          # 'Note: including file: d:\MyDir\include\stdio.h', however
          # different locales have different messages with a different
          # number of colons. Match up to the the drive name 'd:\'.
          matchre = re.compile(rb"^(.*\s)[a-zA-Z]:\\.*stdio.h$")
          for line in stdo.split(b'\r\n'):
              match = matchre.match(line)
              if match:
                  with open(tempfilename, 'ab') as binfile:
                      binfile.write(b'msvc_deps_prefix = ' + match.group(1) + b'\n')
                  return open(tempfilename, 'a')
          raise MesonException('Could not determine vs dep dependency prefix string.')
  
      def generate(self, interp):
          self.interpreter = interp
          self.ninja_command = environment.detect_ninja(log=True)
          if self.ninja_command is None:
              raise MesonException('Could not detect Ninja v1.5 or newer')
          outfilename = os.path.join(self.environment.get_build_dir(), self.ninja_filename)
          tempfilename = outfilename + '~'
          with open(tempfilename, 'w') as outfile:
              outfile.write('# This is the build file for project "%s"\n' %
                            self.build.get_project())
              outfile.write('# It is autogenerated by the Meson build system.\n')
              outfile.write('# Do not edit by hand.\n\n')
              outfile.write('ninja_required_version = 1.5.1\n\n')
          with self.detect_vs_dep_prefix(tempfilename) as outfile:
              self.generate_rules(outfile)
              self.generate_phony(outfile)
              outfile.write('# Build rules for targets\n\n')
              for t in self.build.get_targets().values():
                  self.generate_target(t, outfile)
              outfile.write('# Test rules\n\n')
              self.generate_tests(outfile)
              outfile.write('# Install rules\n\n')
              self.generate_install(outfile)
              self.generate_dist(outfile)
              if 'b_coverage' in self.environment.coredata.base_options and \
                      self.environment.coredata.base_options['b_coverage'].value:
                  outfile.write('# Coverage rules\n\n')
                  self.generate_coverage_rules(outfile)
              outfile.write('# Suffix\n\n')
              self.generate_utils(outfile)
              self.generate_ending(outfile)
          # Only overwrite the old build file after the new one has been
          # fully created.
          os.replace(tempfilename, outfilename)
          self.generate_compdb()
  
      # http://clang.llvm.org/docs/JSONCompilationDatabase.html
      def generate_compdb(self):
          pch_compilers = ['%s_PCH' % i for i in self.build.compilers]
          native_compilers = ['%s_COMPILER' % i for i in self.build.compilers]
          cross_compilers = ['%s_CROSS_COMPILER' % i for i in self.build.cross_compilers]
          ninja_compdb = [self.ninja_command, '-t', 'compdb'] + pch_compilers + native_compilers + cross_compilers
          builddir = self.environment.get_build_dir()
          try:
              jsondb = subprocess.check_output(ninja_compdb, cwd=builddir)
              with open(os.path.join(builddir, 'compile_commands.json'), 'wb') as f:
                  f.write(jsondb)
          except Exception:
              mlog.warning('Could not create compilation database.')
  
      # Get all generated headers. Any source file might need them so
      # we need to add an order dependency to them.
      def get_generated_headers(self, target):
          header_deps = []
          # XXX: Why don't we add deps to CustomTarget headers here?
          for genlist in target.get_generated_sources():
              if isinstance(genlist, (build.CustomTarget, build.CustomTargetIndex)):
                  continue
              for src in genlist.get_outputs():
                  if self.environment.is_header(src):
                      header_deps.append(self.get_target_generated_dir(target, genlist, src))
          if 'vala' in target.compilers and not isinstance(target, build.Executable):
              vala_header = File.from_built_file(self.get_target_dir(target), target.vala_header)
              header_deps.append(vala_header)
          # Recurse and find generated headers
          for dep in itertools.chain(target.link_targets, target.link_whole_targets):
              if isinstance(dep, (build.StaticLibrary, build.SharedLibrary)):
                  header_deps += self.get_generated_headers(dep)
          return header_deps
  
      def get_target_generated_sources(self, target):
          """
          Returns a dictionary with the keys being the path to the file
          (relative to the build directory) of that type and the value
          being the GeneratorList or CustomTarget that generated it.
          """
          srcs = OrderedDict()
          for gensrc in target.get_generated_sources():
              for s in gensrc.get_outputs():
                  f = self.get_target_generated_dir(target, gensrc, s)
                  srcs[f] = s
          return srcs
  
      def get_target_sources(self, target):
          srcs = OrderedDict()
          for s in target.get_sources():
              # BuildTarget sources are always mesonlib.File files which are
              # either in the source root, or generated with configure_file and
              # in the build root
              if not isinstance(s, File):
                  raise InvalidArguments('All sources in target {!r} must be of type mesonlib.File'.format(s))
              f = s.rel_to_builddir(self.build_to_src)
              srcs[f] = s
          return srcs
  
      # Languages that can mix with C or C++ but don't support unity builds yet
      # because the syntax we use for unity builds is specific to C/++/ObjC/++.
      # Assembly files cannot be unitified and neither can LLVM IR files
      langs_cant_unity = ('d', 'fortran')
  
      def get_target_source_can_unity(self, target, source):
          if isinstance(source, File):
              source = source.fname
          if self.environment.is_llvm_ir(source) or \
             self.environment.is_assembly(source):
              return False
          suffix = os.path.splitext(source)[1][1:]
          for lang in self.langs_cant_unity:
              if lang not in target.compilers:
                  continue
              if suffix in target.compilers[lang].file_suffixes:
                  return False
          return True
  
      def generate_target(self, target, outfile):
          if isinstance(target, build.CustomTarget):
              self.generate_custom_target(target, outfile)
          if isinstance(target, build.RunTarget):
              self.generate_run_target(target, outfile)
          name = target.get_id()
          if name in self.processed_targets:
              return
          self.processed_targets[name] = True
          # Generate rules for all dependency targets
          self.process_target_dependencies(target, outfile)
          # If target uses a language that cannot link to C objects,
          # just generate for that language and return.
          if isinstance(target, build.Jar):
              self.generate_jar_target(target, outfile)
              return
          if 'rust' in target.compilers:
              self.generate_rust_target(target, outfile)
              return
          if 'cs' in target.compilers:
              self.generate_cs_target(target, outfile)
              return
          if 'swift' in target.compilers:
              self.generate_swift_target(target, outfile)
              return
  
          # Now we handle the following languages:
          # ObjC++, ObjC, C++, C, D, Fortran, Vala
  
          # target_sources:
          #   Pre-existing target C/C++ sources to be built; dict of full path to
          #   source relative to build root and the original File object.
          # generated_sources:
          #   GeneratedList and CustomTarget sources to be built; dict of the full
          #   path to source relative to build root and the generating target/list
          # vala_generated_sources:
          #   Array of sources generated by valac that have to be compiled
          if 'vala' in target.compilers:
              # Sources consumed by valac are filtered out. These only contain
              # C/C++ sources, objects, generated libs, and unknown sources now.
              target_sources, generated_sources, \
                  vala_generated_sources = self.generate_vala_compile(target, outfile)
          else:
              target_sources = self.get_target_sources(target)
              generated_sources = self.get_target_generated_sources(target)
              vala_generated_sources = []
          self.scan_fortran_module_outputs(target)
          # Generate rules for GeneratedLists
          self.generate_generator_list_rules(target, outfile)
  
          # Generate rules for building the remaining source files in this target
          outname = self.get_target_filename(target)
          obj_list = []
          use_pch = self.environment.coredata.base_options.get('b_pch', False)
          is_unity = self.is_unity(target)
          if use_pch and target.has_pch():
              pch_objects = self.generate_pch(target, outfile)
          else:
              pch_objects = []
          header_deps = []
          unity_src = []
          unity_deps = [] # Generated sources that must be built before compiling a Unity target.
          header_deps += self.get_generated_headers(target)
  
          if is_unity:
              # Warn about incompatible sources if a unity build is enabled
              langs = set(target.compilers.keys())
              langs_cant = langs.intersection(self.langs_cant_unity)
              if langs_cant:
                  langs_are = langs = ', '.join(langs_cant).upper()
                  langs_are += ' are' if len(langs_cant) > 1 else ' is'
                  msg = '{} not supported in Unity builds yet, so {} ' \
                        'sources in the {!r} target will be compiled normally' \
                        ''.format(langs_are, langs, target.name)
                  mlog.log(mlog.red('FIXME'), msg)
  
          # Get a list of all generated headers that will be needed while building
          # this target's sources (generated sources and pre-existing sources).
          # This will be set as dependencies of all the target's sources. At the
          # same time, also deal with generated sources that need to be compiled.
          generated_source_files = []
          for rel_src, gensrc in generated_sources.items():
              dirpart, fnamepart = os.path.split(rel_src)
              raw_src = File(True, dirpart, fnamepart)
              if self.environment.is_source(rel_src) and not self.environment.is_header(rel_src):
                  if is_unity and self.get_target_source_can_unity(target, rel_src):
                      unity_deps.append(raw_src)
                      abs_src = os.path.join(self.environment.get_build_dir(), rel_src)
                      unity_src.append(abs_src)
                  else:
                      generated_source_files.append(raw_src)
              elif self.environment.is_object(rel_src):
                  obj_list.append(rel_src)
              elif self.environment.is_library(rel_src):
                  pass
              else:
                  # Assume anything not specifically a source file is a header. This is because
                  # people generate files with weird suffixes (.inc, .fh) that they then include
                  # in their source files.
                  header_deps.append(raw_src)
          # These are the generated source files that need to be built for use by
          # this target. We create the Ninja build file elements for this here
          # because we need `header_deps` to be fully generated in the above loop.
          for src in generated_source_files:
              if self.environment.is_llvm_ir(src):
                  o = self.generate_llvm_ir_compile(target, outfile, src)
              else:
                  o = self.generate_single_compile(target, outfile, src, True,
                                                   header_deps=header_deps)
              obj_list.append(o)
  
          # Generate compilation targets for C sources generated from Vala
          # sources. This can be extended to other $LANG->C compilers later if
          # necessary. This needs to be separate for at least Vala
          vala_generated_source_files = []
          for src in vala_generated_sources:
              dirpart, fnamepart = os.path.split(src)
              raw_src = File(True, dirpart, fnamepart)
              if is_unity:
                  unity_src.append(os.path.join(self.environment.get_build_dir(), src))
                  header_deps.append(raw_src)
              else:
                  # Generated targets are ordered deps because the must exist
                  # before the sources compiling them are used. After the first
                  # compile we get precise dependency info from dep files.
                  # This should work in all cases. If it does not, then just
                  # move them from orderdeps to proper deps.
                  if self.environment.is_header(src):
                      header_deps.append(raw_src)
                  else:
                      # We gather all these and generate compile rules below
                      # after `header_deps` (above) is fully generated
                      vala_generated_source_files.append(raw_src)
          for src in vala_generated_source_files:
              # Passing 'vala' here signifies that we want the compile
              # arguments to be specialized for C code generated by
              # valac. For instance, no warnings should be emitted.
              obj_list.append(self.generate_single_compile(target, outfile, src, 'vala', [], header_deps))
  
          # Generate compile targets for all the pre-existing sources for this target
          for f, src in target_sources.items():
              if not self.environment.is_header(src):
                  if self.environment.is_llvm_ir(src):
                      obj_list.append(self.generate_llvm_ir_compile(target, outfile, src))
                  elif is_unity and self.get_target_source_can_unity(target, src):
                      abs_src = os.path.join(self.environment.get_build_dir(),
                                             src.rel_to_builddir(self.build_to_src))
                      unity_src.append(abs_src)
                  else:
                      obj_list.append(self.generate_single_compile(target, outfile, src, False, [], header_deps))
          obj_list += self.flatten_object_list(target)
          if is_unity:
              for src in self.generate_unity_files(target, unity_src):
                  obj_list.append(self.generate_single_compile(target, outfile, src, True, unity_deps + header_deps))
          linker = self.determine_linker(target)
          elem = self.generate_link(target, outfile, outname, obj_list, linker, pch_objects)
          self.generate_shlib_aliases(target, self.get_target_dir(target))
          elem.write(outfile)
  
      def process_target_dependencies(self, target, outfile):
          for t in target.get_dependencies():
              if t.get_id() not in self.processed_targets:
                  self.generate_target(t, outfile)
  
      def custom_target_generator_inputs(self, target, outfile):
          for s in target.sources:
              if hasattr(s, 'held_object'):
                  s = s.held_object
              if isinstance(s, build.GeneratedList):
                  self.generate_genlist_for_target(s, target, outfile)
  
      def unwrap_dep_list(self, target):
          deps = []
          for i in target.get_dependencies():
              # FIXME, should not grab element at zero but rather expand all.
              if isinstance(i, list):
                  i = i[0]
              # Add a dependency on all the outputs of this target
              for output in i.get_outputs():
                  deps.append(os.path.join(self.get_target_dir(i), output))
          return deps
  
      def generate_custom_target(self, target, outfile):
          self.custom_target_generator_inputs(target, outfile)
          (srcs, ofilenames, cmd) = self.eval_custom_target_command(target)
          deps = self.unwrap_dep_list(target)
          deps += self.get_custom_target_depend_files(target)
          desc = 'Generating {0} with a {1} command.'
          if target.build_always:
              deps.append('PHONY')
          if target.depfile is None:
              rulename = 'CUSTOM_COMMAND'
          else:
              rulename = 'CUSTOM_COMMAND_DEP'
          elem = NinjaBuildElement(self.all_outputs, ofilenames, rulename, srcs)
          elem.add_dep(deps)
          for d in target.extra_depends:
              # Add a dependency on all the outputs of this target
              for output in d.get_outputs():
                  elem.add_dep(os.path.join(self.get_target_dir(d), output))
          serialize = False
          extra_paths = []
          # If the target requires capturing stdout, then use the serialized
          # executable wrapper to capture that output and save it to a file.
          if target.capture:
              serialize = True
          # If the command line requires a newline, also use the wrapper, as
          # ninja does not support them in its build rule syntax.
          if any('\n' in c for c in cmd):
              serialize = True
          # Windows doesn't have -rpath, so for EXEs that need DLLs built within
          # the project, we need to set PATH so the DLLs are found. We use
          # a serialized executable wrapper for that and check if the
          # CustomTarget command needs extra paths first.
          if mesonlib.is_windows() or mesonlib.is_cygwin():
              extra_bdeps = target.get_transitive_build_target_deps()
              extra_paths = self.determine_windows_extra_paths(target.command[0], extra_bdeps)
              if extra_paths:
                  serialize = True
          if serialize:
              exe_data = self.serialize_executable(target.command[0], cmd[1:],
                                                   # All targets are built from the build dir
                                                   self.environment.get_build_dir(),
                                                   extra_paths=extra_paths,
                                                   capture=ofilenames[0] if target.capture else None)
              cmd = self.environment.get_build_command() + ['--internal', 'exe', exe_data]
              cmd_type = 'meson_exe.py custom'
          else:
              cmd_type = 'custom'
          if target.depfile is not None:
              rel_dfile = os.path.join(self.get_target_dir(target), target.depfile)
              abs_pdir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(target))
              os.makedirs(abs_pdir, exist_ok=True)
              elem.add_item('DEPFILE', rel_dfile)
          cmd = self.replace_paths(target, cmd)
          elem.add_item('COMMAND', cmd)
          elem.add_item('description', desc.format(target.name, cmd_type))
          elem.write(outfile)
          self.processed_targets[target.get_id()] = True
  
      def generate_run_target(self, target, outfile):
          cmd = self.environment.get_build_command() + ['--internal', 'commandrunner']
          deps = self.unwrap_dep_list(target)
          arg_strings = []
          for i in target.args:
              if isinstance(i, str):
                  arg_strings.append(i)
              elif isinstance(i, (build.BuildTarget, build.CustomTarget)):
                  relfname = self.get_target_filename(i)
                  arg_strings.append(os.path.join(self.environment.get_build_dir(), relfname))
                  deps.append(relfname)
              elif isinstance(i, mesonlib.File):
                  relfname = i.rel_to_builddir(self.build_to_src)
                  arg_strings.append(os.path.join(self.environment.get_build_dir(), relfname))
              else:
                  raise AssertionError('Unreachable code in generate_run_target: ' + str(i))
          if target.subproject != '':
              subproject_prefix = '{}@@'.format(target.subproject)
          else:
              subproject_prefix = ''
          target_name = 'meson-{}{}'.format(subproject_prefix, target.name)
          elem = NinjaBuildElement(self.all_outputs, target_name, 'CUSTOM_COMMAND', [])
          cmd += [self.environment.get_source_dir(),
                  self.environment.get_build_dir(),
                  target.subdir] + self.environment.get_build_command()
          texe = target.command
          try:
              texe = texe.held_object
          except AttributeError:
              pass
          if isinstance(texe, build.Executable):
              abs_exe = os.path.join(self.environment.get_build_dir(), self.get_target_filename(texe))
              deps.append(self.get_target_filename(texe))
              if self.environment.is_cross_build() and \
                 self.environment.cross_info.need_exe_wrapper():
                  exe_wrap = self.environment.cross_info.config['binaries'].get('exe_wrapper', None)
                  if exe_wrap is not None:
                      cmd += [exe_wrap]
              cmd.append(abs_exe)
          elif isinstance(texe, dependencies.ExternalProgram):
              cmd += texe.get_command()
          elif isinstance(texe, build.CustomTarget):
              deps.append(self.get_target_filename(texe))
              cmd += [os.path.join(self.environment.get_build_dir(), self.get_target_filename(texe))]
          elif isinstance(texe, mesonlib.File):
              cmd.append(texe.absolute_path(self.environment.get_source_dir(), self.environment.get_build_dir()))
          else:
              cmd.append(target.command)
          cmd += arg_strings
  
          elem.add_dep(deps)
          cmd = self.replace_paths(target, cmd)
          elem.add_item('COMMAND', cmd)
          elem.add_item('description', 'Running external command %s.' % target.name)
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above with the name the user specified
          self.create_target_alias(target_name, outfile)
          self.processed_targets[target.get_id()] = True
  
      def generate_coverage_rules(self, outfile):
          e = NinjaBuildElement(self.all_outputs, 'meson-coverage', 'CUSTOM_COMMAND', 'PHONY')
          e.add_item('COMMAND', self.environment.get_build_command() +
                     ['--internal', 'coverage',
                      self.environment.get_source_dir(),
                      self.environment.get_build_dir(),
                      self.environment.get_log_dir()])
          e.add_item('description', 'Generates coverage reports.')
          e.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-coverage', outfile)
          self.generate_coverage_legacy_rules(outfile)
  
      def generate_coverage_legacy_rules(self, outfile):
          (gcovr_exe, gcovr_new_rootdir, lcov_exe, genhtml_exe) = environment.find_coverage_tools()
          added_rule = False
          if gcovr_exe:
              # gcovr >= 3.1 interprets rootdir differently
              if gcovr_new_rootdir:
                  rootdir = self.environment.get_build_dir()
              else:
                  rootdir = self.environment.get_source_dir(),
              added_rule = True
              elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-xml', 'CUSTOM_COMMAND', '')
              elem.add_item('COMMAND', [gcovr_exe, '-x', '-r', rootdir,
                                        '-o', os.path.join(self.environment.get_log_dir(), 'coverage.xml')])
              elem.add_item('DESC', 'Generating XML coverage report.')
              elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-xml', outfile)
              elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-text', 'CUSTOM_COMMAND', '')
              elem.add_item('COMMAND', [gcovr_exe, '-r', rootdir,
                                        '-o', os.path.join(self.environment.get_log_dir(), 'coverage.txt')])
              elem.add_item('DESC', 'Generating text coverage report.')
              elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-text', outfile)
          if lcov_exe and genhtml_exe:
              added_rule = True
              htmloutdir = os.path.join(self.environment.get_log_dir(), 'coveragereport')
              covinfo = os.path.join(self.environment.get_log_dir(), 'coverage.info')
              phony_elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-html', 'phony', os.path.join(htmloutdir, 'index.html'))
              phony_elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-html', outfile)
              elem = NinjaBuildElement(self.all_outputs, os.path.join(htmloutdir, 'index.html'), 'CUSTOM_COMMAND', '')
  
              subproject_dir = self.build.get_subproject_dir()
              command = [lcov_exe,
                         '--directory', self.environment.get_build_dir(),
                         '--capture',
                         '--output-file', covinfo,
                         '--no-checksum',
                         '&&', lcov_exe,
                         '--extract',
                         covinfo,
                         os.path.join(self.environment.get_source_dir(), '*'),
                         '--output-file', covinfo,
                         '&&', lcov_exe,
                         '--remove',
                         covinfo,
                         os.path.join(self.environment.get_source_dir(), subproject_dir, '*'),
                         '--output-file', covinfo,
                         '&&', genhtml_exe,
                         '--prefix', self.environment.get_build_dir(),
                         '--output-directory', htmloutdir,
                         '--title', 'Code coverage',
                         '--legend',
                         '--show-details',
                         covinfo]
              elem.add_item('COMMAND', command)
              elem.add_item('DESC', 'Generating HTML coverage report.')
              elem.write(outfile)
          elif gcovr_exe and gcovr_new_rootdir:
              added_rule = True
              htmloutdir = os.path.join(self.environment.get_log_dir(), 'coveragereport')
              phony_elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-html', 'phony', os.path.join(htmloutdir, 'index.html'))
              phony_elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-html', outfile)
              elem = NinjaBuildElement(self.all_outputs, os.path.join(htmloutdir, 'index.html'), 'CUSTOM_COMMAND', '')
              command = [gcovr_exe, '--html', '--html-details', '-r', self.environment.get_build_dir(),
                         '-o', os.path.join(htmloutdir, 'index.html')]
              elem.add_item('COMMAND', command)
              elem.add_item('DESC', 'Generating HTML coverage report.')
              elem.write(outfile)
          if not added_rule:
              mlog.warning('coverage requested but neither gcovr nor lcov/genhtml found.')
  
      def generate_install(self, outfile):
          install_data_file = os.path.join(self.environment.get_scratch_dir(), 'install.dat')
          if self.environment.is_cross_build():
              bins = self.environment.cross_info.config['binaries']
              if 'strip' not in bins:
                  mlog.warning('Cross file does not specify strip binary, result will not be stripped.')
                  strip_bin = None
              else:
                  strip_bin = mesonlib.stringlistify(bins['strip'])
          else:
              strip_bin = self.environment.native_strip_bin
          d = InstallData(self.environment.get_source_dir(),
                          self.environment.get_build_dir(),
                          self.environment.get_prefix(),
                          strip_bin, self.environment.get_build_command() + ['introspect'])
          elem = NinjaBuildElement(self.all_outputs, 'meson-install', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_dep('all')
          elem.add_item('DESC', 'Installing files.')
          elem.add_item('COMMAND', self.environment.get_build_command() + ['--internal', 'install', install_data_file])
          elem.add_item('pool', 'console')
          self.generate_depmf_install(d)
          self.generate_target_install(d)
          self.generate_header_install(d)
          self.generate_man_install(d)
          self.generate_data_install(d)
          self.generate_custom_install_script(d)
          self.generate_subdir_install(d)
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-install', outfile)
  
          with open(install_data_file, 'wb') as ofile:
              pickle.dump(d, ofile)
  
      def generate_target_install(self, d):
          for t in self.build.get_targets().values():
              if not t.should_install():
                  continue
              # Find the installation directory.
              outdirs = t.get_custom_install_dir()
              custom_install_dir = False
              if outdirs[0] is not None and outdirs[0] is not True:
                  # Either the value is set, or is set to False which means
                  # we want this specific output out of many outputs to not
                  # be installed.
                  custom_install_dir = True
              elif isinstance(t, build.SharedModule):
                  outdirs[0] = self.environment.get_shared_module_dir()
              elif isinstance(t, build.SharedLibrary):
                  outdirs[0] = self.environment.get_shared_lib_dir()
              elif isinstance(t, build.StaticLibrary):
                  outdirs[0] = self.environment.get_static_lib_dir()
              elif isinstance(t, build.Executable):
                  outdirs[0] = self.environment.get_bindir()
              else:
                  assert(isinstance(t, build.BuildTarget))
                  # XXX: Add BuildTarget-specific install dir cases here
                  outdirs[0] = self.environment.get_libdir()
              # Sanity-check the outputs and install_dirs
              num_outdirs, num_out = len(outdirs), len(t.get_outputs())
              if num_outdirs != 1 and num_outdirs != num_out:
                  m = 'Target {!r} has {} outputs: {!r}, but only {} "install_dir"s were found.\n' \
                      "Pass 'false' for outputs that should not be installed and 'true' for\n" \
                      'using the default installation directory for an output.'
                  raise MesonException(m.format(t.name, num_out, t.get_outputs(), num_outdirs))
              # Install the target output(s)
              if isinstance(t, build.BuildTarget):
                  should_strip = self.get_option_for_target('strip', t)
                  # Install primary build output (library/executable/jar, etc)
                  # Done separately because of strip/aliases/rpath
                  if outdirs[0] is not False:
                      i = [self.get_target_filename(t), outdirs[0],
                           t.get_aliases(), should_strip, t.install_rpath]
                      d.targets.append(i)
                      # On toolchains/platforms that use an import library for
                      # linking (separate from the shared library with all the
                      # code), we need to install that too (dll.a/.lib).
                      if (isinstance(t, build.SharedLibrary) or isinstance(t, build.Executable)) and t.get_import_filename():
                          if custom_install_dir:
                              # If the DLL is installed into a custom directory,
                              # install the import library into the same place so
                              # it doesn't go into a surprising place
                              implib_install_dir = outdirs[0]
                          else:
                              implib_install_dir = self.environment.get_import_lib_dir()
                          # Install the import library.
                          i = [self.get_target_filename_for_linking(t),
                               implib_install_dir,
                               # It has no aliases, should not be stripped, and
                               # doesn't have an install_rpath
                               {}, False, '']
                          d.targets.append(i)
                  # Install secondary outputs. Only used for Vala right now.
                  if num_outdirs > 1:
                      for output, outdir in zip(t.get_outputs()[1:], outdirs[1:]):
                          # User requested that we not install this output
                          if outdir is False:
                              continue
                          f = os.path.join(self.get_target_dir(t), output)
                          d.targets.append([f, outdir, {}, False, None])
              elif isinstance(t, build.CustomTarget):
                  # If only one install_dir is specified, assume that all
                  # outputs will be installed into it. This is for
                  # backwards-compatibility and because it makes sense to
                  # avoid repetition since this is a common use-case.
                  #
                  # To selectively install only some outputs, pass `false` as
                  # the install_dir for the corresponding output by index
                  if num_outdirs == 1 and num_out > 1:
                      for output in t.get_outputs():
                          f = os.path.join(self.get_target_dir(t), output)
                          d.targets.append([f, outdirs[0], {}, False, None])
                  else:
                      for output, outdir in zip(t.get_outputs(), outdirs):
                          # User requested that we not install this output
                          if outdir is False:
                              continue
                          f = os.path.join(self.get_target_dir(t), output)
                          d.targets.append([f, outdir, {}, False, None])
  
      def generate_custom_install_script(self, d):
          result = []
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          for i in self.build.install_scripts:
              exe = i['exe']
              args = i['args']
              fixed_args = []
              for a in args:
                  a = a.replace('@SOURCE_ROOT@', srcdir)
                  a = a.replace('@BUILD_ROOT@', builddir)
                  fixed_args.append(a)
              result.append(build.RunScript(exe, fixed_args))
          d.install_scripts = result
  
      def generate_header_install(self, d):
          incroot = self.environment.get_includedir()
          headers = self.build.get_headers()
  
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          for h in headers:
              outdir = h.get_custom_install_dir()
              if outdir is None:
                  outdir = os.path.join(incroot, h.get_install_subdir())
              for f in h.get_sources():
                  if not isinstance(f, File):
                      msg = 'Invalid header type {!r} can\'t be installed'
                      raise MesonException(msg.format(f))
                  abspath = f.absolute_path(srcdir, builddir)
                  i = [abspath, outdir]
                  d.headers.append(i)
  
      def generate_man_install(self, d):
          manroot = self.environment.get_mandir()
          man = self.build.get_man()
          for m in man:
              for f in m.get_sources():
                  num = f.split('.')[-1]
                  subdir = m.get_custom_install_dir()
                  if subdir is None:
                      subdir = os.path.join(manroot, 'man' + num)
                  srcabs = f.absolute_path(self.environment.get_source_dir(), self.environment.get_build_dir())
                  dstabs = os.path.join(subdir, os.path.basename(f.fname) + '.gz')
                  i = [srcabs, dstabs]
                  d.man.append(i)
  
      def generate_data_install(self, d):
          data = self.build.get_data()
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          for de in data:
              assert(isinstance(de, build.Data))
              subdir = de.install_dir
              if not subdir:
                  subdir = os.path.join(self.environment.get_datadir(), self.interpreter.build.project_name)
              for f in de.sources:
                  assert(isinstance(f, mesonlib.File))
                  plain_f = os.path.basename(f.fname)
                  dstabs = os.path.join(subdir, plain_f)
                  i = [f.absolute_path(srcdir, builddir), dstabs, de.install_mode]
                  d.data.append(i)
  
      def generate_subdir_install(self, d):
          for sd in self.build.get_install_subdirs():
              src_dir = os.path.join(self.environment.get_source_dir(),
                                     sd.source_subdir,
                                     sd.installable_subdir).rstrip('/')
              dst_dir = os.path.join(self.environment.get_prefix(),
                                     sd.install_dir)
              if not sd.strip_directory:
                  dst_dir = os.path.join(dst_dir, os.path.basename(src_dir))
              d.install_subdirs.append([src_dir, dst_dir, sd.install_mode,
                                        sd.exclude])
  
      def generate_tests(self, outfile):
          self.serialize_tests()
          cmd = self.environment.get_build_command(True) + ['test', '--no-rebuild']
          if not self.environment.coredata.get_builtin_option('stdsplit'):
              cmd += ['--no-stdsplit']
          if self.environment.coredata.get_builtin_option('errorlogs'):
              cmd += ['--print-errorlogs']
          elem = NinjaBuildElement(self.all_outputs, 'meson-test', 'CUSTOM_COMMAND', ['all', 'PHONY'])
          elem.add_item('COMMAND', cmd)
          elem.add_item('DESC', 'Running all tests.')
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the above-defined meson-test target
          self.create_target_alias('meson-test', outfile)
  
          # And then benchmarks.
          cmd = self.environment.get_build_command(True) + [
              'test', '--benchmark', '--logbase',
              'benchmarklog', '--num-processes=1', '--no-rebuild']
          elem = NinjaBuildElement(self.all_outputs, 'meson-benchmark', 'CUSTOM_COMMAND', ['all', 'PHONY'])
          elem.add_item('COMMAND', cmd)
          elem.add_item('DESC', 'Running benchmark suite.')
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the above-defined meson-benchmark target
          self.create_target_alias('meson-benchmark', outfile)
  
      def generate_rules(self, outfile):
          outfile.write('# Rules for compiling.\n\n')
          self.generate_compile_rules(outfile)
          outfile.write('# Rules for linking.\n\n')
          num_pools = self.environment.coredata.backend_options['backend_max_links'].value
          if num_pools > 0:
              outfile.write('''pool link_pool
    depth = %d
  
  ''' % num_pools)
          if self.environment.is_cross_build():
              self.generate_static_link_rules(True, outfile)
          self.generate_static_link_rules(False, outfile)
          self.generate_dynamic_link_rules(outfile)
          outfile.write('# Other rules\n\n')
          outfile.write('rule CUSTOM_COMMAND\n')
          outfile.write(' command = $COMMAND\n')
          outfile.write(' description = $DESC\n')
          outfile.write(' restat = 1\n\n')
          # Ninja errors out if you have deps = gcc but no depfile, so we must
          # have two rules for custom commands.
          outfile.write('rule CUSTOM_COMMAND_DEP\n')
          outfile.write(' command = $COMMAND\n')
          outfile.write(' description = $DESC\n')
          outfile.write(' deps = gcc\n')
          outfile.write(' depfile = $DEPFILE\n')
          outfile.write(' restat = 1\n\n')
          outfile.write('rule REGENERATE_BUILD\n')
          c = [ninja_quote(quote_func(x)) for x in self.environment.get_build_command()] + \
              ['--internal',
               'regenerate',
               ninja_quote(quote_func(self.environment.get_source_dir())),
               ninja_quote(quote_func(self.environment.get_build_dir()))]
          outfile.write(" command = " + ' '.join(c) + ' --backend ninja\n')
          outfile.write(' description = Regenerating build files.\n')
          outfile.write(' generator = 1\n\n')
          outfile.write('\n')
  
      def generate_phony(self, outfile):
          outfile.write('# Phony build target, always out of date\n')
          outfile.write('build PHONY: phony\n')
          outfile.write('\n')
  
      def generate_jar_target(self, target, outfile):
          fname = target.get_filename()
          outname_rel = os.path.join(self.get_target_dir(target), fname)
          src_list = target.get_sources()
          class_list = []
          compiler = target.compilers['java']
          c = 'c'
          m = ''
          e = ''
          f = 'f'
          main_class = target.get_main_class()
          if main_class != '':
              e = 'e'
          for src in src_list:
              plain_class_path = self.generate_single_java_compile(src, target, compiler, outfile)
              class_list.append(plain_class_path)
          class_dep_list = [os.path.join(self.get_target_private_dir(target), i) for i in class_list]
          jar_rule = 'java_LINKER'
          commands = [c + m + e + f]
          if e != '':
              commands.append(main_class)
          commands.append(self.get_target_filename(target))
          # Java compilation can produce an arbitrary number of output
          # class files for a single source file. Thus tell jar to just
          # grab everything in the final package.
          commands += ['-C', self.get_target_private_dir(target), '.']
          elem = NinjaBuildElement(self.all_outputs, outname_rel, jar_rule, [])
          elem.add_dep(class_dep_list)
          elem.add_item('ARGS', commands)
          elem.write(outfile)
  
      def generate_cs_resource_tasks(self, target, outfile):
          args = []
          deps = []
          for r in target.resources:
              rel_sourcefile = os.path.join(self.build_to_src, target.subdir, r)
              if r.endswith('.resources'):
                  a = '-resource:' + rel_sourcefile
              elif r.endswith('.txt') or r.endswith('.resx'):
                  ofilebase = os.path.splitext(os.path.basename(r))[0] + '.resources'
                  ofilename = os.path.join(self.get_target_private_dir(target), ofilebase)
                  elem = NinjaBuildElement(self.all_outputs, ofilename, "CUSTOM_COMMAND", rel_sourcefile)
                  elem.add_item('COMMAND', ['resgen', rel_sourcefile, ofilename])
                  elem.add_item('DESC', 'Compiling resource %s.' % rel_sourcefile)
                  elem.write(outfile)
                  deps.append(ofilename)
                  a = '-resource:' + ofilename
              else:
                  raise InvalidArguments('Unknown resource file %s.' % r)
              args.append(a)
          return args, deps
  
      def generate_cs_target(self, target, outfile):
          buildtype = self.get_option_for_target('buildtype', target)
          fname = target.get_filename()
          outname_rel = os.path.join(self.get_target_dir(target), fname)
          src_list = target.get_sources()
          compiler = target.compilers['cs']
          rel_srcs = [os.path.normpath(s.rel_to_builddir(self.build_to_src)) for s in src_list]
          deps = []
          commands = CompilerArgs(compiler, target.extra_args.get('cs', []))
          commands += compiler.get_buildtype_args(buildtype)
          if isinstance(target, build.Executable):
              commands.append('-target:exe')
          elif isinstance(target, build.SharedLibrary):
              commands.append('-target:library')
          else:
              raise MesonException('Unknown C# target type.')
          (resource_args, resource_deps) = self.generate_cs_resource_tasks(target, outfile)
          commands += resource_args
          deps += resource_deps
          commands += compiler.get_output_args(outname_rel)
          for l in target.link_targets:
              lname = os.path.join(self.get_target_dir(l), l.get_filename())
              commands += compiler.get_link_args(lname)
              deps.append(lname)
          if '-g' in commands:
              outputs = [outname_rel, outname_rel + '.mdb']
          else:
              outputs = [outname_rel]
          generated_sources = self.get_target_generated_sources(target)
          for rel_src in generated_sources.keys():
              dirpart, fnamepart = os.path.split(rel_src)
              if rel_src.lower().endswith('.cs'):
                  rel_srcs.append(os.path.normpath(rel_src))
              deps.append(os.path.normpath(rel_src))
  
          for dep in target.get_external_deps():
              commands.extend_direct(dep.get_link_args())
          commands += self.build.get_project_args(compiler, target.subproject)
          commands += self.build.get_global_args(compiler)
  
          elem = NinjaBuildElement(self.all_outputs, outputs, 'cs_COMPILER', rel_srcs)
          elem.add_dep(deps)
          elem.add_item('ARGS', commands)
          elem.write(outfile)
  
          self.generate_generator_list_rules(target, outfile)
  
      def generate_single_java_compile(self, src, target, compiler, outfile):
          args = []
          args += compiler.get_buildtype_args(self.get_option_for_target('buildtype', target))
          args += self.build.get_global_args(compiler)
          args += self.build.get_project_args(compiler, target.subproject)
          args += target.get_java_args()
          args += compiler.get_output_args(self.get_target_private_dir(target))
          for i in target.include_dirs:
              for idir in i.get_incdirs():
                  args += ['-sourcepath', os.path.join(self.build_to_src, i.curdir, idir)]
          rel_src = src.rel_to_builddir(self.build_to_src)
          plain_class_path = src.fname[:-4] + 'class'
          rel_obj = os.path.join(self.get_target_private_dir(target), plain_class_path)
          element = NinjaBuildElement(self.all_outputs, rel_obj, compiler.get_language() + '_COMPILER', rel_src)
          element.add_item('ARGS', args)
          element.write(outfile)
          return plain_class_path
  
      def generate_java_link(self, outfile):
          rule = 'rule java_LINKER\n'
          command = ' command = jar $ARGS\n'
          description = ' description = Creating JAR $out.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def determine_dep_vapis(self, target):
          """
          Peek into the sources of BuildTargets we're linking with, and if any of
          them was built with Vala, assume that it also generated a .vapi file of
          the same name as the BuildTarget and return the path to it relative to
          the build directory.
          """
          result = OrderedSet()
          for dep in itertools.chain(target.link_targets, target.link_whole_targets):
              for i in dep.sources:
                  if hasattr(i, 'fname'):
                      i = i.fname
                  if i.endswith('vala'):
                      vapiname = dep.vala_vapi
                      fullname = os.path.join(self.get_target_dir(dep), vapiname)
                      result.add(fullname)
                      break
          return list(result)
  
      def split_vala_sources(self, t):
          """
          Splits the target's sources into .vala, .gs, .vapi, and other sources.
          Handles both pre-existing and generated sources.
  
          Returns a tuple (vala, vapi, others) each of which is a dictionary with
          the keys being the path to the file (relative to the build directory)
          and the value being the object that generated or represents the file.
          """
          vala = OrderedDict()
          vapi = OrderedDict()
          others = OrderedDict()
          othersgen = OrderedDict()
          # Split pre-existing sources
          for s in t.get_sources():
              # BuildTarget sources are always mesonlib.File files which are
              # either in the source root, or generated with configure_file and
              # in the build root
              if not isinstance(s, File):
                  msg = 'All sources in target {!r} must be of type ' \
                        'mesonlib.File, not {!r}'.format(t, s)
                  raise InvalidArguments(msg)
              f = s.rel_to_builddir(self.build_to_src)
              if s.endswith(('.vala', '.gs')):
                  srctype = vala
              elif s.endswith('.vapi'):
                  srctype = vapi
              else:
                  srctype = others
              srctype[f] = s
          # Split generated sources
          for gensrc in t.get_generated_sources():
              for s in gensrc.get_outputs():
                  f = self.get_target_generated_dir(t, gensrc, s)
                  if s.endswith(('.vala', '.gs')):
                      srctype = vala
                  elif s.endswith('.vapi'):
                      srctype = vapi
                  # Generated non-Vala (C/C++) sources. Won't be used for
                  # generating the Vala compile rule below.
                  else:
                      srctype = othersgen
                  # Duplicate outputs are disastrous
                  if f in srctype and srctype[f] is not gensrc:
                      msg = 'Duplicate output {0!r} from {1!r} {2!r}; ' \
                            'conflicts with {0!r} from {4!r} {3!r}' \
                            ''.format(f, type(gensrc).__name__, gensrc.name,
                                      srctype[f].name, type(srctype[f]).__name__)
                      raise InvalidArguments(msg)
                  # Store 'somefile.vala': GeneratedList (or CustomTarget)
                  srctype[f] = gensrc
          return vala, vapi, (others, othersgen)
  
      def generate_vala_compile(self, target, outfile):
          """Vala is compiled into C. Set up all necessary build steps here."""
          (vala_src, vapi_src, other_src) = self.split_vala_sources(target)
          extra_dep_files = []
          if not vala_src:
              msg = 'Vala library {!r} has no Vala or Genie source files.'
              raise InvalidArguments(msg.format(target.name))
  
          valac = target.compilers['vala']
          c_out_dir = self.get_target_private_dir(target)
          # C files generated by valac
          vala_c_src = []
          # Files generated by valac
          valac_outputs = []
          # All sources that are passed to valac on the commandline
          all_files = list(vapi_src.keys())
          # Passed as --basedir
          srcbasedir = os.path.join(self.build_to_src, target.get_subdir())
          for (vala_file, gensrc) in vala_src.items():
              all_files.append(vala_file)
              # Figure out where the Vala compiler will write the compiled C file
              #
              # If the Vala file is in a subdir of the build dir (in our case
              # because it was generated/built by something else), and is also
              # a subdir of --basedir (because the builddir is in the source
              # tree, and the target subdir is the source root), the subdir
              # components from the source root till the private builddir will be
              # duplicated inside the private builddir. Otherwise, just the
              # basename will be used.
              #
              # If the Vala file is outside the build directory, the paths from
              # the --basedir till the subdir will be duplicated inside the
              # private builddir.
              if isinstance(gensrc, (build.CustomTarget, build.GeneratedList)) or gensrc.is_built:
                  vala_c_file = os.path.splitext(os.path.basename(vala_file))[0] + '.c'
                  # Check if the vala file is in a subdir of --basedir
                  abs_srcbasedir = os.path.join(self.environment.get_source_dir(), target.get_subdir())
                  abs_vala_file = os.path.join(self.environment.get_build_dir(), vala_file)
                  if PurePath(os.path.commonpath((abs_srcbasedir, abs_vala_file))) == PurePath(abs_srcbasedir):
                      vala_c_subdir = PurePath(abs_vala_file).parent.relative_to(abs_srcbasedir)
                      vala_c_file = os.path.join(vala_c_subdir, vala_c_file)
              else:
                  path_to_target = os.path.join(self.build_to_src, target.get_subdir())
                  if vala_file.startswith(path_to_target):
                      vala_c_file = os.path.splitext(os.path.relpath(vala_file, path_to_target))[0] + '.c'
                  else:
                      vala_c_file = os.path.splitext(os.path.basename(vala_file))[0] + '.c'
              # All this will be placed inside the c_out_dir
              vala_c_file = os.path.join(c_out_dir, vala_c_file)
              vala_c_src.append(vala_c_file)
              valac_outputs.append(vala_c_file)
  
          args = self.generate_basic_compiler_args(target, valac)
          args += valac.get_colorout_args(self.environment.coredata.base_options.get('b_colorout').value)
          # Tell Valac to output everything in our private directory. Sadly this
          # means it will also preserve the directory components of Vala sources
          # found inside the build tree (generated sources).
          args += ['--directory', c_out_dir]
          args += ['--basedir', srcbasedir]
          if not isinstance(target, build.Executable):
              # Library name
              args += ['--library', target.name]
              # Outputted header
              hname = os.path.join(self.get_target_dir(target), target.vala_header)
              args += ['--header', hname]
              if self.is_unity(target):
                  # Without this the declarations will get duplicated in the .c
                  # files and cause a build failure when all of them are
                  # #include-d in one .c file.
                  # https://github.com/mesonbuild/meson/issues/1969
                  args += ['--use-header']
              valac_outputs.append(hname)
              # Outputted vapi file
              vapiname = os.path.join(self.get_target_dir(target), target.vala_vapi)
              # Force valac to write the vapi and gir files in the target build dir.
              # Without this, it will write it inside c_out_dir
              args += ['--vapi', os.path.join('..', target.vala_vapi)]
              valac_outputs.append(vapiname)
              target.outputs += [target.vala_header, target.vala_vapi]
              # Install header and vapi to default locations if user requests this
              if len(target.install_dir) > 1 and target.install_dir[1] is True:
                  target.install_dir[1] = self.environment.get_includedir()
              if len(target.install_dir) > 2 and target.install_dir[2] is True:
                  target.install_dir[2] = os.path.join(self.environment.get_datadir(), 'vala', 'vapi')
              # Generate GIR if requested
              if isinstance(target.vala_gir, str):
                  girname = os.path.join(self.get_target_dir(target), target.vala_gir)
                  args += ['--gir', os.path.join('..', target.vala_gir)]
                  valac_outputs.append(girname)
                  target.outputs.append(target.vala_gir)
                  # Install GIR to default location if requested by user
                  if len(target.install_dir) > 3 and target.install_dir[3] is True:
                      target.install_dir[3] = os.path.join(self.environment.get_datadir(), 'gir-1.0')
          # Detect gresources and add --gresources arguments for each
          for (gres, gensrc) in other_src[1].items():
              if isinstance(gensrc, modules.GResourceTarget):
                  gres_xml, = self.get_custom_target_sources(gensrc)
                  args += ['--gresources=' + gres_xml]
          extra_args = []
  
          for a in target.extra_args.get('vala', []):
              if isinstance(a, File):
                  relname = a.rel_to_builddir(self.build_to_src)
                  extra_dep_files.append(relname)
                  extra_args.append(relname)
              else:
                  extra_args.append(a)
          dependency_vapis = self.determine_dep_vapis(target)
          extra_dep_files += dependency_vapis
          args += extra_args
          element = NinjaBuildElement(self.all_outputs, valac_outputs,
                                      valac.get_language() + '_COMPILER',
                                      all_files + dependency_vapis)
          element.add_item('ARGS', args)
          element.add_dep(extra_dep_files)
          element.write(outfile)
          return other_src[0], other_src[1], vala_c_src
  
      def generate_rust_target(self, target, outfile):
          rustc = target.compilers['rust']
          relsrc = []
          for i in target.get_sources():
              if not rustc.can_compile(i):
                  raise InvalidArguments('Rust target %s contains a non-rust source file.' % target.get_basename())
              relsrc.append(i.rel_to_builddir(self.build_to_src))
          target_name = os.path.join(target.subdir, target.get_filename())
          args = ['--crate-type']
          if isinstance(target, build.Executable):
              cratetype = 'bin'
          elif hasattr(target, 'rust_crate_type'):
              cratetype = target.rust_crate_type
          elif isinstance(target, build.SharedLibrary):
              cratetype = 'dylib'
          elif isinstance(target, build.StaticLibrary):
              cratetype = 'rlib'
          else:
              raise InvalidArguments('Unknown target type for rustc.')
          args.append(cratetype)
          args += ['--crate-name', target.name]
          args += rustc.get_buildtype_args(self.get_option_for_target('buildtype', target))
          depfile = os.path.join(target.subdir, target.name + '.d')
          args += ['--emit', 'dep-info={}'.format(depfile), '--emit', 'link']
          args += target.get_extra_args('rust')
          args += ['-o', os.path.join(target.subdir, target.get_filename())]
          orderdeps = [os.path.join(t.subdir, t.get_filename()) for t in target.link_targets]
          linkdirs = OrderedDict()
          for d in target.link_targets:
              linkdirs[d.subdir] = True
              # specify `extern CRATE_NAME=OUTPUT_FILE` for each Rust
              # dependency, so that collisions with libraries in rustc's
              # sysroot don't cause ambiguity
              args += ['--extern', '{}={}'.format(d.name, os.path.join(d.subdir, d.filename))]
          for d in linkdirs.keys():
              if d == '':
                  d = '.'
              args += ['-L', d]
          has_shared_deps = False
          for dep in target.get_dependencies():
              if isinstance(dep, build.SharedLibrary):
                  has_shared_deps = True
          if isinstance(target, build.SharedLibrary) or has_shared_deps:
              # add prefer-dynamic if any of the Rust libraries we link
              # against are dynamic, otherwise we'll end up with
              # multiple implementations of crates
              args += ['-C', 'prefer-dynamic']
  
              # build the usual rpath arguments as well...
  
              # Set runtime-paths so we can run executables without needing to set
              # LD_LIBRARY_PATH, etc in the environment. Doesn't work on Windows.
              if has_path_sep(target.name):
                  # Target names really should not have slashes in them, but
                  # unfortunately we did not check for that and some downstream projects
                  # now have them. Once slashes are forbidden, remove this bit.
                  target_slashname_workaround_dir = os.path.join(os.path.dirname(target.name),
                                                                 self.get_target_dir(target))
              else:
                  target_slashname_workaround_dir = self.get_target_dir(target)
              rpath_args = rustc.build_rpath_args(self.environment.get_build_dir(),
                                                  target_slashname_workaround_dir,
                                                  self.determine_rpath_dirs(target),
                                                  target.build_rpath,
                                                  target.install_rpath)
              # ... but then add rustc's sysroot to account for rustup
              # installations
              for rpath_arg in rpath_args:
                  args += ['-C', 'link-arg=' + rpath_arg + ':' + os.path.join(rustc.get_sysroot(), 'lib')]
          crstr = ''
          if target.is_cross:
              crstr = '_CROSS'
          compiler_name = 'rust%s_COMPILER' % crstr
          element = NinjaBuildElement(self.all_outputs, target_name, compiler_name, relsrc)
          if len(orderdeps) > 0:
              element.add_orderdep(orderdeps)
          element.add_item('ARGS', args)
          element.add_item('targetdep', depfile)
          element.add_item('cratetype', cratetype)
          element.write(outfile)
          if isinstance(target, build.SharedLibrary):
              self.generate_shsym(outfile, target)
  
      def swift_module_file_name(self, target):
          return os.path.join(self.get_target_private_dir(target),
                              self.target_swift_modulename(target) + '.swiftmodule')
  
      def target_swift_modulename(self, target):
          return target.name
  
      def is_swift_target(self, target):
          for s in target.sources:
              if s.endswith('swift'):
                  return True
          return False
  
      def determine_swift_dep_modules(self, target):
          result = []
          for l in target.link_targets:
              if self.is_swift_target(l):
                  result.append(self.swift_module_file_name(l))
          return result
  
      def determine_swift_dep_dirs(self, target):
          result = []
          for l in target.link_targets:
              result.append(self.get_target_private_dir_abs(l))
          return result
  
      def get_swift_link_deps(self, target):
          result = []
          for l in target.link_targets:
              result.append(self.get_target_filename(l))
          return result
  
      def split_swift_generated_sources(self, target):
          all_srcs = self.get_target_generated_sources(target)
          srcs = []
          others = []
          for i in all_srcs:
              if i.endswith('.swift'):
                  srcs.append(i)
              else:
                  others.append(i)
          return srcs, others
  
      def generate_swift_target(self, target, outfile):
          module_name = self.target_swift_modulename(target)
          swiftc = target.compilers['swift']
          abssrc = []
          abs_headers = []
          header_imports = []
          for i in target.get_sources():
              if swiftc.can_compile(i):
                  relsrc = i.rel_to_builddir(self.build_to_src)
                  abss = os.path.normpath(os.path.join(self.environment.get_build_dir(), relsrc))
                  abssrc.append(abss)
              elif self.environment.is_header(i):
                  relh = i.rel_to_builddir(self.build_to_src)
                  absh = os.path.normpath(os.path.join(self.environment.get_build_dir(), relh))
                  abs_headers.append(absh)
                  header_imports += swiftc.get_header_import_args(absh)
              else:
                  raise InvalidArguments('Swift target %s contains a non-swift source file.' % target.get_basename())
          os.makedirs(self.get_target_private_dir_abs(target), exist_ok=True)
          compile_args = swiftc.get_compile_only_args()
          compile_args += swiftc.get_module_args(module_name)
          compile_args += self.build.get_project_args(swiftc, target.subproject)
          compile_args += self.build.get_global_args(swiftc)
          for i in reversed(target.get_include_dirs()):
              basedir = i.get_curdir()
              for d in i.get_incdirs():
                  if d not in ('', '.'):
                      expdir = os.path.join(basedir, d)
                  else:
                      expdir = basedir
                  srctreedir = os.path.normpath(os.path.join(self.environment.get_build_dir(), self.build_to_src, expdir))
                  sargs = swiftc.get_include_args(srctreedir)
                  compile_args += sargs
          link_args = swiftc.get_output_args(os.path.join(self.environment.get_build_dir(), self.get_target_filename(target)))
          link_args += self.build.get_project_link_args(swiftc, target.subproject)
          link_args += self.build.get_global_link_args(swiftc)
          rundir = self.get_target_private_dir(target)
          out_module_name = self.swift_module_file_name(target)
          in_module_files = self.determine_swift_dep_modules(target)
          abs_module_dirs = self.determine_swift_dep_dirs(target)
          module_includes = []
          for x in abs_module_dirs:
              module_includes += swiftc.get_include_args(x)
          link_deps = self.get_swift_link_deps(target)
          abs_link_deps = [os.path.join(self.environment.get_build_dir(), x) for x in link_deps]
          for d in target.link_targets:
              reldir = self.get_target_dir(d)
              if reldir == '':
                  reldir = '.'
              link_args += ['-L', os.path.normpath(os.path.join(self.environment.get_build_dir(), reldir))]
          (rel_generated, _) = self.split_swift_generated_sources(target)
          abs_generated = [os.path.join(self.environment.get_build_dir(), x) for x in rel_generated]
          # We need absolute paths because swiftc needs to be invoked in a subdir
          # and this is the easiest way about it.
          objects = [] # Relative to swift invocation dir
          rel_objects = [] # Relative to build.ninja
          for i in abssrc + abs_generated:
              base = os.path.basename(i)
              oname = os.path.splitext(base)[0] + '.o'
              objects.append(oname)
              rel_objects.append(os.path.join(self.get_target_private_dir(target), oname))
  
          # Swiftc does not seem to be able to emit objects and module files in one go.
          elem = NinjaBuildElement(self.all_outputs, rel_objects,
                                   'swift_COMPILER',
                                   abssrc)
          elem.add_dep(in_module_files + rel_generated)
          elem.add_dep(abs_headers)
          elem.add_item('ARGS', compile_args + header_imports + abs_generated + module_includes)
          elem.add_item('RUNDIR', rundir)
          elem.write(outfile)
          elem = NinjaBuildElement(self.all_outputs, out_module_name,
                                   'swift_COMPILER',
                                   abssrc)
          elem.add_dep(in_module_files + rel_generated)
          elem.add_item('ARGS', compile_args + abs_generated + module_includes + swiftc.get_mod_gen_args())
          elem.add_item('RUNDIR', rundir)
          elem.write(outfile)
          if isinstance(target, build.StaticLibrary):
              elem = self.generate_link(target, outfile, self.get_target_filename(target),
                                        rel_objects, self.build.static_linker)
              elem.write(outfile)
          elif isinstance(target, build.Executable):
              elem = NinjaBuildElement(self.all_outputs, self.get_target_filename(target), 'swift_COMPILER', [])
              elem.add_dep(rel_objects)
              elem.add_dep(link_deps)
              elem.add_item('ARGS', link_args + swiftc.get_std_exe_link_args() + objects + abs_link_deps)
              elem.add_item('RUNDIR', rundir)
              elem.write(outfile)
          else:
              raise MesonException('Swift supports only executable and static library targets.')
  
      def generate_static_link_rules(self, is_cross, outfile):
          num_pools = self.environment.coredata.backend_options['backend_max_links'].value
          if 'java' in self.build.compilers:
              if not is_cross:
                  self.generate_java_link(outfile)
          if is_cross:
              if self.environment.cross_info.need_cross_compiler():
                  static_linker = self.build.static_cross_linker
              else:
                  static_linker = self.build.static_linker
              crstr = '_CROSS'
          else:
              static_linker = self.build.static_linker
              crstr = ''
          if static_linker is None:
              return
          rule = 'rule STATIC%s_LINKER\n' % crstr
          # We don't use @file.rsp on Windows with ArLinker because llvm-ar and
          # gcc-ar blindly pass the --plugin argument to `ar` and you cannot pass
          # options as arguments while using the @file.rsp syntax.
          # See: https://github.com/mesonbuild/meson/issues/1646
          if mesonlib.is_windows() and not isinstance(static_linker, ArLinker):
              command_template = ''' command = {executable} @$out.rsp
   rspfile = $out.rsp
   rspfile_content = $LINK_ARGS {output_args} $in
  '''
          else:
              command_template = ' command = {executable} $LINK_ARGS {output_args} $in\n'
          cmdlist = []
          # FIXME: Must normalize file names with pathlib.Path before writing
          #        them out to fix this properly on Windows. See:
          # https://github.com/mesonbuild/meson/issues/1517
          # https://github.com/mesonbuild/meson/issues/1526
          if isinstance(static_linker, ArLinker) and not mesonlib.is_windows():
              # `ar` has no options to overwrite archives. It always appends,
              # which is never what we want. Delete an existing library first if
              # it exists. https://github.com/mesonbuild/meson/issues/1355
              cmdlist = [execute_wrapper, rmfile_prefix.format('$out')]
          cmdlist += static_linker.get_exelist()
          command = command_template.format(
              executable=' '.join(cmdlist),
              output_args=' '.join(static_linker.get_output_args('$out')))
          description = ' description = Linking static target $out.\n\n'
          outfile.write(rule)
          outfile.write(command)
          if num_pools > 0:
              outfile.write(' pool = link_pool\n')
          outfile.write(description)
  
      def generate_dynamic_link_rules(self, outfile):
          num_pools = self.environment.coredata.backend_options['backend_max_links'].value
          ctypes = [(self.build.compilers, False)]
          if self.environment.is_cross_build():
              if self.environment.cross_info.need_cross_compiler():
                  ctypes.append((self.build.cross_compilers, True))
              else:
                  # Native compiler masquerades as the cross compiler.
                  ctypes.append((self.build.compilers, True))
          else:
              ctypes.append((self.build.cross_compilers, True))
          for (complist, is_cross) in ctypes:
              for langname, compiler in complist.items():
                  if langname == 'java' \
                          or langname == 'vala' \
                          or langname == 'rust' \
                          or langname == 'cs':
                      continue
                  crstr = ''
                  cross_args = []
                  if is_cross:
                      crstr = '_CROSS'
                      try:
                          cross_args = self.environment.cross_info.config['properties'][langname + '_link_args']
                      except KeyError:
                          pass
                  rule = 'rule %s%s_LINKER\n' % (langname, crstr)
                  if mesonlib.is_windows():
                      command_template = ''' command = {executable} @$out.rsp
   rspfile = $out.rsp
   rspfile_content = $ARGS  {output_args} $in $LINK_ARGS {cross_args} $aliasing
  '''
                  else:
                      command_template = ' command = {executable} $ARGS {output_args} $in $LINK_ARGS {cross_args} $aliasing\n'
                  command = command_template.format(
                      executable=' '.join(compiler.get_linker_exelist()),
                      cross_args=' '.join(cross_args),
                      output_args=' '.join(compiler.get_linker_output_args('$out'))
                  )
                  description = ' description = Linking target $out.\n'
                  outfile.write(rule)
                  outfile.write(command)
                  if num_pools > 0:
                      outfile.write(' pool = link_pool\n')
                  outfile.write(description)
                  outfile.write('\n')
          outfile.write('\n')
          args = [ninja_quote(quote_func(x)) for x in self.environment.get_build_command()] + \
              ['--internal',
               'symbolextractor',
               '$in',
               '$out']
          symrule = 'rule SHSYM\n'
          symcmd = ' command = ' + ' '.join(args) + ' $CROSS\n'
          synstat = ' restat = 1\n'
          syndesc = ' description = Generating symbol file $out.\n'
          outfile.write(symrule)
          outfile.write(symcmd)
          outfile.write(synstat)
          outfile.write(syndesc)
          outfile.write('\n')
  
      def generate_java_compile_rule(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Java object $in.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_cs_compile_rule(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
  
          if mesonlib.is_windows():
              command = ''' command = {executable}  @$out.rsp
   rspfile = $out.rsp
   rspfile_content =  $ARGS  $in
  '''.format(executable=invoc)
          else:
              command = ' command = %s $ARGS $in\n' % invoc
  
          description = ' description = Compiling C Sharp target $out.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_vala_compile_rules(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Vala source $in.\n'
          restat = ' restat = 1\n' # ValaC does this always to take advantage of it.
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write(restat)
          outfile.write('\n')
  
      def generate_rust_compile_rules(self, compiler, outfile, is_cross):
          crstr = ''
          if is_cross:
              crstr = '_CROSS'
          rule = 'rule %s%s_COMPILER\n' % (compiler.get_language(), crstr)
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Rust source $in.\n'
          depfile = ' depfile = $targetdep\n'
  
          depstyle = ' deps = gcc\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write(depfile)
          outfile.write(depstyle)
          outfile.write('\n')
  
      def generate_swift_compile_rules(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          full_exe = [ninja_quote(x) for x in self.environment.get_build_command()] + [
              '--internal',
              'dirchanger',
              '$RUNDIR',
          ]
          invoc = (' '.join(full_exe) + ' ' +
                   ' '.join(ninja_quote(i) for i in compiler.get_exelist()))
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Swift source $in.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_fortran_dep_hack(self, outfile):
          if mesonlib.is_windows():
              cmd = 'cmd /C ""'
          else:
              cmd = 'true'
          template = '''# Workaround for these issues:
  # https://groups.google.com/forum/#!topic/ninja-build/j-2RfBIOd_8
  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47485
  rule FORTRAN_DEP_HACK
   command = %s
   description = Dep hack
   restat = 1
  
  '''
          outfile.write(template % cmd)
  
      def generate_llvm_ir_compile_rule(self, compiler, is_cross, outfile):
          if getattr(self, 'created_llvm_ir_rule', False):
              return
          rule = 'rule llvm_ir{}_COMPILER\n'.format('_CROSS' if is_cross else '')
          if mesonlib.is_windows():
              command_template = ' command = {executable} @$out.rsp\n' \
                                 ' rspfile = $out.rsp\n' \
                                 ' rspfile_content = {cross_args} $ARGS {output_args} {compile_only_args} $in\n'
          else:
              command_template = ' command = {executable} {cross_args} $ARGS {output_args} {compile_only_args} $in\n'
          command = command_template.format(
              executable=' '.join([ninja_quote(i) for i in compiler.get_exelist()]),
              cross_args=' '.join(self.get_cross_info_lang_args(compiler.language, is_cross)),
              output_args=' '.join(compiler.get_output_args('$out')),
              compile_only_args=' '.join(compiler.get_compile_only_args())
          )
          description = ' description = Compiling LLVM IR object $in.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
          self.created_llvm_ir_rule = True
  
      def get_cross_info_lang_args(self, lang, is_cross):
          if is_cross:
              try:
                  return self.environment.cross_info.config['properties'][lang + '_args']
              except KeyError:
                  pass
          return []
  
      def generate_compile_rule_for(self, langname, compiler, is_cross, outfile):
          if langname == 'java':
              if not is_cross:
                  self.generate_java_compile_rule(compiler, outfile)
              return
          if langname == 'cs':
              if not is_cross:
                  self.generate_cs_compile_rule(compiler, outfile)
              return
          if langname == 'vala':
              if not is_cross:
                  self.generate_vala_compile_rules(compiler, outfile)
              return
          if langname == 'rust':
              self.generate_rust_compile_rules(compiler, outfile, is_cross)
              return
          if langname == 'swift':
              if not is_cross:
                  self.generate_swift_compile_rules(compiler, outfile)
              return
          if langname == 'fortran':
              self.generate_fortran_dep_hack(outfile)
          if is_cross:
              crstr = '_CROSS'
          else:
              crstr = ''
          rule = 'rule %s%s_COMPILER\n' % (langname, crstr)
          depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
          quoted_depargs = []
          for d in depargs:
              if d != '$out' and d != '$in':
                  d = quote_func(d)
              quoted_depargs.append(d)
          cross_args = self.get_cross_info_lang_args(langname, is_cross)
          if mesonlib.is_windows():
              command_template = ''' command = {executable} @$out.rsp
   rspfile = $out.rsp
   rspfile_content = {cross_args} $ARGS {dep_args} {output_args} {compile_only_args} $in
  '''
          else:
              command_template = ' command = {executable} {cross_args} $ARGS {dep_args} {output_args} {compile_only_args} $in\n'
          command = command_template.format(
              executable=' '.join([ninja_quote(i) for i in compiler.get_exelist()]),
              cross_args=' '.join(cross_args),
              dep_args=' '.join(quoted_depargs),
              output_args=' '.join(compiler.get_output_args('$out')),
              compile_only_args=' '.join(compiler.get_compile_only_args())
          )
          description = ' description = Compiling %s object $out.\n' % compiler.get_display_language()
          if compiler.get_id() == 'msvc':
              deps = ' deps = msvc\n'
          else:
              deps = ' deps = gcc\n'
              deps += ' depfile = $DEPFILE\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(deps)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_pch_rule_for(self, langname, compiler, is_cross, outfile):
          if langname != 'c' and langname != 'cpp':
              return
          if is_cross:
              crstr = '_CROSS'
          else:
              crstr = ''
          rule = 'rule %s%s_PCH\n' % (langname, crstr)
          depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
          cross_args = []
          if is_cross:
              try:
                  cross_args = self.environment.cross_info.config['properties'][langname + '_args']
              except KeyError:
                  pass
  
          quoted_depargs = []
          for d in depargs:
              if d != '$out' and d != '$in':
                  d = quote_func(d)
              quoted_depargs.append(d)
          if compiler.get_id() == 'msvc':
              output = ''
          else:
              output = ' '.join(compiler.get_output_args('$out'))
          command = " command = {executable} {cross_args} $ARGS {dep_args} {output_args} {compile_only_args} $in\n".format(
              executable=' '.join(compiler.get_exelist()),
              cross_args=' '.join(cross_args),
              dep_args=' '.join(quoted_depargs),
              output_args=output,
              compile_only_args=' '.join(compiler.get_compile_only_args())
          )
          description = ' description = Precompiling header %s.\n' % '$in'
          if compiler.get_id() == 'msvc':
              deps = ' deps = msvc\n'
          else:
              deps = ' deps = gcc\n'
              deps += ' depfile = $DEPFILE\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(deps)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_compile_rules(self, outfile):
          for langname, compiler in self.build.compilers.items():
              if compiler.get_id() == 'clang':
                  self.generate_llvm_ir_compile_rule(compiler, False, outfile)
              self.generate_compile_rule_for(langname, compiler, False, outfile)
              self.generate_pch_rule_for(langname, compiler, False, outfile)
          if self.environment.is_cross_build():
              # In case we are going a target-only build, make the native compilers
              # masquerade as cross compilers.
              if self.environment.cross_info.need_cross_compiler():
                  cclist = self.build.cross_compilers
              else:
                  cclist = self.build.compilers
              for langname, compiler in cclist.items():
                  if compiler.get_id() == 'clang':
                      self.generate_llvm_ir_compile_rule(compiler, True, outfile)
                  self.generate_compile_rule_for(langname, compiler, True, outfile)
                  self.generate_pch_rule_for(langname, compiler, True, outfile)
          outfile.write('\n')
  
      def generate_generator_list_rules(self, target, outfile):
          # CustomTargets have already written their rules and
          # CustomTargetIndexes don't actually get generated, so write rules for
          # GeneratedLists here
          for genlist in target.get_generated_sources():
              if isinstance(genlist, (build.CustomTarget, build.CustomTargetIndex)):
                  continue
              self.generate_genlist_for_target(genlist, target, outfile)
  
      def replace_paths(self, target, args, override_subdir=None):
          if override_subdir:
              source_target_dir = os.path.join(self.build_to_src, override_subdir)
          else:
              source_target_dir = self.get_target_source_dir(target)
          relout = self.get_target_private_dir(target)
          args = [x.replace("@SOURCE_DIR@", self.build_to_src).replace("@BUILD_DIR@", relout)
                  for x in args]
          args = [x.replace("@CURRENT_SOURCE_DIR@", source_target_dir) for x in args]
          args = [x.replace("@SOURCE_ROOT@", self.build_to_src).replace("@BUILD_ROOT@", '.')
                  for x in args]
          args = [x.replace('\\', '/') for x in args]
          return args
  
      def generate_genlist_for_target(self, genlist, target, outfile):
          generator = genlist.get_generator()
          subdir = genlist.subdir
          exe = generator.get_exe()
          exe_arr = self.exe_object_to_cmd_array(exe)
          infilelist = genlist.get_inputs()
          outfilelist = genlist.get_outputs()
          extra_dependencies = [os.path.join(self.build_to_src, i) for i in genlist.extra_depends]
          for i in range(len(infilelist)):
              if len(generator.outputs) == 1:
                  sole_output = os.path.join(self.get_target_private_dir(target), outfilelist[i])
              else:
                  sole_output = ''
              curfile = infilelist[i]
              infilename = curfile.rel_to_builddir(self.build_to_src)
              base_args = generator.get_arglist(infilename)
              outfiles = genlist.get_outputs_for(curfile)
              outfiles = [os.path.join(self.get_target_private_dir(target), of) for of in outfiles]
              if generator.depfile is None:
                  rulename = 'CUSTOM_COMMAND'
                  args = base_args
              else:
                  rulename = 'CUSTOM_COMMAND_DEP'
                  depfilename = generator.get_dep_outname(infilename)
                  depfile = os.path.join(self.get_target_private_dir(target), depfilename)
                  args = [x.replace('@DEPFILE@', depfile) for x in base_args]
              args = [x.replace("@INPUT@", infilename).replace('@OUTPUT@', sole_output)
                      for x in args]
              args = self.replace_outputs(args, self.get_target_private_dir(target), outfilelist)
              # We have consumed output files, so drop them from the list of remaining outputs.
              if sole_output == '':
                  outfilelist = outfilelist[len(generator.outputs):]
              args = self.replace_paths(target, args, override_subdir=subdir)
              cmdlist = exe_arr + self.replace_extra_args(args, genlist)
              if generator.capture:
                  exe_data = self.serialize_executable(
                      cmdlist[0],
                      cmdlist[1:],
                      self.environment.get_build_dir(),
                      capture=outfiles[0]
                  )
                  cmd = self.environment.get_build_command() + ['--internal', 'exe', exe_data]
                  abs_pdir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(target))
                  os.makedirs(abs_pdir, exist_ok=True)
              else:
                  cmd = cmdlist
  
              elem = NinjaBuildElement(self.all_outputs, outfiles, rulename, infilename)
              if generator.depfile is not None:
                  elem.add_item('DEPFILE', depfile)
              if len(extra_dependencies) > 0:
                  elem.add_dep(extra_dependencies)
              elem.add_item('DESC', 'Generating {!r}.'.format(sole_output))
              if isinstance(exe, build.BuildTarget):
                  elem.add_dep(self.get_target_filename(exe))
              elem.add_item('COMMAND', cmd)
              elem.write(outfile)
  
      def scan_fortran_module_outputs(self, target):
          compiler = None
          for lang, c in self.build.compilers.items():
              if lang == 'fortran':
                  compiler = c
                  break
          if compiler is None:
              self.fortran_deps[target.get_basename()] = {}
              return
          modre = re.compile(r"\s*module\s+(\w+)", re.IGNORECASE)
          module_files = {}
          for s in target.get_sources():
              # FIXME, does not work for Fortran sources generated by
              # custom_target() and generator() as those are run after
              # the configuration (configure_file() is OK)
              if not compiler.can_compile(s):
                  continue
              filename = s.absolute_path(self.environment.get_source_dir(),
                                         self.environment.get_build_dir())
              # Some Fortran editors save in weird encodings,
              # but all the parts we care about are in ASCII.
              with open(filename, errors='ignore') as f:
                  for line in f:
                      modmatch = modre.match(line)
                      if modmatch is not None:
                          modname = modmatch.group(1).lower()
                          if modname == 'procedure':
                              # MODULE PROCEDURE construct
                              continue
                          if modname in module_files:
                              raise InvalidArguments(
                                  'Namespace collision: module %s defined in '
                                  'two files %s and %s.' %
                                  (modname, module_files[modname], s))
                          module_files[modname] = s
          self.fortran_deps[target.get_basename()] = module_files
  
      def get_fortran_deps(self, compiler, src, target):
          mod_files = []
          usere = re.compile(r"\s*use\s+(\w+)", re.IGNORECASE)
          dirname = self.get_target_private_dir(target)
          tdeps = self.fortran_deps[target.get_basename()]
          with open(src) as f:
              for line in f:
                  usematch = usere.match(line)
                  if usematch is not None:
                      usename = usematch.group(1).lower()
                      if usename not in tdeps:
                          # The module is not provided by any source file. This
                          # is due to:
                          #   a) missing file/typo/etc
                          #   b) using a module provided by the compiler, such as
                          #      OpenMP
                          # There's no easy way to tell which is which (that I
                          # know of) so just ignore this and go on. Ideally we
                          # would print a warning message to the user but this is
                          # a common occurrence, which would lead to lots of
                          # distracting noise.
                          continue
                      mod_source_file = tdeps[usename]
                      # Check if a source uses a module it exports itself.
                      # Potential bug if multiple targets have a file with
                      # the same name.
                      if mod_source_file.fname == os.path.basename(src):
                          continue
                      mod_name = compiler.module_name_to_filename(
                          usematch.group(1))
                      mod_files.append(os.path.join(dirname, mod_name))
          return mod_files
  
      def get_cross_stdlib_args(self, target, compiler):
          if not target.is_cross:
              return []
          if not self.environment.cross_info.has_stdlib(compiler.language):
              return []
          return compiler.get_no_stdinc_args()
  
      def get_compile_debugfile_args(self, compiler, target, objfile):
          if compiler.id != 'msvc':
              return []
          # The way MSVC uses PDB files is documented exactly nowhere so
          # the following is what we have been able to decipher via
          # reverse engineering.
          #
          # Each object file gets the path of its PDB file written
          # inside it.  This can be either the final PDB (for, say,
          # foo.exe) or an object pdb (for foo.obj). If the former, then
          # each compilation step locks the pdb file for writing, which
          # is a bottleneck and object files from one target can not be
          # used in a different target. The latter seems to be the
          # sensible one (and what Unix does) but there is a catch.  If
          # you try to use precompiled headers MSVC will error out
          # because both source and pch pdbs go in the same file and
          # they must be the same.
          #
          # This means:
          #
          # - pch files must be compiled anew for every object file (negating
          #   the entire point of having them in the first place)
          # - when using pch, output must go to the target pdb
          #
          # Since both of these are broken in some way, use the one that
          # works for each target. This unfortunately means that you
          # can't combine pch and object extraction in a single target.
          #
          # PDB files also lead to filename collisions. A target foo.exe
          # has a corresponding foo.pdb. A shared library foo.dll _also_
          # has pdb file called foo.pdb. So will a static library
          # foo.lib, which clobbers both foo.pdb _and_ the dll file's
          # export library called foo.lib (by default, currently we name
          # them libfoo.a to avoidt this issue). You can give the files
          # unique names such as foo_exe.pdb but VC also generates a
          # bunch of other files which take their names from the target
          # basename (i.e. "foo") and stomp on each other.
          #
          # CMake solves this problem by doing two things. First of all
          # static libraries do not generate pdb files at
          # all. Presumably you don't need them and VC is smart enough
          # to look up the original data when linking (speculation, not
          # tested). The second solution is that you can only have
          # target named "foo" as an exe, shared lib _or_ static
          # lib. This makes filename collisions not happen. The downside
          # is that you can't have an executable foo that uses a shared
          # library libfoo.so, which is a common idiom on Unix.
          #
          # If you feel that the above is completely wrong and all of
          # this is actually doable, please send patches.
  
          if target.has_pch():
              tfilename = self.get_target_filename_abs(target)
              return compiler.get_compile_debugfile_args(tfilename, pch=True)
          else:
              return compiler.get_compile_debugfile_args(objfile, pch=False)
  
      def get_link_debugfile_args(self, linker, target, outname):
          return linker.get_link_debugfile_args(outname)
  
      def generate_llvm_ir_compile(self, target, outfile, src):
          compiler = get_compiler_for_source(target.compilers.values(), src)
          commands = CompilerArgs(compiler)
          # Compiler args for compiling this target
          commands += compilers.get_base_compile_args(self.environment.coredata.base_options,
                                                      compiler)
          if isinstance(src, File):
              if src.is_built:
                  src_filename = os.path.join(src.subdir, src.fname)
              else:
                  src_filename = src.fname
          elif os.path.isabs(src):
              src_filename = os.path.basename(src)
          else:
              src_filename = src
          obj_basename = src_filename.replace('/', '_').replace('\\', '_')
          rel_obj = os.path.join(self.get_target_private_dir(target), obj_basename)
          rel_obj += '.' + self.environment.get_object_suffix()
          commands += self.get_compile_debugfile_args(compiler, target, rel_obj)
          if isinstance(src, File) and src.is_built:
              rel_src = src.fname
          elif isinstance(src, File):
              rel_src = src.rel_to_builddir(self.build_to_src)
          else:
              raise InvalidArguments('Invalid source type: {!r}'.format(src))
          # Write the Ninja build command
          compiler_name = 'llvm_ir{}_COMPILER'.format('_CROSS' if target.is_cross else '')
          element = NinjaBuildElement(self.all_outputs, rel_obj, compiler_name, rel_src)
          # Convert from GCC-style link argument naming to the naming used by the
          # current compiler.
          commands = commands.to_native()
          element.add_item('ARGS', commands)
          element.write(outfile)
          return rel_obj
  
      def get_source_dir_include_args(self, target, compiler):
          curdir = target.get_subdir()
          tmppath = os.path.normpath(os.path.join(self.build_to_src, curdir))
          return compiler.get_include_args(tmppath, False)
  
      def get_build_dir_include_args(self, target, compiler):
          curdir = target.get_subdir()
          if curdir == '':
              curdir = '.'
          return compiler.get_include_args(curdir, False)
  
      def get_custom_target_dir_include_args(self, target, compiler):
          custom_target_include_dirs = []
          for i in target.get_generated_sources():
              # Generator output goes into the target private dir which is
              # already in the include paths list. Only custom targets have their
              # own target build dir.
              if not isinstance(i, (build.CustomTarget, build.CustomTargetIndex)):
                  continue
              idir = self.get_target_dir(i)
              if idir not in custom_target_include_dirs:
                  custom_target_include_dirs.append(idir)
          incs = []
          for i in custom_target_include_dirs:
              incs += compiler.get_include_args(i, False)
          return incs
  
      def _generate_single_compile(self, target, compiler, is_generated=False):
          base_proxy = backends.OptionOverrideProxy(target.option_overrides,
                                                    self.environment.coredata.base_options)
          # Create an empty commands list, and start adding arguments from
          # various sources in the order in which they must override each other
          commands = CompilerArgs(compiler)
          # Add compiler args for compiling this target derived from 'base' build
          # options passed on the command-line, in default_options, etc.
          # These have the lowest priority.
          commands += compilers.get_base_compile_args(base_proxy,
                                                      compiler)
          # The code generated by valac is usually crap and has tons of unused
          # variables and such, so disable warnings for Vala C sources.
          no_warn_args = (is_generated == 'vala')
          # Add compiler args and include paths from several sources; defaults,
          # build options, external dependencies, etc.
          commands += self.generate_basic_compiler_args(target, compiler, no_warn_args)
          # Add custom target dirs as includes automatically, but before
          # target-specific include directories.
          # XXX: Not sure if anyone actually uses this? It can cause problems in
          # situations which increase the likelihood for a header name collision,
          # such as in subprojects.
          commands += self.get_custom_target_dir_include_args(target, compiler)
          # Add include dirs from the `include_directories:` kwarg on the target
          # and from `include_directories:` of internal deps of the target.
          #
          # Target include dirs should override internal deps include dirs.
          # This is handled in BuildTarget.process_kwargs()
          #
          # Include dirs from internal deps should override include dirs from
          # external deps and must maintain the order in which they are specified.
          # Hence, we must reverse the list so that the order is preserved.
          for i in reversed(target.get_include_dirs()):
              basedir = i.get_curdir()
              for d in i.get_incdirs():
                  # Avoid superfluous '/.' at the end of paths when d is '.'
                  if d not in ('', '.'):
                      expdir = os.path.join(basedir, d)
                  else:
                      expdir = basedir
                  srctreedir = os.path.join(self.build_to_src, expdir)
                  # Add source subdir first so that the build subdir overrides it
                  sargs = compiler.get_include_args(srctreedir, i.is_system)
                  commands += sargs
                  # There may be include dirs where a build directory has not been
                  # created for some source dir. For example if someone does this:
                  #
                  # inc = include_directories('foo/bar/baz')
                  #
                  # But never subdir()s into the actual dir.
                  if os.path.isdir(os.path.join(self.environment.get_build_dir(), expdir)):
                      bargs = compiler.get_include_args(expdir, i.is_system)
                  else:
                      bargs = []
                  commands += bargs
              for d in i.get_extra_build_dirs():
                  commands += compiler.get_include_args(d, i.is_system)
          # Add per-target compile args, f.ex, `c_args : ['-DFOO']`. We set these
          # near the end since these are supposed to override everything else.
          commands += self.escape_extra_args(compiler,
                                             target.get_extra_args(compiler.get_language()))
          # Add source dir and build dir. Project-specific and target-specific
          # include paths must override per-target compile args, include paths
          # from external dependencies, internal dependencies, and from
          # per-target `include_directories:`
          #
          # We prefer headers in the build dir over the source dir since, for
          # instance, the user might have an srcdir == builddir Autotools build
          # in their source tree. Many projects that are moving to Meson have
          # both Meson and Autotools in parallel as part of the transition.
          if target.implicit_include_directories:
              commands += self.get_source_dir_include_args(target, compiler)
          if target.implicit_include_directories:
              commands += self.get_build_dir_include_args(target, compiler)
          # Finally add the private dir for the target to the include path. This
          # must override everything else and must be the final path added.
          commands += compiler.get_include_args(self.get_target_private_dir(target), False)
          return commands
  
      def generate_single_compile(self, target, outfile, src, is_generated=False, header_deps=[], order_deps=[]):
          """
          Compiles C/C++, ObjC/ObjC++, Fortran, and D sources
          """
          if isinstance(src, str) and src.endswith('.h'):
              raise AssertionError('BUG: sources should not contain headers {!r}'.format(src))
  
          compiler = get_compiler_for_source(target.compilers.values(), src)
          key = (target, compiler, is_generated)
          if key in self.target_arg_cache:
              commands = self.target_arg_cache[key]
          else:
              commands = self._generate_single_compile(target, compiler, is_generated)
              self.target_arg_cache[key] = commands
          commands = CompilerArgs(commands.compiler, commands)
  
          build_dir = self.environment.get_build_dir()
          if isinstance(src, File):
              rel_src = src.rel_to_builddir(self.build_to_src)
              if os.path.isabs(rel_src):
                  # Source files may not be from the source directory if they originate in source-only libraries,
                  # so we can't assert that the absolute path is anywhere in particular.
                  if src.is_built:
                      assert rel_src.startswith(build_dir)
                      rel_src = rel_src[len(build_dir) + 1:]
          elif is_generated:
              raise AssertionError('BUG: broken generated source file handling for {!r}'.format(src))
          else:
              raise InvalidArguments('Invalid source type: {!r}'.format(src))
          obj_basename = self.object_filename_from_source(target, src, self.is_unity(target))
          rel_obj = os.path.join(self.get_target_private_dir(target), obj_basename)
          dep_file = compiler.depfile_for_object(rel_obj)
  
          # Add MSVC debug file generation compile flags: /Fd /FS
          commands += self.get_compile_debugfile_args(compiler, target, rel_obj)
  
          # PCH handling
          if self.environment.coredata.base_options.get('b_pch', False):
              commands += self.get_pch_include_args(compiler, target)
              pchlist = target.get_pch(compiler.language)
          else:
              pchlist = []
          if not pchlist:
              pch_dep = []
          elif compiler.id == 'intel':
              pch_dep = []
          else:
              arr = []
              i = os.path.join(self.get_target_private_dir(target), compiler.get_pch_name(pchlist[0]))
              arr.append(i)
              pch_dep = arr
  
          crstr = ''
          if target.is_cross:
              crstr = '_CROSS'
          compiler_name = '%s%s_COMPILER' % (compiler.get_language(), crstr)
          extra_deps = []
          if compiler.get_language() == 'fortran':
              # Can't read source file to scan for deps if it's generated later
              # at build-time. Skip scanning for deps, and just set the module
              # outdir argument instead.
              # https://github.com/mesonbuild/meson/issues/1348
              if not is_generated:
                  abs_src = os.path.join(build_dir, rel_src)
                  extra_deps += self.get_fortran_deps(compiler, abs_src, target)
              # Dependency hack. Remove once multiple outputs in Ninja is fixed:
              # https://groups.google.com/forum/#!topic/ninja-build/j-2RfBIOd_8
              for modname, srcfile in self.fortran_deps[target.get_basename()].items():
                  modfile = os.path.join(self.get_target_private_dir(target),
                                         compiler.module_name_to_filename(modname))
                  if srcfile == src:
                      depelem = NinjaBuildElement(self.all_outputs, modfile, 'FORTRAN_DEP_HACK', rel_obj)
                      depelem.write(outfile)
              commands += compiler.get_module_outdir_args(self.get_target_private_dir(target))
  
          if compiler.language == 'd':
              commands += compiler.get_feature_args(target.d_features, self.build_to_src)
  
          element = NinjaBuildElement(self.all_outputs, rel_obj, compiler_name, rel_src)
          for d in header_deps:
              if isinstance(d, File):
                  d = d.rel_to_builddir(self.build_to_src)
              elif not self.has_dir_part(d):
                  d = os.path.join(self.get_target_private_dir(target), d)
              element.add_dep(d)
          for d in extra_deps:
              element.add_dep(d)
          for d in order_deps:
              if isinstance(d, File):
                  d = d.rel_to_builddir(self.build_to_src)
              elif not self.has_dir_part(d):
                  d = os.path.join(self.get_target_private_dir(target), d)
              element.add_orderdep(d)
          element.add_orderdep(pch_dep)
          # Convert from GCC-style link argument naming to the naming used by the
          # current compiler.
          commands = commands.to_native()
          for i in self.get_fortran_orderdeps(target, compiler):
              element.add_orderdep(i)
          element.add_item('DEPFILE', dep_file)
          element.add_item('ARGS', commands)
          element.write(outfile)
          return rel_obj
  
      def has_dir_part(self, fname):
          # FIXME FIXME: The usage of this is a terrible and unreliable hack
          if isinstance(fname, File):
              return fname.subdir != ''
          return has_path_sep(fname)
  
      # Fortran is a bit weird (again). When you link against a library, just compiling a source file
      # requires the mod files that are output when single files are built. To do this right we would need to
      # scan all inputs and write out explicit deps for each file. That is stoo slow and too much effort so
      # instead just have an ordered dependency on the library. This ensures all required mod files are created.
      # The real deps are then detected via dep file generation from the compiler. This breaks on compilers that
      # produce incorrect dep files but such is life.
      def get_fortran_orderdeps(self, target, compiler):
          if compiler.language != 'fortran':
              return []
          return [os.path.join(self.get_target_dir(lt), lt.get_filename()) for lt in target.link_targets]
  
      def generate_msvc_pch_command(self, target, compiler, pch):
          if len(pch) != 2:
              raise MesonException('MSVC requires one header and one source to produce precompiled headers.')
          header = pch[0]
          source = pch[1]
          pchname = compiler.get_pch_name(header)
          dst = os.path.join(self.get_target_private_dir(target), pchname)
  
          commands = []
          commands += self.generate_basic_compiler_args(target, compiler)
          just_name = os.path.basename(header)
          (objname, pch_args) = compiler.gen_pch_args(just_name, source, dst)
          commands += pch_args
          commands += self.get_compile_debugfile_args(compiler, target, objname)
          dep = dst + '.' + compiler.get_depfile_suffix()
          return commands, dep, dst, [objname]
  
      def generate_gcc_pch_command(self, target, compiler, pch):
          commands = self._generate_single_compile(target, compiler)
          dst = os.path.join(self.get_target_private_dir(target),
                             os.path.basename(pch) + '.' + compiler.get_pch_suffix())
          dep = dst + '.' + compiler.get_depfile_suffix()
          return commands, dep, dst, []  # Gcc does not create an object file during pch generation.
  
      def generate_pch(self, target, outfile):
          cstr = ''
          pch_objects = []
          if target.is_cross:
              cstr = '_CROSS'
          for lang in ['c', 'cpp']:
              pch = target.get_pch(lang)
              if not pch:
                  continue
              if not has_path_sep(pch[0]) or not has_path_sep(pch[-1]):
                  msg = 'Precompiled header of {!r} must not be in the same ' \
                        'directory as source, please put it in a subdirectory.' \
                        ''.format(target.get_basename())
                  raise InvalidArguments(msg)
              compiler = target.compilers[lang]
              if compiler.id == 'msvc':
                  src = os.path.join(self.build_to_src, target.get_source_subdir(), pch[-1])
                  (commands, dep, dst, objs) = self.generate_msvc_pch_command(target, compiler, pch)
                  extradep = os.path.join(self.build_to_src, target.get_source_subdir(), pch[0])
              elif compiler.id == 'intel':
                  # Intel generates on target generation
                  continue
              else:
                  src = os.path.join(self.build_to_src, target.get_source_subdir(), pch[0])
                  (commands, dep, dst, objs) = self.generate_gcc_pch_command(target, compiler, pch[0])
                  extradep = None
              pch_objects += objs
              rulename = compiler.get_language() + cstr + '_PCH'
              elem = NinjaBuildElement(self.all_outputs, dst, rulename, src)
              if extradep is not None:
                  elem.add_dep(extradep)
              elem.add_item('ARGS', commands)
              elem.add_item('DEPFILE', dep)
              elem.write(outfile)
          return pch_objects
  
      def generate_shsym(self, outfile, target):
          target_name = self.get_target_filename(target)
          targetdir = self.get_target_private_dir(target)
          symname = os.path.join(targetdir, target_name + '.symbols')
          elem = NinjaBuildElement(self.all_outputs, symname, 'SHSYM', target_name)
          if self.environment.is_cross_build() and self.environment.cross_info.need_cross_compiler():
              elem.add_item('CROSS', '--cross-host=' + self.environment.cross_info.config['host_machine']['system'])
          elem.write(outfile)
  
      def get_cross_stdlib_link_args(self, target, linker):
          if isinstance(target, build.StaticLibrary) or not target.is_cross:
              return []
          if not self.environment.cross_info.has_stdlib(linker.language):
              return []
          return linker.get_no_stdlib_link_args()
  
      def get_target_type_link_args(self, target, linker):
          abspath = os.path.join(self.environment.get_build_dir(), target.subdir)
          commands = []
          if isinstance(target, build.Executable):
              # Currently only used with the Swift compiler to add '-emit-executable'
              commands += linker.get_std_exe_link_args()
              # If gui_app, and that's significant on this platform
              if target.gui_app and hasattr(linker, 'get_gui_app_args'):
                  commands += linker.get_gui_app_args()
              # If export_dynamic, add the appropriate linker arguments
              if target.export_dynamic:
                  commands += linker.gen_export_dynamic_link_args(self.environment)
              # If implib, and that's significant on this platform (i.e. Windows using either GCC or Visual Studio)
              if target.import_filename:
                  commands += linker.gen_import_library_args(os.path.join(self.get_target_dir(target), target.import_filename))
          elif isinstance(target, build.SharedLibrary):
              if isinstance(target, build.SharedModule):
                  commands += linker.get_std_shared_module_link_args()
              else:
                  commands += linker.get_std_shared_lib_link_args()
              # All shared libraries are PIC
              commands += linker.get_pic_args()
              # Add -Wl,-soname arguments on Linux, -install_name on OS X
              commands += linker.get_soname_args(target.prefix, target.name, target.suffix,
                                                 abspath, target.soversion,
                                                 isinstance(target, build.SharedModule))
              # This is only visited when building for Windows using either GCC or Visual Studio
              if target.vs_module_defs and hasattr(linker, 'gen_vs_module_defs_args'):
                  commands += linker.gen_vs_module_defs_args(target.vs_module_defs.rel_to_builddir(self.build_to_src))
              # This is only visited when building for Windows using either GCC or Visual Studio
              if target.import_filename:
                  commands += linker.gen_import_library_args(os.path.join(self.get_target_dir(target), target.import_filename))
          elif isinstance(target, build.StaticLibrary):
              commands += linker.get_std_link_args()
          else:
              raise RuntimeError('Unknown build target type.')
          return commands
  
      def get_link_whole_args(self, linker, target):
          target_args = self.build_target_link_arguments(linker, target.link_whole_targets)
          return linker.get_link_whole_for(target_args) if len(target_args) else []
  
      def generate_link(self, target, outfile, outname, obj_list, linker, extra_args=[]):
          if isinstance(target, build.StaticLibrary):
              linker_base = 'STATIC'
          else:
              linker_base = linker.get_language() # Fixme.
          if isinstance(target, build.SharedLibrary):
              self.generate_shsym(outfile, target)
          crstr = ''
          if target.is_cross:
              crstr = '_CROSS'
          linker_rule = linker_base + crstr + '_LINKER'
  
          # Create an empty commands list, and start adding link 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.
          #
          # Once all the linker options have been passed, we will start passing
          # libraries and library paths from internal and external sources.
          commands = CompilerArgs(linker)
          # First, the trivial ones that are impossible to override.
          #
          # Add linker args for linking this target derived from 'base' build
          # options passed on the command-line, in default_options, etc.
          # These have the lowest priority.
          if not isinstance(target, build.StaticLibrary):
              commands += compilers.get_base_link_args(self.environment.coredata.base_options,
                                                       linker,
                                                       isinstance(target, build.SharedModule))
          # Add -nostdlib if needed; can't be overridden
          commands += self.get_cross_stdlib_link_args(target, linker)
          # Add things like /NOLOGO; usually can't be overridden
          commands += linker.get_linker_always_args()
          # Add buildtype linker args: optimization level, etc.
          commands += linker.get_buildtype_linker_args(self.get_option_for_target('buildtype', target))
          # Add /DEBUG and the pdb filename when using MSVC
          commands += self.get_link_debugfile_args(linker, target, outname)
          # Add link args specific to this BuildTarget type, such as soname args,
          # PIC, import library generation, etc.
          commands += self.get_target_type_link_args(target, linker)
          # Archives that are copied wholesale in the result. Must be before any
          # other link targets so missing symbols from whole archives are found in those.
          if not isinstance(target, build.StaticLibrary):
              commands += self.get_link_whole_args(linker, target)
  
          if not isinstance(target, build.StaticLibrary):
              # Add link args added using add_project_link_arguments()
              commands += self.build.get_project_link_args(linker, target.subproject)
              # Add link args added using add_global_link_arguments()
              # These override per-project link arguments
              commands += self.build.get_global_link_args(linker)
              if not target.is_cross:
                  # Link args added from the env: LDFLAGS. We want these to
                  # override all the defaults but not the per-target link args.
                  commands += self.environment.coredata.external_link_args[linker.get_language()]
  
          # Now we will add libraries and library paths from various sources
  
          # Add link args to link to all internal libraries (link_with:) and
          # internal dependencies needed by this target.
          if linker_base == 'STATIC':
              # Link arguments of static libraries are not put in the command
              # line of the library. They are instead appended to the command
              # line where the static library is used.
              dependencies = []
          else:
              dependencies = target.get_dependencies()
          commands += self.build_target_link_arguments(linker, dependencies)
          # For 'automagic' deps: Boost and GTest. Also dependency('threads').
          # pkg-config puts the thread flags itself via `Cflags:`
          for d in target.external_deps:
              if d.need_threads():
                  commands += linker.thread_link_flags(self.environment)
          # Only non-static built targets need link args and link dependencies
          if not isinstance(target, build.StaticLibrary):
              commands += target.link_args
              # External deps must be last because target link libraries may depend on them.
              for dep in target.get_external_deps():
                  # Extend without reordering or de-dup to preserve `-L -l` sets
                  # https://github.com/mesonbuild/meson/issues/1718
                  commands.extend_direct(dep.get_link_args())
              for d in target.get_dependencies():
                  if isinstance(d, build.StaticLibrary):
                      for dep in d.get_external_deps():
                          commands.extend_direct(dep.get_link_args())
          # Add link args for c_* or cpp_* build options. Currently this only
          # adds c_winlibs and cpp_winlibs when building for Windows. This needs
          # to be after all internal and external libraries so that unresolved
          # symbols from those can be found here. This is needed when the
          # *_winlibs that we want to link to are static mingw64 libraries.
          commands += linker.get_option_link_args(self.environment.coredata.compiler_options)
          # Set runtime-paths so we can run executables without needing to set
          # LD_LIBRARY_PATH, etc in the environment. Doesn't work on Windows.
          if has_path_sep(target.name):
              # Target names really should not have slashes in them, but
              # unfortunately we did not check for that and some downstream projects
              # now have them. Once slashes are forbidden, remove this bit.
              target_slashname_workaround_dir = os.path.join(
                  os.path.dirname(target.name),
                  self.get_target_dir(target))
          else:
              target_slashname_workaround_dir = self.get_target_dir(target)
          commands += linker.build_rpath_args(self.environment.get_build_dir(),
                                              target_slashname_workaround_dir,
                                              self.determine_rpath_dirs(target),
                                              target.build_rpath,
                                              target.install_rpath)
          # Add libraries generated by custom targets
          custom_target_libraries = self.get_custom_target_provided_libraries(target)
          commands += extra_args
          commands += custom_target_libraries
          # Convert from GCC-style link argument naming to the naming used by the
          # current compiler.
          commands = commands.to_native()
          dep_targets = [self.get_dependency_filename(t) for t in dependencies]
          dep_targets.extend([self.get_dependency_filename(t)
                              for t in target.link_depends])
          elem = NinjaBuildElement(self.all_outputs, outname, linker_rule, obj_list)
          elem.add_dep(dep_targets + custom_target_libraries)
          elem.add_item('LINK_ARGS', commands)
          return elem
  
      def get_dependency_filename(self, t):
          if isinstance(t, build.SharedLibrary):
              return os.path.join(self.get_target_private_dir(t), self.get_target_filename(t) + '.symbols')
          elif isinstance(t, mesonlib.File):
              if t.is_built:
                  return t.relative_name()
              else:
                  return t.absolute_path(self.environment.get_source_dir(),
                                         self.environment.get_build_dir())
          return self.get_target_filename(t)
  
      def generate_shlib_aliases(self, target, outdir):
          aliases = target.get_aliases()
          for alias, to in aliases.items():
              aliasfile = os.path.join(self.environment.get_build_dir(), outdir, alias)
              try:
                  os.remove(aliasfile)
              except Exception:
                  pass
              try:
                  os.symlink(to, aliasfile)
              except NotImplementedError:
                  mlog.debug("Library versioning disabled because symlinks are not supported.")
              except OSError:
                  mlog.debug("Library versioning disabled because we do not have symlink creation privileges.")
  
      def generate_custom_target_clean(self, outfile, trees):
          e = NinjaBuildElement(self.all_outputs, 'meson-clean-ctlist', 'CUSTOM_COMMAND', 'PHONY')
          d = CleanTrees(self.environment.get_build_dir(), trees)
          d_file = os.path.join(self.environment.get_scratch_dir(), 'cleantrees.dat')
          e.add_item('COMMAND', self.environment.get_build_command() + ['--internal', 'cleantrees', d_file])
          e.add_item('description', 'Cleaning custom target directories.')
          e.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-clean-ctlist', outfile)
          # Write out the data file passed to the script
          with open(d_file, 'wb') as ofile:
              pickle.dump(d, ofile)
          return 'clean-ctlist'
  
      def generate_gcov_clean(self, outfile):
          gcno_elem = NinjaBuildElement(self.all_outputs, 'meson-clean-gcno', 'CUSTOM_COMMAND', 'PHONY')
          script_root = self.environment.get_script_dir()
          clean_script = os.path.join(script_root, 'delwithsuffix.py')
          gcno_elem.add_item('COMMAND', mesonlib.python_command + [clean_script, '.', 'gcno'])
          gcno_elem.add_item('description', 'Deleting gcno files.')
          gcno_elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-clean-gcno', outfile)
  
          gcda_elem = NinjaBuildElement(self.all_outputs, 'meson-clean-gcda', 'CUSTOM_COMMAND', 'PHONY')
          script_root = self.environment.get_script_dir()
          clean_script = os.path.join(script_root, 'delwithsuffix.py')
          gcda_elem.add_item('COMMAND', mesonlib.python_command + [clean_script, '.', 'gcda'])
          gcda_elem.add_item('description', 'Deleting gcda files.')
          gcda_elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-clean-gcda', outfile)
  
      def get_user_option_args(self):
          cmds = []
          for (k, v) in self.environment.coredata.user_options.items():
              cmds.append('-D' + k + '=' + (v.value if isinstance(v.value, str) else str(v.value).lower()))
          # The order of these arguments must be the same between runs of Meson
          # to ensure reproducible output. The order we pass them shouldn't
          # affect behavior in any other way.
          return sorted(cmds)
  
      def generate_dist(self, outfile):
          elem = NinjaBuildElement(self.all_outputs, 'meson-dist', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('DESC', 'Creating source packages')
          elem.add_item('COMMAND', self.environment.get_build_command() + [
              '--internal', 'dist',
              self.environment.source_dir,
              self.environment.build_dir,
          ] + self.environment.get_build_command())
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-dist', outfile)
  
      # For things like scan-build and other helper tools we might have.
      def generate_utils(self, outfile):
          cmd = self.environment.get_build_command() + \
              ['--internal', 'scanbuild', self.environment.source_dir, self.environment.build_dir] + \
              self.environment.get_build_command() + self.get_user_option_args()
          elem = NinjaBuildElement(self.all_outputs, 'meson-scan-build', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('COMMAND', cmd)
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-scan-build', outfile)
          cmd = self.environment.get_build_command() + ['--internal', 'uninstall']
          elem = NinjaBuildElement(self.all_outputs, 'meson-uninstall', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('COMMAND', cmd)
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-uninstall', outfile)
  
      def generate_ending(self, outfile):
          targetlist = []
          for t in self.get_build_by_default_targets().values():
              # Add the first output of each target to the 'all' target so that
              # they are all built
              targetlist.append(os.path.join(self.get_target_dir(t), t.get_outputs()[0]))
  
          elem = NinjaBuildElement(self.all_outputs, 'all', 'phony', targetlist)
          elem.write(outfile)
  
          default = 'default all\n\n'
          outfile.write(default)
  
          elem = NinjaBuildElement(self.all_outputs, 'meson-clean', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('COMMAND', [self.ninja_command, '-t', 'clean'])
          elem.add_item('description', 'Cleaning.')
          # Alias that runs the above-defined meson-clean target
          self.create_target_alias('meson-clean', outfile)
  
          # If we have custom targets in this project, add all their outputs to
          # the list that is passed to the `cleantrees.py` script. The script
          # will manually delete all custom_target outputs that are directories
          # instead of files. This is needed because on platforms other than
          # Windows, Ninja only deletes directories while cleaning if they are
          # empty. https://github.com/mesonbuild/meson/issues/1220
          ctlist = []
          for t in self.build.get_targets().values():
              if isinstance(t, build.CustomTarget):
                  # Create a list of all custom target outputs
                  for o in t.get_outputs():
                      ctlist.append(os.path.join(self.get_target_dir(t), o))
          if ctlist:
              elem.add_dep(self.generate_custom_target_clean(outfile, ctlist))
  
          if 'b_coverage' in self.environment.coredata.base_options and \
             self.environment.coredata.base_options['b_coverage'].value:
              self.generate_gcov_clean(outfile)
              elem.add_dep('clean-gcda')
              elem.add_dep('clean-gcno')
          elem.write(outfile)
  
          deps = self.get_regen_filelist()
          elem = NinjaBuildElement(self.all_outputs, 'build.ninja', 'REGENERATE_BUILD', deps)
          elem.add_item('pool', 'console')
          elem.write(outfile)
  
          elem = NinjaBuildElement(self.all_outputs, 'reconfigure', 'REGENERATE_BUILD', 'PHONY')
          elem.add_item('pool', 'console')
          elem.write(outfile)
  
          elem = NinjaBuildElement(self.all_outputs, deps, 'phony', '')
          elem.write(outfile)
  
  def load(build_dir):
      filename = os.path.join(build_dir, 'meson-private', 'install.dat')
      with open(filename, 'rb') as f:
          obj = pickle.load(f)
      return obj
  
files: mesonbuild/backend/ninjabackend.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 os, pickle, re, shlex, subprocess
  from collections import OrderedDict
  import itertools
  from pathlib import PurePath
  
  from . import backends
  from .. import modules
  from .. import environment, mesonlib
  from .. import build
  from .. import mlog
  from .. import dependencies
  from .. import compilers
  from ..compilers import CompilerArgs
  from ..linkers import ArLinker
  from ..mesonlib import File, MesonException, OrderedSet
  from ..mesonlib import get_compiler_for_source
  from .backends import CleanTrees, InstallData
  from ..build import InvalidArguments
  
  if mesonlib.is_windows():
      quote_func = lambda s: '"{}"'.format(s)
      execute_wrapper = 'cmd /c'
      rmfile_prefix = 'del /f /s /q {} &&'
  else:
      quote_func = shlex.quote
      execute_wrapper = ''
      rmfile_prefix = 'rm -f {} &&'
  
  def ninja_quote(text, is_build_line=False):
      if is_build_line:
          qcs = ('$', ' ', ':')
      else:
          qcs = ('$', ' ')
      for char in qcs:
          text = text.replace(char, '$' + char)
      if '\n' in text:
          errmsg = '''Ninja does not support newlines in rules. The content was:
  
  %s
  
  Please report this error with a test case to the Meson bug tracker.''' % text
          raise MesonException(errmsg)
      return text
  
  
  class NinjaBuildElement:
      def __init__(self, all_outputs, outfilenames, rule, infilenames):
          if isinstance(outfilenames, str):
              self.outfilenames = [outfilenames]
          else:
              self.outfilenames = outfilenames
          assert(isinstance(rule, str))
          self.rule = rule
          if isinstance(infilenames, str):
              self.infilenames = [infilenames]
          else:
              self.infilenames = infilenames
          self.deps = set()
          self.orderdeps = set()
          self.elems = []
          self.all_outputs = all_outputs
  
      def add_dep(self, dep):
          if isinstance(dep, list):
              self.deps.update(dep)
          else:
              self.deps.add(dep)
  
      def add_orderdep(self, dep):
          if isinstance(dep, list):
              self.orderdeps.update(dep)
          else:
              self.orderdeps.add(dep)
  
      def add_item(self, name, elems):
          if isinstance(elems, str):
              elems = [elems]
          self.elems.append((name, elems))
  
      def write(self, outfile):
          self.check_outputs()
          line = 'build %s: %s %s' % (' '.join([ninja_quote(i, True) for i in self.outfilenames]),
                                      self.rule,
                                      ' '.join([ninja_quote(i, True) for i in self.infilenames]))
          if len(self.deps) > 0:
              line += ' | ' + ' '.join([ninja_quote(x, True) for x in self.deps])
          if len(self.orderdeps) > 0:
              line += ' || ' + ' '.join([ninja_quote(x, True) for x in self.orderdeps])
          line += '\n'
          # This is the only way I could find to make this work on all
          # platforms including Windows command shell. Slash is a dir separator
          # on Windows, too, so all characters are unambiguous and, more importantly,
          # do not require quoting, unless explicitely specified, which is necessary for
          # the csc compiler.
          line = line.replace('\\', '/')
          outfile.write(line)
  
          # All the entries that should remain unquoted
          raw_names = {'DEPFILE', 'DESC', 'pool', 'description'}
  
          for e in self.elems:
              (name, elems) = e
              should_quote = name not in raw_names
              line = ' %s = ' % name
              newelems = []
              for i in elems:
                  if not should_quote or i == '&&': # Hackety hack hack
                      quoter = ninja_quote
                  else:
                      quoter = lambda x: ninja_quote(quote_func(x))
                  i = i.replace('\\', '\\\\')
                  if quote_func('') == '""':
                      i = i.replace('"', '\\"')
                  newelems.append(quoter(i))
              line += ' '.join(newelems)
              line += '\n'
              outfile.write(line)
          outfile.write('\n')
  
      def check_outputs(self):
          for n in self.outfilenames:
              if n in self.all_outputs:
                  raise MesonException('Multiple producers for Ninja target "%s". Please rename your targets.' % n)
              self.all_outputs[n] = True
  
  class NinjaBackend(backends.Backend):
  
      def __init__(self, build):
          super().__init__(build)
          self.name = 'ninja'
          self.ninja_filename = 'build.ninja'
          self.target_arg_cache = {}
          self.fortran_deps = {}
          self.all_outputs = {}
  
      def create_target_alias(self, to_target, outfile):
          # We need to use aliases for targets that might be used as directory
          # names to workaround a Ninja bug that breaks `ninja -t clean`.
          # This is used for 'reserved' targets such as 'test', 'install',
          # 'benchmark', etc, and also for RunTargets.
          # https://github.com/mesonbuild/meson/issues/1644
          if not to_target.startswith('meson-'):
              m = 'Invalid usage of create_target_alias with {!r}'
              raise AssertionError(m.format(to_target))
          from_target = to_target[len('meson-'):]
          elem = NinjaBuildElement(self.all_outputs, from_target, 'phony', to_target)
          elem.write(outfile)
  
      def detect_vs_dep_prefix(self, tempfilename):
          '''VS writes its dependency in a locale dependent format.
          Detect the search prefix to use.'''
          for compiler in self.build.compilers.values():
              # Have to detect the dependency format
              if compiler.id == 'msvc':
                  break
          else:
              # None of our compilers are MSVC, we're done.
              return open(tempfilename, 'a')
          filename = os.path.join(self.environment.get_scratch_dir(),
                                  'incdetect.c')
          with open(filename, 'w') as f:
              f.write('''#include<stdio.h>
  int dummy;
  ''')
  
          # The output of cl dependency information is language
          # and locale dependent. Any attempt at converting it to
          # Python strings leads to failure. We _must_ do this detection
          # in raw byte mode and write the result in raw bytes.
          pc = subprocess.Popen(['cl', '/showIncludes', '/c', 'incdetect.c'],
                                cwd=self.environment.get_scratch_dir(),
                                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
          (stdo, _) = pc.communicate()
  
          # We want to match 'Note: including file: ' in the line
          # 'Note: including file: d:\MyDir\include\stdio.h', however
          # different locales have different messages with a different
          # number of colons. Match up to the the drive name 'd:\'.
          matchre = re.compile(rb"^(.*\s)[a-zA-Z]:\\.*stdio.h$")
          for line in stdo.split(b'\r\n'):
              match = matchre.match(line)
              if match:
                  with open(tempfilename, 'ab') as binfile:
                      binfile.write(b'msvc_deps_prefix = ' + match.group(1) + b'\n')
                  return open(tempfilename, 'a')
          raise MesonException('Could not determine vs dep dependency prefix string.')
  
      def generate(self, interp):
          self.interpreter = interp
          self.ninja_command = environment.detect_ninja(log=True)
          if self.ninja_command is None:
              raise MesonException('Could not detect Ninja v1.5 or newer')
          outfilename = os.path.join(self.environment.get_build_dir(), self.ninja_filename)
          tempfilename = outfilename + '~'
          with open(tempfilename, 'w') as outfile:
              outfile.write('# This is the build file for project "%s"\n' %
                            self.build.get_project())
              outfile.write('# It is autogenerated by the Meson build system.\n')
              outfile.write('# Do not edit by hand.\n\n')
              outfile.write('ninja_required_version = 1.5.1\n\n')
          with self.detect_vs_dep_prefix(tempfilename) as outfile:
              self.generate_rules(outfile)
              self.generate_phony(outfile)
              outfile.write('# Build rules for targets\n\n')
              for t in self.build.get_targets().values():
                  self.generate_target(t, outfile)
              outfile.write('# Test rules\n\n')
              self.generate_tests(outfile)
              outfile.write('# Install rules\n\n')
              self.generate_install(outfile)
              self.generate_dist(outfile)
              if 'b_coverage' in self.environment.coredata.base_options and \
                      self.environment.coredata.base_options['b_coverage'].value:
                  outfile.write('# Coverage rules\n\n')
                  self.generate_coverage_rules(outfile)
              outfile.write('# Suffix\n\n')
              self.generate_utils(outfile)
              self.generate_ending(outfile)
          # Only overwrite the old build file after the new one has been
          # fully created.
          os.replace(tempfilename, outfilename)
          self.generate_compdb()
  
      # http://clang.llvm.org/docs/JSONCompilationDatabase.html
      def generate_compdb(self):
          pch_compilers = ['%s_PCH' % i for i in self.build.compilers]
          native_compilers = ['%s_COMPILER' % i for i in self.build.compilers]
          cross_compilers = ['%s_CROSS_COMPILER' % i for i in self.build.cross_compilers]
          ninja_compdb = [self.ninja_command, '-t', 'compdb'] + pch_compilers + native_compilers + cross_compilers
          builddir = self.environment.get_build_dir()
          try:
              jsondb = subprocess.check_output(ninja_compdb, cwd=builddir)
              with open(os.path.join(builddir, 'compile_commands.json'), 'wb') as f:
                  f.write(jsondb)
          except Exception:
              mlog.warning('Could not create compilation database.')
  
      # Get all generated headers. Any source file might need them so
      # we need to add an order dependency to them.
      def get_generated_headers(self, target):
          header_deps = []
          # XXX: Why don't we add deps to CustomTarget headers here?
          for genlist in target.get_generated_sources():
              if isinstance(genlist, (build.CustomTarget, build.CustomTargetIndex)):
                  continue
              for src in genlist.get_outputs():
                  if self.environment.is_header(src):
                      header_deps.append(self.get_target_generated_dir(target, genlist, src))
          if 'vala' in target.compilers and not isinstance(target, build.Executable):
              vala_header = File.from_built_file(self.get_target_dir(target), target.vala_header)
              header_deps.append(vala_header)
          # Recurse and find generated headers
          for dep in itertools.chain(target.link_targets, target.link_whole_targets):
              if isinstance(dep, (build.StaticLibrary, build.SharedLibrary)):
                  header_deps += self.get_generated_headers(dep)
          return header_deps
  
      def get_target_generated_sources(self, target):
          """
          Returns a dictionary with the keys being the path to the file
          (relative to the build directory) of that type and the value
          being the GeneratorList or CustomTarget that generated it.
          """
          srcs = OrderedDict()
          for gensrc in target.get_generated_sources():
              for s in gensrc.get_outputs():
                  f = self.get_target_generated_dir(target, gensrc, s)
                  srcs[f] = s
          return srcs
  
      def get_target_sources(self, target):
          srcs = OrderedDict()
          for s in target.get_sources():
              # BuildTarget sources are always mesonlib.File files which are
              # either in the source root, or generated with configure_file and
              # in the build root
              if not isinstance(s, File):
                  raise InvalidArguments('All sources in target {!r} must be of type mesonlib.File'.format(s))
              f = s.rel_to_builddir(self.build_to_src)
              srcs[f] = s
          return srcs
  
      # Languages that can mix with C or C++ but don't support unity builds yet
      # because the syntax we use for unity builds is specific to C/++/ObjC/++.
      # Assembly files cannot be unitified and neither can LLVM IR files
      langs_cant_unity = ('d', 'fortran')
  
      def get_target_source_can_unity(self, target, source):
          if isinstance(source, File):
              source = source.fname
          if self.environment.is_llvm_ir(source) or \
             self.environment.is_assembly(source):
              return False
          suffix = os.path.splitext(source)[1][1:]
          for lang in self.langs_cant_unity:
              if lang not in target.compilers:
                  continue
              if suffix in target.compilers[lang].file_suffixes:
                  return False
          return True
  
      def generate_target(self, target, outfile):
          if isinstance(target, build.CustomTarget):
              self.generate_custom_target(target, outfile)
          if isinstance(target, build.RunTarget):
              self.generate_run_target(target, outfile)
          name = target.get_id()
          if name in self.processed_targets:
              return
          self.processed_targets[name] = True
          # Generate rules for all dependency targets
          self.process_target_dependencies(target, outfile)
          # If target uses a language that cannot link to C objects,
          # just generate for that language and return.
          if isinstance(target, build.Jar):
              self.generate_jar_target(target, outfile)
              return
          if 'rust' in target.compilers:
              self.generate_rust_target(target, outfile)
              return
          if 'cs' in target.compilers:
              self.generate_cs_target(target, outfile)
              return
          if 'swift' in target.compilers:
              self.generate_swift_target(target, outfile)
              return
  
          # Now we handle the following languages:
          # ObjC++, ObjC, C++, C, D, Fortran, Vala
  
          # target_sources:
          #   Pre-existing target C/C++ sources to be built; dict of full path to
          #   source relative to build root and the original File object.
          # generated_sources:
          #   GeneratedList and CustomTarget sources to be built; dict of the full
          #   path to source relative to build root and the generating target/list
          # vala_generated_sources:
          #   Array of sources generated by valac that have to be compiled
          if 'vala' in target.compilers:
              # Sources consumed by valac are filtered out. These only contain
              # C/C++ sources, objects, generated libs, and unknown sources now.
              target_sources, generated_sources, \
                  vala_generated_sources = self.generate_vala_compile(target, outfile)
          else:
              target_sources = self.get_target_sources(target)
              generated_sources = self.get_target_generated_sources(target)
              vala_generated_sources = []
          self.scan_fortran_module_outputs(target)
          # Generate rules for GeneratedLists
          self.generate_generator_list_rules(target, outfile)
  
          # Generate rules for building the remaining source files in this target
          outname = self.get_target_filename(target)
          obj_list = []
          use_pch = self.environment.coredata.base_options.get('b_pch', False)
          is_unity = self.is_unity(target)
          if use_pch and target.has_pch():
              pch_objects = self.generate_pch(target, outfile)
          else:
              pch_objects = []
          header_deps = []
          unity_src = []
          unity_deps = [] # Generated sources that must be built before compiling a Unity target.
          header_deps += self.get_generated_headers(target)
  
          if is_unity:
              # Warn about incompatible sources if a unity build is enabled
              langs = set(target.compilers.keys())
              langs_cant = langs.intersection(self.langs_cant_unity)
              if langs_cant:
                  langs_are = langs = ', '.join(langs_cant).upper()
                  langs_are += ' are' if len(langs_cant) > 1 else ' is'
                  msg = '{} not supported in Unity builds yet, so {} ' \
                        'sources in the {!r} target will be compiled normally' \
                        ''.format(langs_are, langs, target.name)
                  mlog.log(mlog.red('FIXME'), msg)
  
          # Get a list of all generated headers that will be needed while building
          # this target's sources (generated sources and pre-existing sources).
          # This will be set as dependencies of all the target's sources. At the
          # same time, also deal with generated sources that need to be compiled.
          generated_source_files = []
          for rel_src, gensrc in generated_sources.items():
              dirpart, fnamepart = os.path.split(rel_src)
              raw_src = File(True, dirpart, fnamepart)
              if self.environment.is_source(rel_src) and not self.environment.is_header(rel_src):
                  if is_unity and self.get_target_source_can_unity(target, rel_src):
                      unity_deps.append(raw_src)
                      abs_src = os.path.join(self.environment.get_build_dir(), rel_src)
                      unity_src.append(abs_src)
                  else:
                      generated_source_files.append(raw_src)
              elif self.environment.is_object(rel_src):
                  obj_list.append(rel_src)
              elif self.environment.is_library(rel_src):
                  pass
              else:
                  # Assume anything not specifically a source file is a header. This is because
                  # people generate files with weird suffixes (.inc, .fh) that they then include
                  # in their source files.
                  header_deps.append(raw_src)
          # These are the generated source files that need to be built for use by
          # this target. We create the Ninja build file elements for this here
          # because we need `header_deps` to be fully generated in the above loop.
          for src in generated_source_files:
              if self.environment.is_llvm_ir(src):
                  o = self.generate_llvm_ir_compile(target, outfile, src)
              else:
                  o = self.generate_single_compile(target, outfile, src, True,
                                                   header_deps=header_deps)
              obj_list.append(o)
  
          # Generate compilation targets for C sources generated from Vala
          # sources. This can be extended to other $LANG->C compilers later if
          # necessary. This needs to be separate for at least Vala
          vala_generated_source_files = []
          for src in vala_generated_sources:
              dirpart, fnamepart = os.path.split(src)
              raw_src = File(True, dirpart, fnamepart)
              if is_unity:
                  unity_src.append(os.path.join(self.environment.get_build_dir(), src))
                  header_deps.append(raw_src)
              else:
                  # Generated targets are ordered deps because the must exist
                  # before the sources compiling them are used. After the first
                  # compile we get precise dependency info from dep files.
                  # This should work in all cases. If it does not, then just
                  # move them from orderdeps to proper deps.
                  if self.environment.is_header(src):
                      header_deps.append(raw_src)
                  else:
                      # We gather all these and generate compile rules below
                      # after `header_deps` (above) is fully generated
                      vala_generated_source_files.append(raw_src)
          for src in vala_generated_source_files:
              # Passing 'vala' here signifies that we want the compile
              # arguments to be specialized for C code generated by
              # valac. For instance, no warnings should be emitted.
              obj_list.append(self.generate_single_compile(target, outfile, src, 'vala', [], header_deps))
  
          # Generate compile targets for all the pre-existing sources for this target
          for f, src in target_sources.items():
              if not self.environment.is_header(src):
                  if self.environment.is_llvm_ir(src):
                      obj_list.append(self.generate_llvm_ir_compile(target, outfile, src))
                  elif is_unity and self.get_target_source_can_unity(target, src):
                      abs_src = os.path.join(self.environment.get_build_dir(),
                                             src.rel_to_builddir(self.build_to_src))
                      unity_src.append(abs_src)
                  else:
                      obj_list.append(self.generate_single_compile(target, outfile, src, False, [], header_deps))
          obj_list += self.flatten_object_list(target)
          if is_unity:
              for src in self.generate_unity_files(target, unity_src):
                  obj_list.append(self.generate_single_compile(target, outfile, src, True, unity_deps + header_deps))
          linker = self.determine_linker(target)
          elem = self.generate_link(target, outfile, outname, obj_list, linker, pch_objects)
          self.generate_shlib_aliases(target, self.get_target_dir(target))
          elem.write(outfile)
  
      def process_target_dependencies(self, target, outfile):
          for t in target.get_dependencies():
              if t.get_id() not in self.processed_targets:
                  self.generate_target(t, outfile)
  
      def custom_target_generator_inputs(self, target, outfile):
          for s in target.sources:
              if hasattr(s, 'held_object'):
                  s = s.held_object
              if isinstance(s, build.GeneratedList):
                  self.generate_genlist_for_target(s, target, outfile)
  
      def unwrap_dep_list(self, target):
          deps = []
          for i in target.get_dependencies():
              # FIXME, should not grab element at zero but rather expand all.
              if isinstance(i, list):
                  i = i[0]
              # Add a dependency on all the outputs of this target
              for output in i.get_outputs():
                  deps.append(os.path.join(self.get_target_dir(i), output))
          return deps
  
      def generate_custom_target(self, target, outfile):
          self.custom_target_generator_inputs(target, outfile)
          (srcs, ofilenames, cmd) = self.eval_custom_target_command(target)
          deps = self.unwrap_dep_list(target)
          deps += self.get_custom_target_depend_files(target)
          desc = 'Generating {0} with a {1} command.'
          if target.build_always:
              deps.append('PHONY')
          if target.depfile is None:
              rulename = 'CUSTOM_COMMAND'
          else:
              rulename = 'CUSTOM_COMMAND_DEP'
          elem = NinjaBuildElement(self.all_outputs, ofilenames, rulename, srcs)
          elem.add_dep(deps)
          for d in target.extra_depends:
              # Add a dependency on all the outputs of this target
              for output in d.get_outputs():
                  elem.add_dep(os.path.join(self.get_target_dir(d), output))
          serialize = False
          extra_paths = []
          # If the target requires capturing stdout, then use the serialized
          # executable wrapper to capture that output and save it to a file.
          if target.capture:
              serialize = True
          # If the command line requires a newline, also use the wrapper, as
          # ninja does not support them in its build rule syntax.
          if any('\n' in c for c in cmd):
              serialize = True
          # Windows doesn't have -rpath, so for EXEs that need DLLs built within
          # the project, we need to set PATH so the DLLs are found. We use
          # a serialized executable wrapper for that and check if the
          # CustomTarget command needs extra paths first.
          if mesonlib.is_windows() or mesonlib.is_cygwin():
              extra_bdeps = target.get_transitive_build_target_deps()
              extra_paths = self.determine_windows_extra_paths(target.command[0], extra_bdeps)
              if extra_paths:
                  serialize = True
          if serialize:
              exe_data = self.serialize_executable(target.command[0], cmd[1:],
                                                   # All targets are built from the build dir
                                                   self.environment.get_build_dir(),
                                                   extra_paths=extra_paths,
                                                   capture=ofilenames[0] if target.capture else None)
              cmd = self.environment.get_build_command() + ['--internal', 'exe', exe_data]
              cmd_type = 'meson_exe.py custom'
          else:
              cmd_type = 'custom'
          if target.depfile is not None:
              rel_dfile = os.path.join(self.get_target_dir(target), target.depfile)
              abs_pdir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(target))
              os.makedirs(abs_pdir, exist_ok=True)
              elem.add_item('DEPFILE', rel_dfile)
          cmd = self.replace_paths(target, cmd)
          elem.add_item('COMMAND', cmd)
          elem.add_item('description', desc.format(target.name, cmd_type))
          elem.write(outfile)
          self.processed_targets[target.get_id()] = True
  
      def generate_run_target(self, target, outfile):
          cmd = self.environment.get_build_command() + ['--internal', 'commandrunner']
          deps = self.unwrap_dep_list(target)
          arg_strings = []
          for i in target.args:
              if isinstance(i, str):
                  arg_strings.append(i)
              elif isinstance(i, (build.BuildTarget, build.CustomTarget)):
                  relfname = self.get_target_filename(i)
                  arg_strings.append(os.path.join(self.environment.get_build_dir(), relfname))
                  deps.append(relfname)
              elif isinstance(i, mesonlib.File):
                  relfname = i.rel_to_builddir(self.build_to_src)
                  arg_strings.append(os.path.join(self.environment.get_build_dir(), relfname))
              else:
                  raise AssertionError('Unreachable code in generate_run_target: ' + str(i))
          if target.subproject != '':
              subproject_prefix = '{}@@'.format(target.subproject)
          else:
              subproject_prefix = ''
          target_name = 'meson-{}{}'.format(subproject_prefix, target.name)
          elem = NinjaBuildElement(self.all_outputs, target_name, 'CUSTOM_COMMAND', [])
          cmd += [self.environment.get_source_dir(),
                  self.environment.get_build_dir(),
                  target.subdir] + self.environment.get_build_command()
          texe = target.command
          try:
              texe = texe.held_object
          except AttributeError:
              pass
          if isinstance(texe, build.Executable):
              abs_exe = os.path.join(self.environment.get_build_dir(), self.get_target_filename(texe))
              deps.append(self.get_target_filename(texe))
              if self.environment.is_cross_build() and \
                 self.environment.cross_info.need_exe_wrapper():
                  exe_wrap = self.environment.cross_info.config['binaries'].get('exe_wrapper', None)
                  if exe_wrap is not None:
                      cmd += [exe_wrap]
              cmd.append(abs_exe)
          elif isinstance(texe, dependencies.ExternalProgram):
              cmd += texe.get_command()
          elif isinstance(texe, build.CustomTarget):
              deps.append(self.get_target_filename(texe))
              cmd += [os.path.join(self.environment.get_build_dir(), self.get_target_filename(texe))]
          elif isinstance(texe, mesonlib.File):
              cmd.append(texe.absolute_path(self.environment.get_source_dir(), self.environment.get_build_dir()))
          else:
              cmd.append(target.command)
          cmd += arg_strings
  
          elem.add_dep(deps)
          cmd = self.replace_paths(target, cmd)
          elem.add_item('COMMAND', cmd)
          elem.add_item('description', 'Running external command %s.' % target.name)
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above with the name the user specified
          self.create_target_alias(target_name, outfile)
          self.processed_targets[target.get_id()] = True
  
      def generate_coverage_rules(self, outfile):
          e = NinjaBuildElement(self.all_outputs, 'meson-coverage', 'CUSTOM_COMMAND', 'PHONY')
          e.add_item('COMMAND', self.environment.get_build_command() +
                     ['--internal', 'coverage',
                      self.environment.get_source_dir(),
                      self.environment.get_build_dir(),
                      self.environment.get_log_dir()])
          e.add_item('description', 'Generates coverage reports.')
          e.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-coverage', outfile)
          self.generate_coverage_legacy_rules(outfile)
  
      def generate_coverage_legacy_rules(self, outfile):
          (gcovr_exe, gcovr_new_rootdir, lcov_exe, genhtml_exe) = environment.find_coverage_tools()
          added_rule = False
          if gcovr_exe:
              # gcovr >= 3.1 interprets rootdir differently
              if gcovr_new_rootdir:
                  rootdir = self.environment.get_build_dir()
              else:
                  rootdir = self.environment.get_source_dir(),
              added_rule = True
              elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-xml', 'CUSTOM_COMMAND', '')
              elem.add_item('COMMAND', [gcovr_exe, '-x', '-r', rootdir,
                                        '-o', os.path.join(self.environment.get_log_dir(), 'coverage.xml')])
              elem.add_item('DESC', 'Generating XML coverage report.')
              elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-xml', outfile)
              elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-text', 'CUSTOM_COMMAND', '')
              elem.add_item('COMMAND', [gcovr_exe, '-r', rootdir,
                                        '-o', os.path.join(self.environment.get_log_dir(), 'coverage.txt')])
              elem.add_item('DESC', 'Generating text coverage report.')
              elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-text', outfile)
          if lcov_exe and genhtml_exe:
              added_rule = True
              htmloutdir = os.path.join(self.environment.get_log_dir(), 'coveragereport')
              covinfo = os.path.join(self.environment.get_log_dir(), 'coverage.info')
              phony_elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-html', 'phony', os.path.join(htmloutdir, 'index.html'))
              phony_elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-html', outfile)
              elem = NinjaBuildElement(self.all_outputs, os.path.join(htmloutdir, 'index.html'), 'CUSTOM_COMMAND', '')
  
              subproject_dir = self.build.get_subproject_dir()
              command = [lcov_exe,
                         '--directory', self.environment.get_build_dir(),
                         '--capture',
                         '--output-file', covinfo,
                         '--no-checksum',
                         '&&', lcov_exe,
                         '--extract',
                         covinfo,
                         os.path.join(self.environment.get_source_dir(), '*'),
                         '--output-file', covinfo,
                         '&&', lcov_exe,
                         '--remove',
                         covinfo,
                         os.path.join(self.environment.get_source_dir(), subproject_dir, '*'),
                         '--output-file', covinfo,
                         '&&', genhtml_exe,
                         '--prefix', self.environment.get_build_dir(),
                         '--output-directory', htmloutdir,
                         '--title', 'Code coverage',
                         '--legend',
                         '--show-details',
                         covinfo]
              elem.add_item('COMMAND', command)
              elem.add_item('DESC', 'Generating HTML coverage report.')
              elem.write(outfile)
          elif gcovr_exe and gcovr_new_rootdir:
              added_rule = True
              htmloutdir = os.path.join(self.environment.get_log_dir(), 'coveragereport')
              phony_elem = NinjaBuildElement(self.all_outputs, 'meson-coverage-html', 'phony', os.path.join(htmloutdir, 'index.html'))
              phony_elem.write(outfile)
              # Alias that runs the target defined above
              self.create_target_alias('meson-coverage-html', outfile)
              elem = NinjaBuildElement(self.all_outputs, os.path.join(htmloutdir, 'index.html'), 'CUSTOM_COMMAND', '')
              command = [gcovr_exe, '--html', '--html-details', '-r', self.environment.get_build_dir(),
                         '-o', os.path.join(htmloutdir, 'index.html')]
              elem.add_item('COMMAND', command)
              elem.add_item('DESC', 'Generating HTML coverage report.')
              elem.write(outfile)
          if not added_rule:
              mlog.warning('coverage requested but neither gcovr nor lcov/genhtml found.')
  
      def generate_install(self, outfile):
          install_data_file = os.path.join(self.environment.get_scratch_dir(), 'install.dat')
          if self.environment.is_cross_build():
              bins = self.environment.cross_info.config['binaries']
              if 'strip' not in bins:
                  mlog.warning('Cross file does not specify strip binary, result will not be stripped.')
                  strip_bin = None
              else:
                  strip_bin = mesonlib.stringlistify(bins['strip'])
          else:
              strip_bin = self.environment.native_strip_bin
          d = InstallData(self.environment.get_source_dir(),
                          self.environment.get_build_dir(),
                          self.environment.get_prefix(),
                          strip_bin, self.environment.get_build_command() + ['introspect'])
          elem = NinjaBuildElement(self.all_outputs, 'meson-install', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_dep('all')
          elem.add_item('DESC', 'Installing files.')
          elem.add_item('COMMAND', self.environment.get_build_command() + ['--internal', 'install', install_data_file])
          elem.add_item('pool', 'console')
          self.generate_depmf_install(d)
          self.generate_target_install(d)
          self.generate_header_install(d)
          self.generate_man_install(d)
          self.generate_data_install(d)
          self.generate_custom_install_script(d)
          self.generate_subdir_install(d)
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-install', outfile)
  
          with open(install_data_file, 'wb') as ofile:
              pickle.dump(d, ofile)
  
      def generate_target_install(self, d):
          for t in self.build.get_targets().values():
              if not t.should_install():
                  continue
              # Find the installation directory.
              outdirs = t.get_custom_install_dir()
              custom_install_dir = False
              if outdirs[0] is not None and outdirs[0] is not True:
                  # Either the value is set, or is set to False which means
                  # we want this specific output out of many outputs to not
                  # be installed.
                  custom_install_dir = True
              elif isinstance(t, build.SharedModule):
                  outdirs[0] = self.environment.get_shared_module_dir()
              elif isinstance(t, build.SharedLibrary):
                  outdirs[0] = self.environment.get_shared_lib_dir()
              elif isinstance(t, build.StaticLibrary):
                  outdirs[0] = self.environment.get_static_lib_dir()
              elif isinstance(t, build.Executable):
                  outdirs[0] = self.environment.get_bindir()
              else:
                  assert(isinstance(t, build.BuildTarget))
                  # XXX: Add BuildTarget-specific install dir cases here
                  outdirs[0] = self.environment.get_libdir()
              # Sanity-check the outputs and install_dirs
              num_outdirs, num_out = len(outdirs), len(t.get_outputs())
              if num_outdirs != 1 and num_outdirs != num_out:
                  m = 'Target {!r} has {} outputs: {!r}, but only {} "install_dir"s were found.\n' \
                      "Pass 'false' for outputs that should not be installed and 'true' for\n" \
                      'using the default installation directory for an output.'
                  raise MesonException(m.format(t.name, num_out, t.get_outputs(), num_outdirs))
              # Install the target output(s)
              if isinstance(t, build.BuildTarget):
                  should_strip = self.get_option_for_target('strip', t)
                  # Install primary build output (library/executable/jar, etc)
                  # Done separately because of strip/aliases/rpath
                  if outdirs[0] is not False:
                      i = [self.get_target_filename(t), outdirs[0],
                           t.get_aliases(), should_strip, t.install_rpath]
                      d.targets.append(i)
                      # On toolchains/platforms that use an import library for
                      # linking (separate from the shared library with all the
                      # code), we need to install that too (dll.a/.lib).
                      if (isinstance(t, build.SharedLibrary) or isinstance(t, build.Executable)) and t.get_import_filename():
                          if custom_install_dir:
                              # If the DLL is installed into a custom directory,
                              # install the import library into the same place so
                              # it doesn't go into a surprising place
                              implib_install_dir = outdirs[0]
                          else:
                              implib_install_dir = self.environment.get_import_lib_dir()
                          # Install the import library.
                          i = [self.get_target_filename_for_linking(t),
                               implib_install_dir,
                               # It has no aliases, should not be stripped, and
                               # doesn't have an install_rpath
                               {}, False, '']
                          d.targets.append(i)
                  # Install secondary outputs. Only used for Vala right now.
                  if num_outdirs > 1:
                      for output, outdir in zip(t.get_outputs()[1:], outdirs[1:]):
                          # User requested that we not install this output
                          if outdir is False:
                              continue
                          f = os.path.join(self.get_target_dir(t), output)
                          d.targets.append([f, outdir, {}, False, None])
              elif isinstance(t, build.CustomTarget):
                  # If only one install_dir is specified, assume that all
                  # outputs will be installed into it. This is for
                  # backwards-compatibility and because it makes sense to
                  # avoid repetition since this is a common use-case.
                  #
                  # To selectively install only some outputs, pass `false` as
                  # the install_dir for the corresponding output by index
                  if num_outdirs == 1 and num_out > 1:
                      for output in t.get_outputs():
                          f = os.path.join(self.get_target_dir(t), output)
                          d.targets.append([f, outdirs[0], {}, False, None])
                  else:
                      for output, outdir in zip(t.get_outputs(), outdirs):
                          # User requested that we not install this output
                          if outdir is False:
                              continue
                          f = os.path.join(self.get_target_dir(t), output)
                          d.targets.append([f, outdir, {}, False, None])
  
      def generate_custom_install_script(self, d):
          result = []
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          for i in self.build.install_scripts:
              exe = i['exe']
              args = i['args']
              fixed_args = []
              for a in args:
                  a = a.replace('@SOURCE_ROOT@', srcdir)
                  a = a.replace('@BUILD_ROOT@', builddir)
                  fixed_args.append(a)
              result.append(build.RunScript(exe, fixed_args))
          d.install_scripts = result
  
      def generate_header_install(self, d):
          incroot = self.environment.get_includedir()
          headers = self.build.get_headers()
  
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          for h in headers:
              outdir = h.get_custom_install_dir()
              if outdir is None:
                  outdir = os.path.join(incroot, h.get_install_subdir())
              for f in h.get_sources():
                  if not isinstance(f, File):
                      msg = 'Invalid header type {!r} can\'t be installed'
                      raise MesonException(msg.format(f))
                  abspath = f.absolute_path(srcdir, builddir)
                  i = [abspath, outdir]
                  d.headers.append(i)
  
      def generate_man_install(self, d):
          manroot = self.environment.get_mandir()
          man = self.build.get_man()
          for m in man:
              for f in m.get_sources():
                  num = f.split('.')[-1]
                  subdir = m.get_custom_install_dir()
                  if subdir is None:
                      subdir = os.path.join(manroot, 'man' + num)
                  srcabs = f.absolute_path(self.environment.get_source_dir(), self.environment.get_build_dir())
                  dstabs = os.path.join(subdir, os.path.basename(f.fname) + '.gz')
                  i = [srcabs, dstabs]
                  d.man.append(i)
  
      def generate_data_install(self, d):
          data = self.build.get_data()
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          for de in data:
              assert(isinstance(de, build.Data))
              subdir = de.install_dir
              if not subdir:
                  subdir = os.path.join(self.environment.get_datadir(), self.interpreter.build.project_name)
              for f in de.sources:
                  assert(isinstance(f, mesonlib.File))
                  plain_f = os.path.basename(f.fname)
                  dstabs = os.path.join(subdir, plain_f)
                  i = [f.absolute_path(srcdir, builddir), dstabs, de.install_mode]
                  d.data.append(i)
  
      def generate_subdir_install(self, d):
          for sd in self.build.get_install_subdirs():
              src_dir = os.path.join(self.environment.get_source_dir(),
                                     sd.source_subdir,
                                     sd.installable_subdir).rstrip('/')
              dst_dir = os.path.join(self.environment.get_prefix(),
                                     sd.install_dir)
              if not sd.strip_directory:
                  dst_dir = os.path.join(dst_dir, os.path.basename(src_dir))
              d.install_subdirs.append([src_dir, dst_dir, sd.install_mode,
                                        sd.exclude])
  
      def generate_tests(self, outfile):
          self.serialize_tests()
          cmd = self.environment.get_build_command(True) + ['test', '--no-rebuild']
          if not self.environment.coredata.get_builtin_option('stdsplit'):
              cmd += ['--no-stdsplit']
          if self.environment.coredata.get_builtin_option('errorlogs'):
              cmd += ['--print-errorlogs']
          elem = NinjaBuildElement(self.all_outputs, 'meson-test', 'CUSTOM_COMMAND', ['all', 'PHONY'])
          elem.add_item('COMMAND', cmd)
          elem.add_item('DESC', 'Running all tests.')
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the above-defined meson-test target
          self.create_target_alias('meson-test', outfile)
  
          # And then benchmarks.
          cmd = self.environment.get_build_command(True) + [
              'test', '--benchmark', '--logbase',
              'benchmarklog', '--num-processes=1', '--no-rebuild']
          elem = NinjaBuildElement(self.all_outputs, 'meson-benchmark', 'CUSTOM_COMMAND', ['all', 'PHONY'])
          elem.add_item('COMMAND', cmd)
          elem.add_item('DESC', 'Running benchmark suite.')
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the above-defined meson-benchmark target
          self.create_target_alias('meson-benchmark', outfile)
  
      def generate_rules(self, outfile):
          outfile.write('# Rules for compiling.\n\n')
          self.generate_compile_rules(outfile)
          outfile.write('# Rules for linking.\n\n')
          num_pools = self.environment.coredata.backend_options['backend_max_links'].value
          if num_pools > 0:
              outfile.write('''pool link_pool
    depth = %d
  
  ''' % num_pools)
          if self.environment.is_cross_build():
              self.generate_static_link_rules(True, outfile)
          self.generate_static_link_rules(False, outfile)
          self.generate_dynamic_link_rules(outfile)
          outfile.write('# Other rules\n\n')
          outfile.write('rule CUSTOM_COMMAND\n')
          outfile.write(' command = $COMMAND\n')
          outfile.write(' description = $DESC\n')
          outfile.write(' restat = 1\n\n')
          # Ninja errors out if you have deps = gcc but no depfile, so we must
          # have two rules for custom commands.
          outfile.write('rule CUSTOM_COMMAND_DEP\n')
          outfile.write(' command = $COMMAND\n')
          outfile.write(' description = $DESC\n')
          outfile.write(' deps = gcc\n')
          outfile.write(' depfile = $DEPFILE\n')
          outfile.write(' restat = 1\n\n')
          outfile.write('rule REGENERATE_BUILD\n')
          c = [ninja_quote(quote_func(x)) for x in self.environment.get_build_command()] + \
              ['--internal',
               'regenerate',
               ninja_quote(quote_func(self.environment.get_source_dir())),
               ninja_quote(quote_func(self.environment.get_build_dir()))]
          outfile.write(" command = " + ' '.join(c) + ' --backend ninja\n')
          outfile.write(' description = Regenerating build files.\n')
          outfile.write(' generator = 1\n\n')
          outfile.write('\n')
  
      def generate_phony(self, outfile):
          outfile.write('# Phony build target, always out of date\n')
          outfile.write('build PHONY: phony\n')
          outfile.write('\n')
  
      def generate_jar_target(self, target, outfile):
          fname = target.get_filename()
          outname_rel = os.path.join(self.get_target_dir(target), fname)
          src_list = target.get_sources()
          class_list = []
          compiler = target.compilers['java']
          c = 'c'
          m = ''
          e = ''
          f = 'f'
          main_class = target.get_main_class()
          if main_class != '':
              e = 'e'
          for src in src_list:
              plain_class_path = self.generate_single_java_compile(src, target, compiler, outfile)
              class_list.append(plain_class_path)
          class_dep_list = [os.path.join(self.get_target_private_dir(target), i) for i in class_list]
          jar_rule = 'java_LINKER'
          commands = [c + m + e + f]
          if e != '':
              commands.append(main_class)
          commands.append(self.get_target_filename(target))
          # Java compilation can produce an arbitrary number of output
          # class files for a single source file. Thus tell jar to just
          # grab everything in the final package.
          commands += ['-C', self.get_target_private_dir(target), '.']
          elem = NinjaBuildElement(self.all_outputs, outname_rel, jar_rule, [])
          elem.add_dep(class_dep_list)
          elem.add_item('ARGS', commands)
          elem.write(outfile)
  
      def generate_cs_resource_tasks(self, target, outfile):
          args = []
          deps = []
          for r in target.resources:
              rel_sourcefile = os.path.join(self.build_to_src, target.subdir, r)
              if r.endswith('.resources'):
                  a = '-resource:' + rel_sourcefile
              elif r.endswith('.txt') or r.endswith('.resx'):
                  ofilebase = os.path.splitext(os.path.basename(r))[0] + '.resources'
                  ofilename = os.path.join(self.get_target_private_dir(target), ofilebase)
                  elem = NinjaBuildElement(self.all_outputs, ofilename, "CUSTOM_COMMAND", rel_sourcefile)
                  elem.add_item('COMMAND', ['resgen', rel_sourcefile, ofilename])
                  elem.add_item('DESC', 'Compiling resource %s.' % rel_sourcefile)
                  elem.write(outfile)
                  deps.append(ofilename)
                  a = '-resource:' + ofilename
              else:
                  raise InvalidArguments('Unknown resource file %s.' % r)
              args.append(a)
          return args, deps
  
      def generate_cs_target(self, target, outfile):
          buildtype = self.get_option_for_target('buildtype', target)
          fname = target.get_filename()
          outname_rel = os.path.join(self.get_target_dir(target), fname)
          src_list = target.get_sources()
          compiler = target.compilers['cs']
          rel_srcs = [os.path.normpath(s.rel_to_builddir(self.build_to_src)) for s in src_list]
          deps = []
          commands = CompilerArgs(compiler, target.extra_args.get('cs', []))
          commands += compiler.get_buildtype_args(buildtype)
          if isinstance(target, build.Executable):
              commands.append('-target:exe')
          elif isinstance(target, build.SharedLibrary):
              commands.append('-target:library')
          else:
              raise MesonException('Unknown C# target type.')
          (resource_args, resource_deps) = self.generate_cs_resource_tasks(target, outfile)
          commands += resource_args
          deps += resource_deps
          commands += compiler.get_output_args(outname_rel)
          for l in target.link_targets:
              lname = os.path.join(self.get_target_dir(l), l.get_filename())
              commands += compiler.get_link_args(lname)
              deps.append(lname)
          if '-g' in commands:
              outputs = [outname_rel, outname_rel + '.mdb']
          else:
              outputs = [outname_rel]
          generated_sources = self.get_target_generated_sources(target)
          for rel_src in generated_sources.keys():
              dirpart, fnamepart = os.path.split(rel_src)
              if rel_src.lower().endswith('.cs'):
                  rel_srcs.append(os.path.normpath(rel_src))
              deps.append(os.path.normpath(rel_src))
  
          for dep in target.get_external_deps():
              commands.extend_direct(dep.get_link_args())
          commands += self.build.get_project_args(compiler, target.subproject)
          commands += self.build.get_global_args(compiler)
  
          elem = NinjaBuildElement(self.all_outputs, outputs, 'cs_COMPILER', rel_srcs)
          elem.add_dep(deps)
          elem.add_item('ARGS', commands)
          elem.write(outfile)
  
          self.generate_generator_list_rules(target, outfile)
  
      def generate_single_java_compile(self, src, target, compiler, outfile):
          args = []
          args += compiler.get_buildtype_args(self.get_option_for_target('buildtype', target))
          args += self.build.get_global_args(compiler)
          args += self.build.get_project_args(compiler, target.subproject)
          args += target.get_java_args()
          args += compiler.get_output_args(self.get_target_private_dir(target))
          for i in target.include_dirs:
              for idir in i.get_incdirs():
                  args += ['-sourcepath', os.path.join(self.build_to_src, i.curdir, idir)]
          rel_src = src.rel_to_builddir(self.build_to_src)
          plain_class_path = src.fname[:-4] + 'class'
          rel_obj = os.path.join(self.get_target_private_dir(target), plain_class_path)
          element = NinjaBuildElement(self.all_outputs, rel_obj, compiler.get_language() + '_COMPILER', rel_src)
          element.add_item('ARGS', args)
          element.write(outfile)
          return plain_class_path
  
      def generate_java_link(self, outfile):
          rule = 'rule java_LINKER\n'
          command = ' command = jar $ARGS\n'
          description = ' description = Creating JAR $out.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def determine_dep_vapis(self, target):
          """
          Peek into the sources of BuildTargets we're linking with, and if any of
          them was built with Vala, assume that it also generated a .vapi file of
          the same name as the BuildTarget and return the path to it relative to
          the build directory.
          """
          result = OrderedSet()
          for dep in itertools.chain(target.link_targets, target.link_whole_targets):
              for i in dep.sources:
                  if hasattr(i, 'fname'):
                      i = i.fname
                  if i.endswith('vala'):
                      vapiname = dep.vala_vapi
                      fullname = os.path.join(self.get_target_dir(dep), vapiname)
                      result.add(fullname)
                      break
          return list(result)
  
      def split_vala_sources(self, t):
          """
          Splits the target's sources into .vala, .gs, .vapi, and other sources.
          Handles both pre-existing and generated sources.
  
          Returns a tuple (vala, vapi, others) each of which is a dictionary with
          the keys being the path to the file (relative to the build directory)
          and the value being the object that generated or represents the file.
          """
          vala = OrderedDict()
          vapi = OrderedDict()
          others = OrderedDict()
          othersgen = OrderedDict()
          # Split pre-existing sources
          for s in t.get_sources():
              # BuildTarget sources are always mesonlib.File files which are
              # either in the source root, or generated with configure_file and
              # in the build root
              if not isinstance(s, File):
                  msg = 'All sources in target {!r} must be of type ' \
                        'mesonlib.File, not {!r}'.format(t, s)
                  raise InvalidArguments(msg)
              f = s.rel_to_builddir(self.build_to_src)
              if s.endswith(('.vala', '.gs')):
                  srctype = vala
              elif s.endswith('.vapi'):
                  srctype = vapi
              else:
                  srctype = others
              srctype[f] = s
          # Split generated sources
          for gensrc in t.get_generated_sources():
              for s in gensrc.get_outputs():
                  f = self.get_target_generated_dir(t, gensrc, s)
                  if s.endswith(('.vala', '.gs')):
                      srctype = vala
                  elif s.endswith('.vapi'):
                      srctype = vapi
                  # Generated non-Vala (C/C++) sources. Won't be used for
                  # generating the Vala compile rule below.
                  else:
                      srctype = othersgen
                  # Duplicate outputs are disastrous
                  if f in srctype and srctype[f] is not gensrc:
                      msg = 'Duplicate output {0!r} from {1!r} {2!r}; ' \
                            'conflicts with {0!r} from {4!r} {3!r}' \
                            ''.format(f, type(gensrc).__name__, gensrc.name,
                                      srctype[f].name, type(srctype[f]).__name__)
                      raise InvalidArguments(msg)
                  # Store 'somefile.vala': GeneratedList (or CustomTarget)
                  srctype[f] = gensrc
          return vala, vapi, (others, othersgen)
  
      def generate_vala_compile(self, target, outfile):
          """Vala is compiled into C. Set up all necessary build steps here."""
          (vala_src, vapi_src, other_src) = self.split_vala_sources(target)
          extra_dep_files = []
          if not vala_src:
              msg = 'Vala library {!r} has no Vala or Genie source files.'
              raise InvalidArguments(msg.format(target.name))
  
          valac = target.compilers['vala']
          c_out_dir = self.get_target_private_dir(target)
          # C files generated by valac
          vala_c_src = []
          # Files generated by valac
          valac_outputs = []
          # All sources that are passed to valac on the commandline
          all_files = list(vapi_src.keys())
          # Passed as --basedir
          srcbasedir = os.path.join(self.build_to_src, target.get_subdir())
          for (vala_file, gensrc) in vala_src.items():
              all_files.append(vala_file)
              # Figure out where the Vala compiler will write the compiled C file
              #
              # If the Vala file is in a subdir of the build dir (in our case
              # because it was generated/built by something else), and is also
              # a subdir of --basedir (because the builddir is in the source
              # tree, and the target subdir is the source root), the subdir
              # components from the source root till the private builddir will be
              # duplicated inside the private builddir. Otherwise, just the
              # basename will be used.
              #
              # If the Vala file is outside the build directory, the paths from
              # the --basedir till the subdir will be duplicated inside the
              # private builddir.
              if isinstance(gensrc, (build.CustomTarget, build.GeneratedList)) or gensrc.is_built:
                  vala_c_file = os.path.splitext(os.path.basename(vala_file))[0] + '.c'
                  # Check if the vala file is in a subdir of --basedir
                  abs_srcbasedir = os.path.join(self.environment.get_source_dir(), target.get_subdir())
                  abs_vala_file = os.path.join(self.environment.get_build_dir(), vala_file)
                  if PurePath(os.path.commonpath((abs_srcbasedir, abs_vala_file))) == PurePath(abs_srcbasedir):
                      vala_c_subdir = PurePath(abs_vala_file).parent.relative_to(abs_srcbasedir)
                      vala_c_file = os.path.join(vala_c_subdir, vala_c_file)
              else:
                  path_to_target = os.path.join(self.build_to_src, target.get_subdir())
                  if vala_file.startswith(path_to_target):
                      vala_c_file = os.path.splitext(os.path.relpath(vala_file, path_to_target))[0] + '.c'
                  else:
                      vala_c_file = os.path.splitext(os.path.basename(vala_file))[0] + '.c'
              # All this will be placed inside the c_out_dir
              vala_c_file = os.path.join(c_out_dir, vala_c_file)
              vala_c_src.append(vala_c_file)
              valac_outputs.append(vala_c_file)
  
          args = self.generate_basic_compiler_args(target, valac)
          args += valac.get_colorout_args(self.environment.coredata.base_options.get('b_colorout').value)
          # Tell Valac to output everything in our private directory. Sadly this
          # means it will also preserve the directory components of Vala sources
          # found inside the build tree (generated sources).
          args += ['--directory', c_out_dir]
          args += ['--basedir', srcbasedir]
          if not isinstance(target, build.Executable):
              # Library name
              args += ['--library', target.name]
              # Outputted header
              hname = os.path.join(self.get_target_dir(target), target.vala_header)
              args += ['--header', hname]
              if self.is_unity(target):
                  # Without this the declarations will get duplicated in the .c
                  # files and cause a build failure when all of them are
                  # #include-d in one .c file.
                  # https://github.com/mesonbuild/meson/issues/1969
                  args += ['--use-header']
              valac_outputs.append(hname)
              # Outputted vapi file
              vapiname = os.path.join(self.get_target_dir(target), target.vala_vapi)
              # Force valac to write the vapi and gir files in the target build dir.
              # Without this, it will write it inside c_out_dir
              args += ['--vapi', os.path.join('..', target.vala_vapi)]
              valac_outputs.append(vapiname)
              target.outputs += [target.vala_header, target.vala_vapi]
              # Install header and vapi to default locations if user requests this
              if len(target.install_dir) > 1 and target.install_dir[1] is True:
                  target.install_dir[1] = self.environment.get_includedir()
              if len(target.install_dir) > 2 and target.install_dir[2] is True:
                  target.install_dir[2] = os.path.join(self.environment.get_datadir(), 'vala', 'vapi')
              # Generate GIR if requested
              if isinstance(target.vala_gir, str):
                  girname = os.path.join(self.get_target_dir(target), target.vala_gir)
                  args += ['--gir', os.path.join('..', target.vala_gir)]
                  valac_outputs.append(girname)
                  target.outputs.append(target.vala_gir)
                  # Install GIR to default location if requested by user
                  if len(target.install_dir) > 3 and target.install_dir[3] is True:
                      target.install_dir[3] = os.path.join(self.environment.get_datadir(), 'gir-1.0')
          # Detect gresources and add --gresources arguments for each
          for (gres, gensrc) in other_src[1].items():
              if isinstance(gensrc, modules.GResourceTarget):
                  gres_xml, = self.get_custom_target_sources(gensrc)
                  args += ['--gresources=' + gres_xml]
          extra_args = []
  
          for a in target.extra_args.get('vala', []):
              if isinstance(a, File):
                  relname = a.rel_to_builddir(self.build_to_src)
                  extra_dep_files.append(relname)
                  extra_args.append(relname)
              else:
                  extra_args.append(a)
          dependency_vapis = self.determine_dep_vapis(target)
          extra_dep_files += dependency_vapis
          args += extra_args
          element = NinjaBuildElement(self.all_outputs, valac_outputs,
                                      valac.get_language() + '_COMPILER',
                                      all_files + dependency_vapis)
          element.add_item('ARGS', args)
          element.add_dep(extra_dep_files)
          element.write(outfile)
          return other_src[0], other_src[1], vala_c_src
  
      def generate_rust_target(self, target, outfile):
          rustc = target.compilers['rust']
          relsrc = []
          for i in target.get_sources():
              if not rustc.can_compile(i):
                  raise InvalidArguments('Rust target %s contains a non-rust source file.' % target.get_basename())
              relsrc.append(i.rel_to_builddir(self.build_to_src))
          target_name = os.path.join(target.subdir, target.get_filename())
          args = ['--crate-type']
          if isinstance(target, build.Executable):
              cratetype = 'bin'
          elif hasattr(target, 'rust_crate_type'):
              cratetype = target.rust_crate_type
          elif isinstance(target, build.SharedLibrary):
              cratetype = 'dylib'
          elif isinstance(target, build.StaticLibrary):
              cratetype = 'rlib'
          else:
              raise InvalidArguments('Unknown target type for rustc.')
          args.append(cratetype)
          args += ['--crate-name', target.name]
          args += rustc.get_buildtype_args(self.get_option_for_target('buildtype', target))
          depfile = os.path.join(target.subdir, target.name + '.d')
          args += ['--emit', 'dep-info={}'.format(depfile), '--emit', 'link']
          args += target.get_extra_args('rust')
          args += ['-o', os.path.join(target.subdir, target.get_filename())]
          orderdeps = [os.path.join(t.subdir, t.get_filename()) for t in target.link_targets]
          linkdirs = OrderedDict()
          for d in target.link_targets:
              linkdirs[d.subdir] = True
              # specify `extern CRATE_NAME=OUTPUT_FILE` for each Rust
              # dependency, so that collisions with libraries in rustc's
              # sysroot don't cause ambiguity
              args += ['--extern', '{}={}'.format(d.name, os.path.join(d.subdir, d.filename))]
          for d in linkdirs.keys():
              if d == '':
                  d = '.'
              args += ['-L', d]
          has_shared_deps = False
          for dep in target.get_dependencies():
              if isinstance(dep, build.SharedLibrary):
                  has_shared_deps = True
          if isinstance(target, build.SharedLibrary) or has_shared_deps:
              # add prefer-dynamic if any of the Rust libraries we link
              # against are dynamic, otherwise we'll end up with
              # multiple implementations of crates
              args += ['-C', 'prefer-dynamic']
  
              # build the usual rpath arguments as well...
  
              # Set runtime-paths so we can run executables without needing to set
              # LD_LIBRARY_PATH, etc in the environment. Doesn't work on Windows.
              if '/' in target.name or '\\' in target.name:
                  # Target names really should not have slashes in them, but
                  # unfortunately we did not check for that and some downstream projects
                  # now have them. Once slashes are forbidden, remove this bit.
                  target_slashname_workaround_dir = os.path.join(os.path.dirname(target.name),
                                                                 self.get_target_dir(target))
              else:
                  target_slashname_workaround_dir = self.get_target_dir(target)
              rpath_args = rustc.build_rpath_args(self.environment.get_build_dir(),
                                                  target_slashname_workaround_dir,
                                                  self.determine_rpath_dirs(target),
                                                  target.build_rpath,
                                                  target.install_rpath)
              # ... but then add rustc's sysroot to account for rustup
              # installations
              for rpath_arg in rpath_args:
                  args += ['-C', 'link-arg=' + rpath_arg + ':' + os.path.join(rustc.get_sysroot(), 'lib')]
          crstr = ''
          if target.is_cross:
              crstr = '_CROSS'
          compiler_name = 'rust%s_COMPILER' % crstr
          element = NinjaBuildElement(self.all_outputs, target_name, compiler_name, relsrc)
          if len(orderdeps) > 0:
              element.add_orderdep(orderdeps)
          element.add_item('ARGS', args)
          element.add_item('targetdep', depfile)
          element.add_item('cratetype', cratetype)
          element.write(outfile)
          if isinstance(target, build.SharedLibrary):
              self.generate_shsym(outfile, target)
  
      def swift_module_file_name(self, target):
          return os.path.join(self.get_target_private_dir(target),
                              self.target_swift_modulename(target) + '.swiftmodule')
  
      def target_swift_modulename(self, target):
          return target.name
  
      def is_swift_target(self, target):
          for s in target.sources:
              if s.endswith('swift'):
                  return True
          return False
  
      def determine_swift_dep_modules(self, target):
          result = []
          for l in target.link_targets:
              if self.is_swift_target(l):
                  result.append(self.swift_module_file_name(l))
          return result
  
      def determine_swift_dep_dirs(self, target):
          result = []
          for l in target.link_targets:
              result.append(self.get_target_private_dir_abs(l))
          return result
  
      def get_swift_link_deps(self, target):
          result = []
          for l in target.link_targets:
              result.append(self.get_target_filename(l))
          return result
  
      def split_swift_generated_sources(self, target):
          all_srcs = self.get_target_generated_sources(target)
          srcs = []
          others = []
          for i in all_srcs:
              if i.endswith('.swift'):
                  srcs.append(i)
              else:
                  others.append(i)
          return srcs, others
  
      def generate_swift_target(self, target, outfile):
          module_name = self.target_swift_modulename(target)
          swiftc = target.compilers['swift']
          abssrc = []
          abs_headers = []
          header_imports = []
          for i in target.get_sources():
              if swiftc.can_compile(i):
                  relsrc = i.rel_to_builddir(self.build_to_src)
                  abss = os.path.normpath(os.path.join(self.environment.get_build_dir(), relsrc))
                  abssrc.append(abss)
              elif self.environment.is_header(i):
                  relh = i.rel_to_builddir(self.build_to_src)
                  absh = os.path.normpath(os.path.join(self.environment.get_build_dir(), relh))
                  abs_headers.append(absh)
                  header_imports += swiftc.get_header_import_args(absh)
              else:
                  raise InvalidArguments('Swift target %s contains a non-swift source file.' % target.get_basename())
          os.makedirs(self.get_target_private_dir_abs(target), exist_ok=True)
          compile_args = swiftc.get_compile_only_args()
          compile_args += swiftc.get_module_args(module_name)
          compile_args += self.build.get_project_args(swiftc, target.subproject)
          compile_args += self.build.get_global_args(swiftc)
          for i in reversed(target.get_include_dirs()):
              basedir = i.get_curdir()
              for d in i.get_incdirs():
                  if d not in ('', '.'):
                      expdir = os.path.join(basedir, d)
                  else:
                      expdir = basedir
                  srctreedir = os.path.normpath(os.path.join(self.environment.get_build_dir(), self.build_to_src, expdir))
                  sargs = swiftc.get_include_args(srctreedir)
                  compile_args += sargs
          link_args = swiftc.get_output_args(os.path.join(self.environment.get_build_dir(), self.get_target_filename(target)))
          link_args += self.build.get_project_link_args(swiftc, target.subproject)
          link_args += self.build.get_global_link_args(swiftc)
          rundir = self.get_target_private_dir(target)
          out_module_name = self.swift_module_file_name(target)
          in_module_files = self.determine_swift_dep_modules(target)
          abs_module_dirs = self.determine_swift_dep_dirs(target)
          module_includes = []
          for x in abs_module_dirs:
              module_includes += swiftc.get_include_args(x)
          link_deps = self.get_swift_link_deps(target)
          abs_link_deps = [os.path.join(self.environment.get_build_dir(), x) for x in link_deps]
          for d in target.link_targets:
              reldir = self.get_target_dir(d)
              if reldir == '':
                  reldir = '.'
              link_args += ['-L', os.path.normpath(os.path.join(self.environment.get_build_dir(), reldir))]
          (rel_generated, _) = self.split_swift_generated_sources(target)
          abs_generated = [os.path.join(self.environment.get_build_dir(), x) for x in rel_generated]
          # We need absolute paths because swiftc needs to be invoked in a subdir
          # and this is the easiest way about it.
          objects = [] # Relative to swift invocation dir
          rel_objects = [] # Relative to build.ninja
          for i in abssrc + abs_generated:
              base = os.path.basename(i)
              oname = os.path.splitext(base)[0] + '.o'
              objects.append(oname)
              rel_objects.append(os.path.join(self.get_target_private_dir(target), oname))
  
          # Swiftc does not seem to be able to emit objects and module files in one go.
          elem = NinjaBuildElement(self.all_outputs, rel_objects,
                                   'swift_COMPILER',
                                   abssrc)
          elem.add_dep(in_module_files + rel_generated)
          elem.add_dep(abs_headers)
          elem.add_item('ARGS', compile_args + header_imports + abs_generated + module_includes)
          elem.add_item('RUNDIR', rundir)
          elem.write(outfile)
          elem = NinjaBuildElement(self.all_outputs, out_module_name,
                                   'swift_COMPILER',
                                   abssrc)
          elem.add_dep(in_module_files + rel_generated)
          elem.add_item('ARGS', compile_args + abs_generated + module_includes + swiftc.get_mod_gen_args())
          elem.add_item('RUNDIR', rundir)
          elem.write(outfile)
          if isinstance(target, build.StaticLibrary):
              elem = self.generate_link(target, outfile, self.get_target_filename(target),
                                        rel_objects, self.build.static_linker)
              elem.write(outfile)
          elif isinstance(target, build.Executable):
              elem = NinjaBuildElement(self.all_outputs, self.get_target_filename(target), 'swift_COMPILER', [])
              elem.add_dep(rel_objects)
              elem.add_dep(link_deps)
              elem.add_item('ARGS', link_args + swiftc.get_std_exe_link_args() + objects + abs_link_deps)
              elem.add_item('RUNDIR', rundir)
              elem.write(outfile)
          else:
              raise MesonException('Swift supports only executable and static library targets.')
  
      def generate_static_link_rules(self, is_cross, outfile):
          num_pools = self.environment.coredata.backend_options['backend_max_links'].value
          if 'java' in self.build.compilers:
              if not is_cross:
                  self.generate_java_link(outfile)
          if is_cross:
              if self.environment.cross_info.need_cross_compiler():
                  static_linker = self.build.static_cross_linker
              else:
                  static_linker = self.build.static_linker
              crstr = '_CROSS'
          else:
              static_linker = self.build.static_linker
              crstr = ''
          if static_linker is None:
              return
          rule = 'rule STATIC%s_LINKER\n' % crstr
          # We don't use @file.rsp on Windows with ArLinker because llvm-ar and
          # gcc-ar blindly pass the --plugin argument to `ar` and you cannot pass
          # options as arguments while using the @file.rsp syntax.
          # See: https://github.com/mesonbuild/meson/issues/1646
          if mesonlib.is_windows() and not isinstance(static_linker, ArLinker):
              command_template = ''' command = {executable} @$out.rsp
   rspfile = $out.rsp
   rspfile_content = $LINK_ARGS {output_args} $in
  '''
          else:
              command_template = ' command = {executable} $LINK_ARGS {output_args} $in\n'
          cmdlist = []
          # FIXME: Must normalize file names with pathlib.Path before writing
          #        them out to fix this properly on Windows. See:
          # https://github.com/mesonbuild/meson/issues/1517
          # https://github.com/mesonbuild/meson/issues/1526
          if isinstance(static_linker, ArLinker) and not mesonlib.is_windows():
              # `ar` has no options to overwrite archives. It always appends,
              # which is never what we want. Delete an existing library first if
              # it exists. https://github.com/mesonbuild/meson/issues/1355
              cmdlist = [execute_wrapper, rmfile_prefix.format('$out')]
          cmdlist += static_linker.get_exelist()
          command = command_template.format(
              executable=' '.join(cmdlist),
              output_args=' '.join(static_linker.get_output_args('$out')))
          description = ' description = Linking static target $out.\n\n'
          outfile.write(rule)
          outfile.write(command)
          if num_pools > 0:
              outfile.write(' pool = link_pool\n')
          outfile.write(description)
  
      def generate_dynamic_link_rules(self, outfile):
          num_pools = self.environment.coredata.backend_options['backend_max_links'].value
          ctypes = [(self.build.compilers, False)]
          if self.environment.is_cross_build():
              if self.environment.cross_info.need_cross_compiler():
                  ctypes.append((self.build.cross_compilers, True))
              else:
                  # Native compiler masquerades as the cross compiler.
                  ctypes.append((self.build.compilers, True))
          else:
              ctypes.append((self.build.cross_compilers, True))
          for (complist, is_cross) in ctypes:
              for langname, compiler in complist.items():
                  if langname == 'java' \
                          or langname == 'vala' \
                          or langname == 'rust' \
                          or langname == 'cs':
                      continue
                  crstr = ''
                  cross_args = []
                  if is_cross:
                      crstr = '_CROSS'
                      try:
                          cross_args = self.environment.cross_info.config['properties'][langname + '_link_args']
                      except KeyError:
                          pass
                  rule = 'rule %s%s_LINKER\n' % (langname, crstr)
                  if mesonlib.is_windows():
                      command_template = ''' command = {executable} @$out.rsp
   rspfile = $out.rsp
   rspfile_content = $ARGS  {output_args} $in $LINK_ARGS {cross_args} $aliasing
  '''
                  else:
                      command_template = ' command = {executable} $ARGS {output_args} $in $LINK_ARGS {cross_args} $aliasing\n'
                  command = command_template.format(
                      executable=' '.join(compiler.get_linker_exelist()),
                      cross_args=' '.join(cross_args),
                      output_args=' '.join(compiler.get_linker_output_args('$out'))
                  )
                  description = ' description = Linking target $out.\n'
                  outfile.write(rule)
                  outfile.write(command)
                  if num_pools > 0:
                      outfile.write(' pool = link_pool\n')
                  outfile.write(description)
                  outfile.write('\n')
          outfile.write('\n')
          args = [ninja_quote(quote_func(x)) for x in self.environment.get_build_command()] + \
              ['--internal',
               'symbolextractor',
               '$in',
               '$out']
          symrule = 'rule SHSYM\n'
          symcmd = ' command = ' + ' '.join(args) + ' $CROSS\n'
          synstat = ' restat = 1\n'
          syndesc = ' description = Generating symbol file $out.\n'
          outfile.write(symrule)
          outfile.write(symcmd)
          outfile.write(synstat)
          outfile.write(syndesc)
          outfile.write('\n')
  
      def generate_java_compile_rule(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Java object $in.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_cs_compile_rule(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
  
          if mesonlib.is_windows():
              command = ''' command = {executable}  @$out.rsp
   rspfile = $out.rsp
   rspfile_content =  $ARGS  $in
  '''.format(executable=invoc)
          else:
              command = ' command = %s $ARGS $in\n' % invoc
  
          description = ' description = Compiling C Sharp target $out.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_vala_compile_rules(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Vala source $in.\n'
          restat = ' restat = 1\n' # ValaC does this always to take advantage of it.
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write(restat)
          outfile.write('\n')
  
      def generate_rust_compile_rules(self, compiler, outfile, is_cross):
          crstr = ''
          if is_cross:
              crstr = '_CROSS'
          rule = 'rule %s%s_COMPILER\n' % (compiler.get_language(), crstr)
          invoc = ' '.join([ninja_quote(i) for i in compiler.get_exelist()])
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Rust source $in.\n'
          depfile = ' depfile = $targetdep\n'
  
          depstyle = ' deps = gcc\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write(depfile)
          outfile.write(depstyle)
          outfile.write('\n')
  
      def generate_swift_compile_rules(self, compiler, outfile):
          rule = 'rule %s_COMPILER\n' % compiler.get_language()
          full_exe = [ninja_quote(x) for x in self.environment.get_build_command()] + [
              '--internal',
              'dirchanger',
              '$RUNDIR',
          ]
          invoc = (' '.join(full_exe) + ' ' +
                   ' '.join(ninja_quote(i) for i in compiler.get_exelist()))
          command = ' command = %s $ARGS $in\n' % invoc
          description = ' description = Compiling Swift source $in.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_fortran_dep_hack(self, outfile):
          if mesonlib.is_windows():
              cmd = 'cmd /C ""'
          else:
              cmd = 'true'
          template = '''# Workaround for these issues:
  # https://groups.google.com/forum/#!topic/ninja-build/j-2RfBIOd_8
  # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47485
  rule FORTRAN_DEP_HACK
   command = %s
   description = Dep hack
   restat = 1
  
  '''
          outfile.write(template % cmd)
  
      def generate_llvm_ir_compile_rule(self, compiler, is_cross, outfile):
          if getattr(self, 'created_llvm_ir_rule', False):
              return
          rule = 'rule llvm_ir{}_COMPILER\n'.format('_CROSS' if is_cross else '')
          if mesonlib.is_windows():
              command_template = ' command = {executable} @$out.rsp\n' \
                                 ' rspfile = $out.rsp\n' \
                                 ' rspfile_content = {cross_args} $ARGS {output_args} {compile_only_args} $in\n'
          else:
              command_template = ' command = {executable} {cross_args} $ARGS {output_args} {compile_only_args} $in\n'
          command = command_template.format(
              executable=' '.join([ninja_quote(i) for i in compiler.get_exelist()]),
              cross_args=' '.join(self.get_cross_info_lang_args(compiler.language, is_cross)),
              output_args=' '.join(compiler.get_output_args('$out')),
              compile_only_args=' '.join(compiler.get_compile_only_args())
          )
          description = ' description = Compiling LLVM IR object $in.\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(description)
          outfile.write('\n')
          self.created_llvm_ir_rule = True
  
      def get_cross_info_lang_args(self, lang, is_cross):
          if is_cross:
              try:
                  return self.environment.cross_info.config['properties'][lang + '_args']
              except KeyError:
                  pass
          return []
  
      def generate_compile_rule_for(self, langname, compiler, is_cross, outfile):
          if langname == 'java':
              if not is_cross:
                  self.generate_java_compile_rule(compiler, outfile)
              return
          if langname == 'cs':
              if not is_cross:
                  self.generate_cs_compile_rule(compiler, outfile)
              return
          if langname == 'vala':
              if not is_cross:
                  self.generate_vala_compile_rules(compiler, outfile)
              return
          if langname == 'rust':
              self.generate_rust_compile_rules(compiler, outfile, is_cross)
              return
          if langname == 'swift':
              if not is_cross:
                  self.generate_swift_compile_rules(compiler, outfile)
              return
          if langname == 'fortran':
              self.generate_fortran_dep_hack(outfile)
          if is_cross:
              crstr = '_CROSS'
          else:
              crstr = ''
          rule = 'rule %s%s_COMPILER\n' % (langname, crstr)
          depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
          quoted_depargs = []
          for d in depargs:
              if d != '$out' and d != '$in':
                  d = quote_func(d)
              quoted_depargs.append(d)
          cross_args = self.get_cross_info_lang_args(langname, is_cross)
          if mesonlib.is_windows():
              command_template = ''' command = {executable} @$out.rsp
   rspfile = $out.rsp
   rspfile_content = {cross_args} $ARGS {dep_args} {output_args} {compile_only_args} $in
  '''
          else:
              command_template = ' command = {executable} {cross_args} $ARGS {dep_args} {output_args} {compile_only_args} $in\n'
          command = command_template.format(
              executable=' '.join([ninja_quote(i) for i in compiler.get_exelist()]),
              cross_args=' '.join(cross_args),
              dep_args=' '.join(quoted_depargs),
              output_args=' '.join(compiler.get_output_args('$out')),
              compile_only_args=' '.join(compiler.get_compile_only_args())
          )
          description = ' description = Compiling %s object $out.\n' % compiler.get_display_language()
          if compiler.get_id() == 'msvc':
              deps = ' deps = msvc\n'
          else:
              deps = ' deps = gcc\n'
              deps += ' depfile = $DEPFILE\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(deps)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_pch_rule_for(self, langname, compiler, is_cross, outfile):
          if langname != 'c' and langname != 'cpp':
              return
          if is_cross:
              crstr = '_CROSS'
          else:
              crstr = ''
          rule = 'rule %s%s_PCH\n' % (langname, crstr)
          depargs = compiler.get_dependency_gen_args('$out', '$DEPFILE')
          cross_args = []
          if is_cross:
              try:
                  cross_args = self.environment.cross_info.config['properties'][langname + '_args']
              except KeyError:
                  pass
  
          quoted_depargs = []
          for d in depargs:
              if d != '$out' and d != '$in':
                  d = quote_func(d)
              quoted_depargs.append(d)
          if compiler.get_id() == 'msvc':
              output = ''
          else:
              output = ' '.join(compiler.get_output_args('$out'))
          command = " command = {executable} {cross_args} $ARGS {dep_args} {output_args} {compile_only_args} $in\n".format(
              executable=' '.join(compiler.get_exelist()),
              cross_args=' '.join(cross_args),
              dep_args=' '.join(quoted_depargs),
              output_args=output,
              compile_only_args=' '.join(compiler.get_compile_only_args())
          )
          description = ' description = Precompiling header %s.\n' % '$in'
          if compiler.get_id() == 'msvc':
              deps = ' deps = msvc\n'
          else:
              deps = ' deps = gcc\n'
              deps += ' depfile = $DEPFILE\n'
          outfile.write(rule)
          outfile.write(command)
          outfile.write(deps)
          outfile.write(description)
          outfile.write('\n')
  
      def generate_compile_rules(self, outfile):
          for langname, compiler in self.build.compilers.items():
              if compiler.get_id() == 'clang':
                  self.generate_llvm_ir_compile_rule(compiler, False, outfile)
              self.generate_compile_rule_for(langname, compiler, False, outfile)
              self.generate_pch_rule_for(langname, compiler, False, outfile)
          if self.environment.is_cross_build():
              # In case we are going a target-only build, make the native compilers
              # masquerade as cross compilers.
              if self.environment.cross_info.need_cross_compiler():
                  cclist = self.build.cross_compilers
              else:
                  cclist = self.build.compilers
              for langname, compiler in cclist.items():
                  if compiler.get_id() == 'clang':
                      self.generate_llvm_ir_compile_rule(compiler, True, outfile)
                  self.generate_compile_rule_for(langname, compiler, True, outfile)
                  self.generate_pch_rule_for(langname, compiler, True, outfile)
          outfile.write('\n')
  
      def generate_generator_list_rules(self, target, outfile):
          # CustomTargets have already written their rules and
          # CustomTargetIndexes don't actually get generated, so write rules for
          # GeneratedLists here
          for genlist in target.get_generated_sources():
              if isinstance(genlist, (build.CustomTarget, build.CustomTargetIndex)):
                  continue
              self.generate_genlist_for_target(genlist, target, outfile)
  
      def replace_paths(self, target, args, override_subdir=None):
          if override_subdir:
              source_target_dir = os.path.join(self.build_to_src, override_subdir)
          else:
              source_target_dir = self.get_target_source_dir(target)
          relout = self.get_target_private_dir(target)
          args = [x.replace("@SOURCE_DIR@", self.build_to_src).replace("@BUILD_DIR@", relout)
                  for x in args]
          args = [x.replace("@CURRENT_SOURCE_DIR@", source_target_dir) for x in args]
          args = [x.replace("@SOURCE_ROOT@", self.build_to_src).replace("@BUILD_ROOT@", '.')
                  for x in args]
          args = [x.replace('\\', '/') for x in args]
          return args
  
      def generate_genlist_for_target(self, genlist, target, outfile):
          generator = genlist.get_generator()
          subdir = genlist.subdir
          exe = generator.get_exe()
          exe_arr = self.exe_object_to_cmd_array(exe)
          infilelist = genlist.get_inputs()
          outfilelist = genlist.get_outputs()
          extra_dependencies = [os.path.join(self.build_to_src, i) for i in genlist.extra_depends]
          for i in range(len(infilelist)):
              if len(generator.outputs) == 1:
                  sole_output = os.path.join(self.get_target_private_dir(target), outfilelist[i])
              else:
                  sole_output = ''
              curfile = infilelist[i]
              infilename = curfile.rel_to_builddir(self.build_to_src)
              base_args = generator.get_arglist(infilename)
              outfiles = genlist.get_outputs_for(curfile)
              outfiles = [os.path.join(self.get_target_private_dir(target), of) for of in outfiles]
              if generator.depfile is None:
                  rulename = 'CUSTOM_COMMAND'
                  args = base_args
              else:
                  rulename = 'CUSTOM_COMMAND_DEP'
                  depfilename = generator.get_dep_outname(infilename)
                  depfile = os.path.join(self.get_target_private_dir(target), depfilename)
                  args = [x.replace('@DEPFILE@', depfile) for x in base_args]
              args = [x.replace("@INPUT@", infilename).replace('@OUTPUT@', sole_output)
                      for x in args]
              args = self.replace_outputs(args, self.get_target_private_dir(target), outfilelist)
              # We have consumed output files, so drop them from the list of remaining outputs.
              if sole_output == '':
                  outfilelist = outfilelist[len(generator.outputs):]
              args = self.replace_paths(target, args, override_subdir=subdir)
              cmdlist = exe_arr + self.replace_extra_args(args, genlist)
              if generator.capture:
                  exe_data = self.serialize_executable(
                      cmdlist[0],
                      cmdlist[1:],
                      self.environment.get_build_dir(),
                      capture=outfiles[0]
                  )
                  cmd = self.environment.get_build_command() + ['--internal', 'exe', exe_data]
                  abs_pdir = os.path.join(self.environment.get_build_dir(), self.get_target_dir(target))
                  os.makedirs(abs_pdir, exist_ok=True)
              else:
                  cmd = cmdlist
  
              elem = NinjaBuildElement(self.all_outputs, outfiles, rulename, infilename)
              if generator.depfile is not None:
                  elem.add_item('DEPFILE', depfile)
              if len(extra_dependencies) > 0:
                  elem.add_dep(extra_dependencies)
              elem.add_item('DESC', 'Generating {!r}.'.format(sole_output))
              if isinstance(exe, build.BuildTarget):
                  elem.add_dep(self.get_target_filename(exe))
              elem.add_item('COMMAND', cmd)
              elem.write(outfile)
  
      def scan_fortran_module_outputs(self, target):
          compiler = None
          for lang, c in self.build.compilers.items():
              if lang == 'fortran':
                  compiler = c
                  break
          if compiler is None:
              self.fortran_deps[target.get_basename()] = {}
              return
          modre = re.compile(r"\s*module\s+(\w+)", re.IGNORECASE)
          module_files = {}
          for s in target.get_sources():
              # FIXME, does not work for Fortran sources generated by
              # custom_target() and generator() as those are run after
              # the configuration (configure_file() is OK)
              if not compiler.can_compile(s):
                  continue
              filename = s.absolute_path(self.environment.get_source_dir(),
                                         self.environment.get_build_dir())
              # Some Fortran editors save in weird encodings,
              # but all the parts we care about are in ASCII.
              with open(filename, errors='ignore') as f:
                  for line in f:
                      modmatch = modre.match(line)
                      if modmatch is not None:
                          modname = modmatch.group(1).lower()
                          if modname == 'procedure':
                              # MODULE PROCEDURE construct
                              continue
                          if modname in module_files:
                              raise InvalidArguments(
                                  'Namespace collision: module %s defined in '
                                  'two files %s and %s.' %
                                  (modname, module_files[modname], s))
                          module_files[modname] = s
          self.fortran_deps[target.get_basename()] = module_files
  
      def get_fortran_deps(self, compiler, src, target):
          mod_files = []
          usere = re.compile(r"\s*use\s+(\w+)", re.IGNORECASE)
          dirname = self.get_target_private_dir(target)
          tdeps = self.fortran_deps[target.get_basename()]
          with open(src) as f:
              for line in f:
                  usematch = usere.match(line)
                  if usematch is not None:
                      usename = usematch.group(1).lower()
                      if usename not in tdeps:
                          # The module is not provided by any source file. This
                          # is due to:
                          #   a) missing file/typo/etc
                          #   b) using a module provided by the compiler, such as
                          #      OpenMP
                          # There's no easy way to tell which is which (that I
                          # know of) so just ignore this and go on. Ideally we
                          # would print a warning message to the user but this is
                          # a common occurrence, which would lead to lots of
                          # distracting noise.
                          continue
                      mod_source_file = tdeps[usename]
                      # Check if a source uses a module it exports itself.
                      # Potential bug if multiple targets have a file with
                      # the same name.
                      if mod_source_file.fname == os.path.basename(src):
                          continue
                      mod_name = compiler.module_name_to_filename(
                          usematch.group(1))
                      mod_files.append(os.path.join(dirname, mod_name))
          return mod_files
  
      def get_cross_stdlib_args(self, target, compiler):
          if not target.is_cross:
              return []
          if not self.environment.cross_info.has_stdlib(compiler.language):
              return []
          return compiler.get_no_stdinc_args()
  
      def get_compile_debugfile_args(self, compiler, target, objfile):
          if compiler.id != 'msvc':
              return []
          # The way MSVC uses PDB files is documented exactly nowhere so
          # the following is what we have been able to decipher via
          # reverse engineering.
          #
          # Each object file gets the path of its PDB file written
          # inside it.  This can be either the final PDB (for, say,
          # foo.exe) or an object pdb (for foo.obj). If the former, then
          # each compilation step locks the pdb file for writing, which
          # is a bottleneck and object files from one target can not be
          # used in a different target. The latter seems to be the
          # sensible one (and what Unix does) but there is a catch.  If
          # you try to use precompiled headers MSVC will error out
          # because both source and pch pdbs go in the same file and
          # they must be the same.
          #
          # This means:
          #
          # - pch files must be compiled anew for every object file (negating
          #   the entire point of having them in the first place)
          # - when using pch, output must go to the target pdb
          #
          # Since both of these are broken in some way, use the one that
          # works for each target. This unfortunately means that you
          # can't combine pch and object extraction in a single target.
          #
          # PDB files also lead to filename collisions. A target foo.exe
          # has a corresponding foo.pdb. A shared library foo.dll _also_
          # has pdb file called foo.pdb. So will a static library
          # foo.lib, which clobbers both foo.pdb _and_ the dll file's
          # export library called foo.lib (by default, currently we name
          # them libfoo.a to avoidt this issue). You can give the files
          # unique names such as foo_exe.pdb but VC also generates a
          # bunch of other files which take their names from the target
          # basename (i.e. "foo") and stomp on each other.
          #
          # CMake solves this problem by doing two things. First of all
          # static libraries do not generate pdb files at
          # all. Presumably you don't need them and VC is smart enough
          # to look up the original data when linking (speculation, not
          # tested). The second solution is that you can only have
          # target named "foo" as an exe, shared lib _or_ static
          # lib. This makes filename collisions not happen. The downside
          # is that you can't have an executable foo that uses a shared
          # library libfoo.so, which is a common idiom on Unix.
          #
          # If you feel that the above is completely wrong and all of
          # this is actually doable, please send patches.
  
          if target.has_pch():
              tfilename = self.get_target_filename_abs(target)
              return compiler.get_compile_debugfile_args(tfilename, pch=True)
          else:
              return compiler.get_compile_debugfile_args(objfile, pch=False)
  
      def get_link_debugfile_args(self, linker, target, outname):
          return linker.get_link_debugfile_args(outname)
  
      def generate_llvm_ir_compile(self, target, outfile, src):
          compiler = get_compiler_for_source(target.compilers.values(), src)
          commands = CompilerArgs(compiler)
          # Compiler args for compiling this target
          commands += compilers.get_base_compile_args(self.environment.coredata.base_options,
                                                      compiler)
          if isinstance(src, File):
              if src.is_built:
                  src_filename = os.path.join(src.subdir, src.fname)
              else:
                  src_filename = src.fname
          elif os.path.isabs(src):
              src_filename = os.path.basename(src)
          else:
              src_filename = src
          obj_basename = src_filename.replace('/', '_').replace('\\', '_')
          rel_obj = os.path.join(self.get_target_private_dir(target), obj_basename)
          rel_obj += '.' + self.environment.get_object_suffix()
          commands += self.get_compile_debugfile_args(compiler, target, rel_obj)
          if isinstance(src, File) and src.is_built:
              rel_src = src.fname
          elif isinstance(src, File):
              rel_src = src.rel_to_builddir(self.build_to_src)
          else:
              raise InvalidArguments('Invalid source type: {!r}'.format(src))
          # Write the Ninja build command
          compiler_name = 'llvm_ir{}_COMPILER'.format('_CROSS' if target.is_cross else '')
          element = NinjaBuildElement(self.all_outputs, rel_obj, compiler_name, rel_src)
          # Convert from GCC-style link argument naming to the naming used by the
          # current compiler.
          commands = commands.to_native()
          element.add_item('ARGS', commands)
          element.write(outfile)
          return rel_obj
  
      def get_source_dir_include_args(self, target, compiler):
          curdir = target.get_subdir()
          tmppath = os.path.normpath(os.path.join(self.build_to_src, curdir))
          return compiler.get_include_args(tmppath, False)
  
      def get_build_dir_include_args(self, target, compiler):
          curdir = target.get_subdir()
          if curdir == '':
              curdir = '.'
          return compiler.get_include_args(curdir, False)
  
      def get_custom_target_dir_include_args(self, target, compiler):
          custom_target_include_dirs = []
          for i in target.get_generated_sources():
              # Generator output goes into the target private dir which is
              # already in the include paths list. Only custom targets have their
              # own target build dir.
              if not isinstance(i, (build.CustomTarget, build.CustomTargetIndex)):
                  continue
              idir = self.get_target_dir(i)
              if idir not in custom_target_include_dirs:
                  custom_target_include_dirs.append(idir)
          incs = []
          for i in custom_target_include_dirs:
              incs += compiler.get_include_args(i, False)
          return incs
  
      def _generate_single_compile(self, target, compiler, is_generated=False):
          base_proxy = backends.OptionOverrideProxy(target.option_overrides,
                                                    self.environment.coredata.base_options)
          # Create an empty commands list, and start adding arguments from
          # various sources in the order in which they must override each other
          commands = CompilerArgs(compiler)
          # Add compiler args for compiling this target derived from 'base' build
          # options passed on the command-line, in default_options, etc.
          # These have the lowest priority.
          commands += compilers.get_base_compile_args(base_proxy,
                                                      compiler)
          # The code generated by valac is usually crap and has tons of unused
          # variables and such, so disable warnings for Vala C sources.
          no_warn_args = (is_generated == 'vala')
          # Add compiler args and include paths from several sources; defaults,
          # build options, external dependencies, etc.
          commands += self.generate_basic_compiler_args(target, compiler, no_warn_args)
          # Add custom target dirs as includes automatically, but before
          # target-specific include directories.
          # XXX: Not sure if anyone actually uses this? It can cause problems in
          # situations which increase the likelihood for a header name collision,
          # such as in subprojects.
          commands += self.get_custom_target_dir_include_args(target, compiler)
          # Add include dirs from the `include_directories:` kwarg on the target
          # and from `include_directories:` of internal deps of the target.
          #
          # Target include dirs should override internal deps include dirs.
          # This is handled in BuildTarget.process_kwargs()
          #
          # Include dirs from internal deps should override include dirs from
          # external deps and must maintain the order in which they are specified.
          # Hence, we must reverse the list so that the order is preserved.
          for i in reversed(target.get_include_dirs()):
              basedir = i.get_curdir()
              for d in i.get_incdirs():
                  # Avoid superfluous '/.' at the end of paths when d is '.'
                  if d not in ('', '.'):
                      expdir = os.path.join(basedir, d)
                  else:
                      expdir = basedir
                  srctreedir = os.path.join(self.build_to_src, expdir)
                  # Add source subdir first so that the build subdir overrides it
                  sargs = compiler.get_include_args(srctreedir, i.is_system)
                  commands += sargs
                  # There may be include dirs where a build directory has not been
                  # created for some source dir. For example if someone does this:
                  #
                  # inc = include_directories('foo/bar/baz')
                  #
                  # But never subdir()s into the actual dir.
                  if os.path.isdir(os.path.join(self.environment.get_build_dir(), expdir)):
                      bargs = compiler.get_include_args(expdir, i.is_system)
                  else:
                      bargs = []
                  commands += bargs
              for d in i.get_extra_build_dirs():
                  commands += compiler.get_include_args(d, i.is_system)
          # Add per-target compile args, f.ex, `c_args : ['-DFOO']`. We set these
          # near the end since these are supposed to override everything else.
          commands += self.escape_extra_args(compiler,
                                             target.get_extra_args(compiler.get_language()))
          # Add source dir and build dir. Project-specific and target-specific
          # include paths must override per-target compile args, include paths
          # from external dependencies, internal dependencies, and from
          # per-target `include_directories:`
          #
          # We prefer headers in the build dir over the source dir since, for
          # instance, the user might have an srcdir == builddir Autotools build
          # in their source tree. Many projects that are moving to Meson have
          # both Meson and Autotools in parallel as part of the transition.
          if target.implicit_include_directories:
              commands += self.get_source_dir_include_args(target, compiler)
          if target.implicit_include_directories:
              commands += self.get_build_dir_include_args(target, compiler)
          # Finally add the private dir for the target to the include path. This
          # must override everything else and must be the final path added.
          commands += compiler.get_include_args(self.get_target_private_dir(target), False)
          return commands
  
      def generate_single_compile(self, target, outfile, src, is_generated=False, header_deps=[], order_deps=[]):
          """
          Compiles C/C++, ObjC/ObjC++, Fortran, and D sources
          """
          if isinstance(src, str) and src.endswith('.h'):
              raise AssertionError('BUG: sources should not contain headers {!r}'.format(src))
  
          compiler = get_compiler_for_source(target.compilers.values(), src)
          key = (target, compiler, is_generated)
          if key in self.target_arg_cache:
              commands = self.target_arg_cache[key]
          else:
              commands = self._generate_single_compile(target, compiler, is_generated)
              self.target_arg_cache[key] = commands
          commands = CompilerArgs(commands.compiler, commands)
  
          build_dir = self.environment.get_build_dir()
          if isinstance(src, File):
              rel_src = src.rel_to_builddir(self.build_to_src)
              if os.path.isabs(rel_src):
                  # Source files may not be from the source directory if they originate in source-only libraries,
                  # so we can't assert that the absolute path is anywhere in particular.
                  if src.is_built:
                      assert rel_src.startswith(build_dir)
                      rel_src = rel_src[len(build_dir) + 1:]
          elif is_generated:
              raise AssertionError('BUG: broken generated source file handling for {!r}'.format(src))
          else:
              raise InvalidArguments('Invalid source type: {!r}'.format(src))
          obj_basename = self.object_filename_from_source(target, src, self.is_unity(target))
          rel_obj = os.path.join(self.get_target_private_dir(target), obj_basename)
          dep_file = compiler.depfile_for_object(rel_obj)
  
          # Add MSVC debug file generation compile flags: /Fd /FS
          commands += self.get_compile_debugfile_args(compiler, target, rel_obj)
  
          # PCH handling
          if self.environment.coredata.base_options.get('b_pch', False):
              commands += self.get_pch_include_args(compiler, target)
              pchlist = target.get_pch(compiler.language)
          else:
              pchlist = []
          if not pchlist:
              pch_dep = []
          elif compiler.id == 'intel':
              pch_dep = []
          else:
              arr = []
              i = os.path.join(self.get_target_private_dir(target), compiler.get_pch_name(pchlist[0]))
              arr.append(i)
              pch_dep = arr
  
          crstr = ''
          if target.is_cross:
              crstr = '_CROSS'
          compiler_name = '%s%s_COMPILER' % (compiler.get_language(), crstr)
          extra_deps = []
          if compiler.get_language() == 'fortran':
              # Can't read source file to scan for deps if it's generated later
              # at build-time. Skip scanning for deps, and just set the module
              # outdir argument instead.
              # https://github.com/mesonbuild/meson/issues/1348
              if not is_generated:
                  abs_src = os.path.join(build_dir, rel_src)
                  extra_deps += self.get_fortran_deps(compiler, abs_src, target)
              # Dependency hack. Remove once multiple outputs in Ninja is fixed:
              # https://groups.google.com/forum/#!topic/ninja-build/j-2RfBIOd_8
              for modname, srcfile in self.fortran_deps[target.get_basename()].items():
                  modfile = os.path.join(self.get_target_private_dir(target),
                                         compiler.module_name_to_filename(modname))
                  if srcfile == src:
                      depelem = NinjaBuildElement(self.all_outputs, modfile, 'FORTRAN_DEP_HACK', rel_obj)
                      depelem.write(outfile)
              commands += compiler.get_module_outdir_args(self.get_target_private_dir(target))
  
          if compiler.language == 'd':
              commands += compiler.get_feature_args(target.d_features, self.build_to_src)
  
          element = NinjaBuildElement(self.all_outputs, rel_obj, compiler_name, rel_src)
          for d in header_deps:
              if isinstance(d, File):
                  d = d.rel_to_builddir(self.build_to_src)
              elif not self.has_dir_part(d):
                  d = os.path.join(self.get_target_private_dir(target), d)
              element.add_dep(d)
          for d in extra_deps:
              element.add_dep(d)
          for d in order_deps:
              if isinstance(d, File):
                  d = d.rel_to_builddir(self.build_to_src)
              elif not self.has_dir_part(d):
                  d = os.path.join(self.get_target_private_dir(target), d)
              element.add_orderdep(d)
          element.add_orderdep(pch_dep)
          # Convert from GCC-style link argument naming to the naming used by the
          # current compiler.
          commands = commands.to_native()
          for i in self.get_fortran_orderdeps(target, compiler):
              element.add_orderdep(i)
          element.add_item('DEPFILE', dep_file)
          element.add_item('ARGS', commands)
          element.write(outfile)
          return rel_obj
  
      def has_dir_part(self, fname):
          # FIXME FIXME: The usage of this is a terrible and unreliable hack
          if isinstance(fname, File):
              return fname.subdir != ''
          return '/' in fname or '\\' in fname
  
      # Fortran is a bit weird (again). When you link against a library, just compiling a source file
      # requires the mod files that are output when single files are built. To do this right we would need to
      # scan all inputs and write out explicit deps for each file. That is stoo slow and too much effort so
      # instead just have an ordered dependency on the library. This ensures all required mod files are created.
      # The real deps are then detected via dep file generation from the compiler. This breaks on compilers that
      # produce incorrect dep files but such is life.
      def get_fortran_orderdeps(self, target, compiler):
          if compiler.language != 'fortran':
              return []
          return [os.path.join(self.get_target_dir(lt), lt.get_filename()) for lt in target.link_targets]
  
      def generate_msvc_pch_command(self, target, compiler, pch):
          if len(pch) != 2:
              raise MesonException('MSVC requires one header and one source to produce precompiled headers.')
          header = pch[0]
          source = pch[1]
          pchname = compiler.get_pch_name(header)
          dst = os.path.join(self.get_target_private_dir(target), pchname)
  
          commands = []
          commands += self.generate_basic_compiler_args(target, compiler)
          just_name = os.path.basename(header)
          (objname, pch_args) = compiler.gen_pch_args(just_name, source, dst)
          commands += pch_args
          commands += self.get_compile_debugfile_args(compiler, target, objname)
          dep = dst + '.' + compiler.get_depfile_suffix()
          return commands, dep, dst, [objname]
  
      def generate_gcc_pch_command(self, target, compiler, pch):
          commands = self._generate_single_compile(target, compiler)
          dst = os.path.join(self.get_target_private_dir(target),
                             os.path.basename(pch) + '.' + compiler.get_pch_suffix())
          dep = dst + '.' + compiler.get_depfile_suffix()
          return commands, dep, dst, []  # Gcc does not create an object file during pch generation.
  
      def generate_pch(self, target, outfile):
          cstr = ''
          pch_objects = []
          if target.is_cross:
              cstr = '_CROSS'
          for lang in ['c', 'cpp']:
              pch = target.get_pch(lang)
              if not pch:
                  continue
              if '/' not in pch[0] or '/' not in pch[-1]:
                  msg = 'Precompiled header of {!r} must not be in the same ' \
                        'directory as source, please put it in a subdirectory.' \
                        ''.format(target.get_basename())
                  raise InvalidArguments(msg)
              compiler = target.compilers[lang]
              if compiler.id == 'msvc':
                  src = os.path.join(self.build_to_src, target.get_source_subdir(), pch[-1])
                  (commands, dep, dst, objs) = self.generate_msvc_pch_command(target, compiler, pch)
                  extradep = os.path.join(self.build_to_src, target.get_source_subdir(), pch[0])
              elif compiler.id == 'intel':
                  # Intel generates on target generation
                  continue
              else:
                  src = os.path.join(self.build_to_src, target.get_source_subdir(), pch[0])
                  (commands, dep, dst, objs) = self.generate_gcc_pch_command(target, compiler, pch[0])
                  extradep = None
              pch_objects += objs
              rulename = compiler.get_language() + cstr + '_PCH'
              elem = NinjaBuildElement(self.all_outputs, dst, rulename, src)
              if extradep is not None:
                  elem.add_dep(extradep)
              elem.add_item('ARGS', commands)
              elem.add_item('DEPFILE', dep)
              elem.write(outfile)
          return pch_objects
  
      def generate_shsym(self, outfile, target):
          target_name = self.get_target_filename(target)
          targetdir = self.get_target_private_dir(target)
          symname = os.path.join(targetdir, target_name + '.symbols')
          elem = NinjaBuildElement(self.all_outputs, symname, 'SHSYM', target_name)
          if self.environment.is_cross_build() and self.environment.cross_info.need_cross_compiler():
              elem.add_item('CROSS', '--cross-host=' + self.environment.cross_info.config['host_machine']['system'])
          elem.write(outfile)
  
      def get_cross_stdlib_link_args(self, target, linker):
          if isinstance(target, build.StaticLibrary) or not target.is_cross:
              return []
          if not self.environment.cross_info.has_stdlib(linker.language):
              return []
          return linker.get_no_stdlib_link_args()
  
      def get_target_type_link_args(self, target, linker):
          abspath = os.path.join(self.environment.get_build_dir(), target.subdir)
          commands = []
          if isinstance(target, build.Executable):
              # Currently only used with the Swift compiler to add '-emit-executable'
              commands += linker.get_std_exe_link_args()
              # If gui_app, and that's significant on this platform
              if target.gui_app and hasattr(linker, 'get_gui_app_args'):
                  commands += linker.get_gui_app_args()
              # If export_dynamic, add the appropriate linker arguments
              if target.export_dynamic:
                  commands += linker.gen_export_dynamic_link_args(self.environment)
              # If implib, and that's significant on this platform (i.e. Windows using either GCC or Visual Studio)
              if target.import_filename:
                  commands += linker.gen_import_library_args(os.path.join(self.get_target_dir(target), target.import_filename))
          elif isinstance(target, build.SharedLibrary):
              if isinstance(target, build.SharedModule):
                  commands += linker.get_std_shared_module_link_args()
              else:
                  commands += linker.get_std_shared_lib_link_args()
              # All shared libraries are PIC
              commands += linker.get_pic_args()
              # Add -Wl,-soname arguments on Linux, -install_name on OS X
              commands += linker.get_soname_args(target.prefix, target.name, target.suffix,
                                                 abspath, target.soversion,
                                                 isinstance(target, build.SharedModule))
              # This is only visited when building for Windows using either GCC or Visual Studio
              if target.vs_module_defs and hasattr(linker, 'gen_vs_module_defs_args'):
                  commands += linker.gen_vs_module_defs_args(target.vs_module_defs.rel_to_builddir(self.build_to_src))
              # This is only visited when building for Windows using either GCC or Visual Studio
              if target.import_filename:
                  commands += linker.gen_import_library_args(os.path.join(self.get_target_dir(target), target.import_filename))
          elif isinstance(target, build.StaticLibrary):
              commands += linker.get_std_link_args()
          else:
              raise RuntimeError('Unknown build target type.')
          return commands
  
      def get_link_whole_args(self, linker, target):
          target_args = self.build_target_link_arguments(linker, target.link_whole_targets)
          return linker.get_link_whole_for(target_args) if len(target_args) else []
  
      def generate_link(self, target, outfile, outname, obj_list, linker, extra_args=[]):
          if isinstance(target, build.StaticLibrary):
              linker_base = 'STATIC'
          else:
              linker_base = linker.get_language() # Fixme.
          if isinstance(target, build.SharedLibrary):
              self.generate_shsym(outfile, target)
          crstr = ''
          if target.is_cross:
              crstr = '_CROSS'
          linker_rule = linker_base + crstr + '_LINKER'
  
          # Create an empty commands list, and start adding link 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.
          #
          # Once all the linker options have been passed, we will start passing
          # libraries and library paths from internal and external sources.
          commands = CompilerArgs(linker)
          # First, the trivial ones that are impossible to override.
          #
          # Add linker args for linking this target derived from 'base' build
          # options passed on the command-line, in default_options, etc.
          # These have the lowest priority.
          if not isinstance(target, build.StaticLibrary):
              commands += compilers.get_base_link_args(self.environment.coredata.base_options,
                                                       linker,
                                                       isinstance(target, build.SharedModule))
          # Add -nostdlib if needed; can't be overridden
          commands += self.get_cross_stdlib_link_args(target, linker)
          # Add things like /NOLOGO; usually can't be overridden
          commands += linker.get_linker_always_args()
          # Add buildtype linker args: optimization level, etc.
          commands += linker.get_buildtype_linker_args(self.get_option_for_target('buildtype', target))
          # Add /DEBUG and the pdb filename when using MSVC
          commands += self.get_link_debugfile_args(linker, target, outname)
          # Add link args specific to this BuildTarget type, such as soname args,
          # PIC, import library generation, etc.
          commands += self.get_target_type_link_args(target, linker)
          # Archives that are copied wholesale in the result. Must be before any
          # other link targets so missing symbols from whole archives are found in those.
          if not isinstance(target, build.StaticLibrary):
              commands += self.get_link_whole_args(linker, target)
  
          if not isinstance(target, build.StaticLibrary):
              # Add link args added using add_project_link_arguments()
              commands += self.build.get_project_link_args(linker, target.subproject)
              # Add link args added using add_global_link_arguments()
              # These override per-project link arguments
              commands += self.build.get_global_link_args(linker)
              if not target.is_cross:
                  # Link args added from the env: LDFLAGS. We want these to
                  # override all the defaults but not the per-target link args.
                  commands += self.environment.coredata.external_link_args[linker.get_language()]
  
          # Now we will add libraries and library paths from various sources
  
          # Add link args to link to all internal libraries (link_with:) and
          # internal dependencies needed by this target.
          if linker_base == 'STATIC':
              # Link arguments of static libraries are not put in the command
              # line of the library. They are instead appended to the command
              # line where the static library is used.
              dependencies = []
          else:
              dependencies = target.get_dependencies()
          commands += self.build_target_link_arguments(linker, dependencies)
          # For 'automagic' deps: Boost and GTest. Also dependency('threads').
          # pkg-config puts the thread flags itself via `Cflags:`
          for d in target.external_deps:
              if d.need_threads():
                  commands += linker.thread_link_flags(self.environment)
          # Only non-static built targets need link args and link dependencies
          if not isinstance(target, build.StaticLibrary):
              commands += target.link_args
              # External deps must be last because target link libraries may depend on them.
              for dep in target.get_external_deps():
                  # Extend without reordering or de-dup to preserve `-L -l` sets
                  # https://github.com/mesonbuild/meson/issues/1718
                  commands.extend_direct(dep.get_link_args())
              for d in target.get_dependencies():
                  if isinstance(d, build.StaticLibrary):
                      for dep in d.get_external_deps():
                          commands.extend_direct(dep.get_link_args())
          # Add link args for c_* or cpp_* build options. Currently this only
          # adds c_winlibs and cpp_winlibs when building for Windows. This needs
          # to be after all internal and external libraries so that unresolved
          # symbols from those can be found here. This is needed when the
          # *_winlibs that we want to link to are static mingw64 libraries.
          commands += linker.get_option_link_args(self.environment.coredata.compiler_options)
          # Set runtime-paths so we can run executables without needing to set
          # LD_LIBRARY_PATH, etc in the environment. Doesn't work on Windows.
          if '/' in target.name or '\\' in target.name:
              # Target names really should not have slashes in them, but
              # unfortunately we did not check for that and some downstream projects
              # now have them. Once slashes are forbidden, remove this bit.
              target_slashname_workaround_dir = os.path.join(
                  os.path.dirname(target.name),
                  self.get_target_dir(target))
          else:
              target_slashname_workaround_dir = self.get_target_dir(target)
          commands += linker.build_rpath_args(self.environment.get_build_dir(),
                                              target_slashname_workaround_dir,
                                              self.determine_rpath_dirs(target),
                                              target.build_rpath,
                                              target.install_rpath)
          # Add libraries generated by custom targets
          custom_target_libraries = self.get_custom_target_provided_libraries(target)
          commands += extra_args
          commands += custom_target_libraries
          # Convert from GCC-style link argument naming to the naming used by the
          # current compiler.
          commands = commands.to_native()
          dep_targets = [self.get_dependency_filename(t) for t in dependencies]
          dep_targets.extend([self.get_dependency_filename(t)
                              for t in target.link_depends])
          elem = NinjaBuildElement(self.all_outputs, outname, linker_rule, obj_list)
          elem.add_dep(dep_targets + custom_target_libraries)
          elem.add_item('LINK_ARGS', commands)
          return elem
  
      def get_dependency_filename(self, t):
          if isinstance(t, build.SharedLibrary):
              return os.path.join(self.get_target_private_dir(t), self.get_target_filename(t) + '.symbols')
          elif isinstance(t, mesonlib.File):
              if t.is_built:
                  return t.relative_name()
              else:
                  return t.absolute_path(self.environment.get_source_dir(),
                                         self.environment.get_build_dir())
          return self.get_target_filename(t)
  
      def generate_shlib_aliases(self, target, outdir):
          aliases = target.get_aliases()
          for alias, to in aliases.items():
              aliasfile = os.path.join(self.environment.get_build_dir(), outdir, alias)
              try:
                  os.remove(aliasfile)
              except Exception:
                  pass
              try:
                  os.symlink(to, aliasfile)
              except NotImplementedError:
                  mlog.debug("Library versioning disabled because symlinks are not supported.")
              except OSError:
                  mlog.debug("Library versioning disabled because we do not have symlink creation privileges.")
  
      def generate_custom_target_clean(self, outfile, trees):
          e = NinjaBuildElement(self.all_outputs, 'meson-clean-ctlist', 'CUSTOM_COMMAND', 'PHONY')
          d = CleanTrees(self.environment.get_build_dir(), trees)
          d_file = os.path.join(self.environment.get_scratch_dir(), 'cleantrees.dat')
          e.add_item('COMMAND', self.environment.get_build_command() + ['--internal', 'cleantrees', d_file])
          e.add_item('description', 'Cleaning custom target directories.')
          e.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-clean-ctlist', outfile)
          # Write out the data file passed to the script
          with open(d_file, 'wb') as ofile:
              pickle.dump(d, ofile)
          return 'clean-ctlist'
  
      def generate_gcov_clean(self, outfile):
          gcno_elem = NinjaBuildElement(self.all_outputs, 'meson-clean-gcno', 'CUSTOM_COMMAND', 'PHONY')
          script_root = self.environment.get_script_dir()
          clean_script = os.path.join(script_root, 'delwithsuffix.py')
          gcno_elem.add_item('COMMAND', mesonlib.python_command + [clean_script, '.', 'gcno'])
          gcno_elem.add_item('description', 'Deleting gcno files.')
          gcno_elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-clean-gcno', outfile)
  
          gcda_elem = NinjaBuildElement(self.all_outputs, 'meson-clean-gcda', 'CUSTOM_COMMAND', 'PHONY')
          script_root = self.environment.get_script_dir()
          clean_script = os.path.join(script_root, 'delwithsuffix.py')
          gcda_elem.add_item('COMMAND', mesonlib.python_command + [clean_script, '.', 'gcda'])
          gcda_elem.add_item('description', 'Deleting gcda files.')
          gcda_elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-clean-gcda', outfile)
  
      def get_user_option_args(self):
          cmds = []
          for (k, v) in self.environment.coredata.user_options.items():
              cmds.append('-D' + k + '=' + (v.value if isinstance(v.value, str) else str(v.value).lower()))
          # The order of these arguments must be the same between runs of Meson
          # to ensure reproducible output. The order we pass them shouldn't
          # affect behavior in any other way.
          return sorted(cmds)
  
      def generate_dist(self, outfile):
          elem = NinjaBuildElement(self.all_outputs, 'meson-dist', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('DESC', 'Creating source packages')
          elem.add_item('COMMAND', self.environment.get_build_command() + [
              '--internal', 'dist',
              self.environment.source_dir,
              self.environment.build_dir,
          ] + self.environment.get_build_command())
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-dist', outfile)
  
      # For things like scan-build and other helper tools we might have.
      def generate_utils(self, outfile):
          cmd = self.environment.get_build_command() + \
              ['--internal', 'scanbuild', self.environment.source_dir, self.environment.build_dir] + \
              self.environment.get_build_command() + self.get_user_option_args()
          elem = NinjaBuildElement(self.all_outputs, 'meson-scan-build', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('COMMAND', cmd)
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-scan-build', outfile)
          cmd = self.environment.get_build_command() + ['--internal', 'uninstall']
          elem = NinjaBuildElement(self.all_outputs, 'meson-uninstall', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('COMMAND', cmd)
          elem.add_item('pool', 'console')
          elem.write(outfile)
          # Alias that runs the target defined above
          self.create_target_alias('meson-uninstall', outfile)
  
      def generate_ending(self, outfile):
          targetlist = []
          for t in self.get_build_by_default_targets().values():
              # Add the first output of each target to the 'all' target so that
              # they are all built
              targetlist.append(os.path.join(self.get_target_dir(t), t.get_outputs()[0]))
  
          elem = NinjaBuildElement(self.all_outputs, 'all', 'phony', targetlist)
          elem.write(outfile)
  
          default = 'default all\n\n'
          outfile.write(default)
  
          elem = NinjaBuildElement(self.all_outputs, 'meson-clean', 'CUSTOM_COMMAND', 'PHONY')
          elem.add_item('COMMAND', [self.ninja_command, '-t', 'clean'])
          elem.add_item('description', 'Cleaning.')
          # Alias that runs the above-defined meson-clean target
          self.create_target_alias('meson-clean', outfile)
  
          # If we have custom targets in this project, add all their outputs to
          # the list that is passed to the `cleantrees.py` script. The script
          # will manually delete all custom_target outputs that are directories
          # instead of files. This is needed because on platforms other than
          # Windows, Ninja only deletes directories while cleaning if they are
          # empty. https://github.com/mesonbuild/meson/issues/1220
          ctlist = []
          for t in self.build.get_targets().values():
              if isinstance(t, build.CustomTarget):
                  # Create a list of all custom target outputs
                  for o in t.get_outputs():
                      ctlist.append(os.path.join(self.get_target_dir(t), o))
          if ctlist:
              elem.add_dep(self.generate_custom_target_clean(outfile, ctlist))
  
          if 'b_coverage' in self.environment.coredata.base_options and \
             self.environment.coredata.base_options['b_coverage'].value:
              self.generate_gcov_clean(outfile)
              elem.add_dep('clean-gcda')
              elem.add_dep('clean-gcno')
          elem.write(outfile)
  
          deps = self.get_regen_filelist()
          elem = NinjaBuildElement(self.all_outputs, 'build.ninja', 'REGENERATE_BUILD', deps)
          elem.add_item('pool', 'console')
          elem.write(outfile)
  
          elem = NinjaBuildElement(self.all_outputs, 'reconfigure', 'REGENERATE_BUILD', 'PHONY')
          elem.add_item('pool', 'console')
          elem.write(outfile)
  
          elem = NinjaBuildElement(self.all_outputs, deps, 'phony', '')
          elem.write(outfile)
  
  def load(build_dir):
      filename = os.path.join(build_dir, 'meson-private', 'install.dat')
      with open(filename, 'rb') as f:
          obj = pickle.load(f)
      return obj
  
files: mesonbuild/backend/ninjabackend.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
  
  known_basic_kwargs = {'install': True,
                        'c_pch': True,
                        'cpp_pch': True,
                        'c_args': True,
                        'objc_args': True,
                        'objcpp_args': True,
                        'cpp_args': True,
                        'cs_args': True,
                        'vala_args': True,
                        'fortran_args': True,
                        'd_args': True,
                        'd_import_dirs': True,
                        'd_unittest': True,
                        'd_module_versions': True,
                        'java_args': True,
                        'rust_args': True,
                        'link_args': True,
                        'link_depends': True,
                        'link_with': True,
                        'link_whole': True,
                        'implicit_include_directories': True,
                        'include_directories': True,
                        'dependencies': True,
                        'install_dir': True,
                        'main_class': True,
                        'name_suffix': True,
                        'gui_app': True,
                        'extra_files': True,
                        'install_rpath': True,
                        'build_rpath': True,
                        'resources': True,
                        'sources': True,
                        'objects': True,
                        'native': True,
                        'build_by_default': True,
                        'override_options': True,
                        }
  
  # These contain kwargs supported by both static and shared libraries. These are
  # combined here because a library() call might be shared_library() or
  # static_library() at runtime based on the configuration.
  # FIXME: Find a way to pass that info down here so we can have proper target
  # kwargs checking when specifically using shared_library() or static_library().
  known_lib_kwargs = known_basic_kwargs.copy()
  known_lib_kwargs.update({'version': True, # Only for shared libs
                           'soversion': True, # Only for shared libs
                           'name_prefix': True,
                           'vs_module_defs': True, # Only for shared libs
                           'vala_header': True,
                           'vala_vapi': True,
                           'vala_gir': True,
                           'pic': True, # Only for static libs
                           'rust_crate_type': True, # Only for Rust libs
                           })
  
  known_exe_kwargs = known_basic_kwargs.copy()
  known_exe_kwargs.update({'implib': True,
                           'export_dynamic': True
                           })
  
  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 = {}
  
      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, is_unity):
          self.target = target
          self.srclist = srclist
          if 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 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.
          # If the list of sources for which we want objects is the same as the
          # list of sources that go into each unified build, we're good.
          srclist_set = set(self.srclist)
          # Objects for all the sources are required, so we're compatible
          if srclist_set == set(self.target.sources):
              return
          # Check if the srclist is a subset (of the target's sources) that is
          # going to form a unified source file and a single object
          compsrcs = classify_unity_sources(self.target.compilers.values(),
                                            self.target.sources)
          for srcs in compsrcs.values():
              if srclist_set == set(srcs):
                  return
          msg = 'Single object files can not be extracted in Unity builds. ' \
                'You can only extract all the object files at once.'
          raise MesonException(msg)
  
  
  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 = {}
          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 = 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.
          base = self.name + self.type_suffix()
          if self.subproject == '':
              return base
          return self.subproject + '@@' + base
  
      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):
      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)
  
      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, known_basic_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)
              if src not in self.sources:
                  raise MesonException('Tried to extract unknown source %s.' % src)
              obj_src.append(src)
          return ExtractedObjects(self, obj_src, self.is_unity)
  
      def extract_all_objects(self):
          return ExtractedObjects(self, self.sources, self.is_unity)
  
      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 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):
              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))
          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.')
                  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):
          transitive_deps = []
          for t in itertools.chain(self.link_targets, self.link_whole_targets):
              transitive_deps.append(t)
              if isinstance(t, StaticLibrary):
                  transitive_deps += t.get_dependencies()
          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)
                  # 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 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(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:
                      return 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))
  
          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()
          if linker and linker.get_id() == 'msvc':
              return True
          return False
  
      def is_linkable_target(self):
          return False
  
  
  class Generator:
      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):
      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:
                  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 check_unknown_kwargs(self, kwargs):
          self.check_unknown_kwargs_int(kwargs, known_exe_kwargs)
  
      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):
      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 check_unknown_kwargs(self, kwargs):
          self.check_unknown_kwargs_int(kwargs, known_lib_kwargs)
  
      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):
      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 check_unknown_kwargs(self, kwargs):
          self.check_unknown_kwargs_int(kwargs, known_lib_kwargs)
  
      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):
      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)
          self.import_filename = None
  
  class CustomTarget(Target):
      known_kwargs = {'input': True,
                      'output': True,
                      'command': True,
                      'capture': False,
                      'install': True,
                      'install_dir': True,
                      'build_always': True,
                      'depends': True,
                      'depend_files': True,
                      'depfile': True,
                      'build_by_default': True,
                      'override_options': True,
                      }
  
      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 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))
          else:
              self.install = False
              self.install_dir = [None]
          self.build_always = kwargs.get('build_always', False)
          if not isinstance(self.build_always, bool):
              raise InvalidArguments('Argument build_always 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_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 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):
      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):
          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))
  
  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, 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
  from .compilers import is_object, clike_langs, sort_clike, lang_suffixes
  
  known_basic_kwargs = {'install': True,
                        'c_pch': True,
                        'cpp_pch': True,
                        'c_args': True,
                        'objc_args': True,
                        'objcpp_args': True,
                        'cpp_args': True,
                        'cs_args': True,
                        'vala_args': True,
                        'fortran_args': True,
                        'd_args': True,
                        'd_import_dirs': True,
                        'd_unittest': True,
                        'd_module_versions': True,
                        'java_args': True,
                        'rust_args': True,
                        'link_args': True,
                        'link_depends': True,
                        'link_with': True,
                        'link_whole': True,
                        'implicit_include_directories': True,
                        'include_directories': True,
                        'dependencies': True,
                        'install_dir': True,
                        'main_class': True,
                        'name_suffix': True,
                        'gui_app': True,
                        'extra_files': True,
                        'install_rpath': True,
                        'build_rpath': True,
                        'resources': True,
                        'sources': True,
                        'objects': True,
                        'native': True,
                        'build_by_default': True,
                        'override_options': True,
                        }
  
  # These contain kwargs supported by both static and shared libraries. These are
  # combined here because a library() call might be shared_library() or
  # static_library() at runtime based on the configuration.
  # FIXME: Find a way to pass that info down here so we can have proper target
  # kwargs checking when specifically using shared_library() or static_library().
  known_lib_kwargs = known_basic_kwargs.copy()
  known_lib_kwargs.update({'version': True, # Only for shared libs
                           'soversion': True, # Only for shared libs
                           'name_prefix': True,
                           'vs_module_defs': True, # Only for shared libs
                           'vala_header': True,
                           'vala_vapi': True,
                           'vala_gir': True,
                           'pic': True, # Only for static libs
                           'rust_crate_type': True, # Only for Rust libs
                           })
  
  known_exe_kwargs = known_basic_kwargs.copy()
  known_exe_kwargs.update({'implib': True,
                           'export_dynamic': True
                           })
  
  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 = {}
  
      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, is_unity):
          self.target = target
          self.srclist = srclist
          if 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 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.
          # If the list of sources for which we want objects is the same as the
          # list of sources that go into each unified build, we're good.
          srclist_set = set(self.srclist)
          # Objects for all the sources are required, so we're compatible
          if srclist_set == set(self.target.sources):
              return
          # Check if the srclist is a subset (of the target's sources) that is
          # going to form a unified source file and a single object
          compsrcs = classify_unity_sources(self.target.compilers.values(),
                                            self.target.sources)
          for srcs in compsrcs.values():
              if srclist_set == set(srcs):
                  return
          msg = 'Single object files can not be extracted in Unity builds. ' \
                'You can only extract all the object files at once.'
          raise MesonException(msg)
  
  
  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 = {}
          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 '/' in name or '\\' in 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 = 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.
          base = self.name + self.type_suffix()
          if self.subproject == '':
              return base
          return self.subproject + '@@' + base
  
      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):
      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)
  
      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, known_basic_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)
              if src not in self.sources:
                  raise MesonException('Tried to extract unknown source %s.' % src)
              obj_src.append(src)
          return ExtractedObjects(self, obj_src, self.is_unity)
  
      def extract_all_objects(self):
          return ExtractedObjects(self, self.sources, self.is_unity)
  
      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 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):
              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))
          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.')
                  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):
          transitive_deps = []
          for t in itertools.chain(self.link_targets, self.link_whole_targets):
              transitive_deps.append(t)
              if isinstance(t, StaticLibrary):
                  transitive_deps += t.get_dependencies()
          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)
                  # 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 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(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:
                      return 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))
  
          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()
          if linker and linker.get_id() == 'msvc':
              return True
          return False
  
      def is_linkable_target(self):
          return False
  
  
  class Generator:
      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 '/' in rule or '\\' in 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):
      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:
                  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 check_unknown_kwargs(self, kwargs):
          self.check_unknown_kwargs_int(kwargs, known_exe_kwargs)
  
      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):
      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 check_unknown_kwargs(self, kwargs):
          self.check_unknown_kwargs_int(kwargs, known_lib_kwargs)
  
      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):
      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 check_unknown_kwargs(self, kwargs):
          self.check_unknown_kwargs_int(kwargs, known_lib_kwargs)
  
      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):
      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)
          self.import_filename = None
  
  class CustomTarget(Target):
      known_kwargs = {'input': True,
                      'output': True,
                      'command': True,
                      'capture': False,
                      'install': True,
                      'install_dir': True,
                      'build_always': True,
                      'depends': True,
                      'depend_files': True,
                      'depfile': True,
                      'build_by_default': True,
                      'override_options': True,
                      }
  
      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 '/' in 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 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))
          else:
              self.install = False
              self.install_dir = [None]
          self.build_always = kwargs.get('build_always', False)
          if not isinstance(self.build_always, bool):
              raise InvalidArguments('Argument build_always 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_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 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):
      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):
          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))
  
  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, 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-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, DependencyException
  from .interpreterbase import InterpreterBase
  from .interpreterbase import check_stringlist, noPosargs, noKwargs, stringArgs, permittedKwargs, permittedMethodKwargs
  from .interpreterbase import InterpreterException, InvalidArguments, InvalidCode
  from .interpreterbase import InterpreterObject, MutableInterpreterObject, Disabler
  from .modules import ModuleReturnValue
  
  import os, sys, shutil, uuid
  import re, shlex
  from collections import namedtuple
  from pathlib import PurePath
  
  import importlib
  
  
  def stringifyUserArguments(args):
      if isinstance(args, list):
          return '[%s]' % ', '.join([stringifyUserArguments(x) for x in args])
      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 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,
                               })
  
      def returncode_method(self, args, kwargs):
          return self.res.returncode
  
      def compiled_method(self, args, kwargs):
          return self.res.compiled
  
      def stdout_method(self, args, kwargs):
          return self.res.stdout
  
      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):
          super().__init__()
          if not isinstance(cmd, ExternalProgram):
              raise AssertionError('BUG: RunProcess must be passed an ExternalProgram')
          pc, self.stdout, self.stderr = self.run_command(cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir)
          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):
          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)
          mlog.debug('Running command:', ' '.join(command_array))
          try:
              p, o, e = Popen_safe(command_array, env=child_env, cwd=cwd)
              mlog.debug('--- stdout----')
              mlog.debug(o)
              mlog.debug('----stderr----')
              mlog.debug(e)
              mlog.debug('')
              return p, o, e
          except FileNotFoundError:
              raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array))
  
      def returncode_method(self, args, kwargs):
          return self.returncode
  
      def stdout_method(self, args, kwargs):
          return self.stdout
  
      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)
  
      @stringArgs
      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))
  
      def set_method(self, args, kwargs):
          self.add_var(self.held_object.set, args, kwargs)
  
      def append_method(self, args, kwargs):
          self.add_var(self.held_object.append, args, kwargs)
  
      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) != 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
  
      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
  
      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)
  
      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,
                               })
  
      def type_name_method(self, args, kwargs):
          return self.held_object.type_name
  
      def found_method(self, args, kwargs):
          if self.held_object.type_name == 'internal':
              return True
          return self.held_object.found()
  
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
      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)
  
      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)
  
  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,
                               })
  
      def found_method(self, args, kwargs):
          return True
  
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
  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})
  
      def found_method(self, args, kwargs):
          return self.found()
  
      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})
  
      def found(self):
          return self.held_object.found()
  
      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()
  
  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})
  
      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,
                               })
  
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      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,
                               })
  
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      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)
          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
  
  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)
          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_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()
  
      def private_dir_include_method(self, args, kwargs):
          return IncludeDirsHolder(build.IncludeDirs('', [], False,
                                                     [self.interpreter.backend.get_target_private_dir(self.held_object)]))
  
      def full_path_method(self, args, kwargs):
          return self.interpreter.backend.get_target_filename_abs(self.held_object)
  
      def outdir_method(self, args, kwargs):
          return self.interpreter.backend.get_target_dir(self.held_object)
  
      def extract_objects_method(self, args, kwargs):
          gobjs = self.held_object.extract_objects(args)
          return GeneratedObjectsHolder(gobjs)
  
      def extract_all_objects_method(self, args, kwargs):
          gobjs = self.held_object.extract_all_objects()
          return GeneratedObjectsHolder(gobjs)
  
      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)
  
  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)
  
      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')
  
  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, 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.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,
                               })
  
      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,
                               '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,
                               'unittest_args': self.unittest_args_method,
                               'symbols_have_underscore_prefix': self.symbols_have_underscore_prefix_method,
                               })
  
      @permittedMethodKwargs({})
      def version_method(self, args, kwargs):
          return self.compiler.version
  
      @permittedMethodKwargs({})
      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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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)
  
      @permittedMethodKwargs({})
      def get_id_method(self, args, kwargs):
          return self.compiler.get_id()
  
      @permittedMethodKwargs({})
      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)
  
      @permittedMethodKwargs({})
      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)
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_members_method(self, args, kwargs):
          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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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', '')
          l = kwargs.get('low', -1024)
          h = kwargs.get('high', 1024)
          guess = kwargs.get('guess', None)
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of compute_int must be a string.')
          if not isinstance(l, int):
              raise InterpreterException('Low argument of compute_int must be an int.')
          if not isinstance(h, 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, l, h, guess, prefix, self.environment, extra_args, deps)
          mlog.log('Computing int of "%s": %d' % (expression, res))
          return res
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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.')
          required = kwargs.get('required', True)
          if not isinstance(required, bool):
              raise InterpreterException('required must be boolean.')
          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)
  
      @permittedMethodKwargs({})
      def has_argument_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          if len(args) != 1:
              raise InterpreterException('Has_arg takes exactly one argument.')
          result = self.compiler.has_argument(args[0], self.environment)
          if result:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Compiler for {} supports argument {}:'.format(self.compiler.get_display_language(), args[0]), h)
          return result
  
      @permittedMethodKwargs({})
      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
  
      @permittedMethodKwargs({})
      def get_supported_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          result = self.compiler.get_supported_arguments(args, self.environment)
          if len(result) == len(args):
              h = mlog.green('YES')
          elif len(result) > 0:
              h = mlog.yellow('SOME')
          else:
              h = mlog.red('NO')
          mlog.log(
              'Compiler for {} supports arguments {}:'.format(
                  self.compiler.get_display_language(), ' '.join(args)),
              h)
          return result
  
      @permittedMethodKwargs({})
      def first_supported_argument_method(self, args, kwargs):
          for i in mesonlib.stringlistify(args):
              if self.compiler.has_argument(i, self.environment):
                  mlog.log('First supported argument:', mlog.bold(i))
                  return [i]
          mlog.log('First supported 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))
          # 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,
                               '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)
  
      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)
  
      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)
  
      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)
  
      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)
  
      def backend_method(self, args, kwargs):
          return self.interpreter.backend.name
  
      def source_root_method(self, args, kwargs):
          return self.interpreter.environment.source_dir
  
      def build_root_method(self, args, kwargs):
          return self.interpreter.environment.build_dir
  
      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
  
      def is_cross_build_method(self, args, kwargs):
          return self.build.environment.is_cross_build()
  
      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)
  
      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
  
      def is_subproject_method(self, args, kwargs):
          return self.interpreter.is_subproject()
  
      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]
  
      def project_version_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['version']
  
      def project_license_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['license']
  
      def version_method(self, args, kwargs):
          return coredata.version
  
      def project_name_method(self, args, kwargs):
          return self.interpreter.active_projectname
  
      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)
  
  
  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',
      'name_prefix',
      'name_suffix',
      'native',
      'objects',
      'override_options',
      'pic',
      'sources',
      'vs_module_defs',
  ])
  
  build_target_common_kwargs = (
      buildtarget_kwargs |
      lang_arg_kwargs |
      pch_kwargs |
      vala_kwargs |
      rust_kwargs |
      cs_kwargs)
  
  exe_kwargs = (build_target_common_kwargs) | {'implib', 'export_dynamic'}
  shlib_kwargs = (build_target_common_kwargs) | {'version', 'soversion'}
  shmod_kwargs = shlib_kwargs
  stlib_kwargs = shlib_kwargs
  
  jar_kwargs = exe_kwargs.copy()
  jar_kwargs.update(['main_class'])
  
  build_target_kwargs = exe_kwargs.copy()
  build_target_kwargs.update(['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': build_target_kwargs,
                      'configure_file': {'input', 'output', 'configuration', 'command', 'install_dir', 'capture', 'install'},
                      'custom_target': {'input', 'output', 'command', 'install', 'install_dir', 'build_always', 'capture', 'depends', 'depend_files', 'depfile', 'build_by_default'},
                      'dependency': {'default_options', 'fallback', 'language', 'main', 'method', 'modules', 'optional_modules', 'native', 'required', 'static', 'version'},
                      'declare_dependency': {'include_directories', 'link_with', 'sources', 'dependencies', 'compile_args', 'link_args', 'link_whole', 'version'},
                      'executable': exe_kwargs,
                      'find_program': {'required', 'native'},
                      'generator': {'arguments', 'output', 'depfile', 'capture', 'preserve_path_from'},
                      'include_directories': {'is_system'},
                      'install_data': {'install_dir', 'install_mode', 'sources'},
                      'install_headers': {'install_dir', 'subdir'},
                      'install_man': {'install_dir'},
                      'install_subdir': {'exclude_files', 'exclude_directories', 'install_dir', 'install_mode', 'strip_directory'},
                      'jar': jar_kwargs,
                      'project': {'version', 'meson_version', 'default_options', 'license', 'subproject_dir'},
                      'run_target': {'command', 'depends'},
                      'shared_library': shlib_kwargs,
                      'shared_module': shmod_kwargs,
                      'static_library': stlib_kwargs,
                      'subdir': {'if_found'},
                      'subproject': {'version', 'default_options'},
                      'test': {'args', 'env', 'is_parallel', 'should_fail', 'timeout', 'workdir', 'suite'},
                      'vcs_tag': {'input', 'output', 'fallback', 'command', 'replace_string'},
                      }
  
  
  class Interpreter(InterpreterBase):
  
      def __init__(self, build, backend, subproject='', subdir='', subproject_dir='subprojects',
                   default_project_options=[]):
          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
          # 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 = []
          self.default_project_options = default_project_options[:] # Passed from the outside, only used in subprojects.
          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,
                             'subproject': self.func_subproject,
                             'shared_library': self.func_shared_lib,
                             'shared_module': self.func_shared_module,
                             'static_library': self.func_static_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.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.environment.coredata.modules:
              try:
                  module = importlib.import_module('mesonbuild.modules.' + modname)
              except ImportError:
                  raise InvalidArguments('Module "%s" does not exist' % (modname, ))
              self.environment.coredata.modules[modname] = module.initialize()
          return ModuleHolder(modname, self.environment.coredata.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]
  
      @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.')
  
      @noKwargs
      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:]
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          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)
  
      @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.')
  
      @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):
          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('\nExecuting subproject ', mlog.bold(dirname), '.\n', sep='')
          subi = Interpreter(self.build, self.backend, dirname, subdir, self.subproject_dir,
                             mesonlib.stringlistify(kwargs.get('default_options', [])))
          subi.subprojects = self.subprojects
  
          subi.subproject_stack = self.subproject_stack + [dirname]
          current_active = self.active_projectname
          subi.run()
          if 'version' in kwargs:
              pv = subi.project_version
              wanted = kwargs['version']
              if pv == 'undefined' or not mesonlib.version_compare(pv, wanted):
                  raise InterpreterException('Subproject %s version is %s but %s required.' % (dirname, pv, wanted))
          self.active_projectname = current_active
          mlog.log('\nSubproject', mlog.bold(dirname), 'finished.')
          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]
  
      @stringArgs
      @noKwargs
      def func_get_option(self, nodes, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Argument required for get_option.')
          undecorated_optname = 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.''')
          try:
              return self.environment.get_coredata().base_options[optname].value
          except KeyError:
              pass
          try:
              return self.environment.coredata.get_builtin_option(optname)
          except RuntimeError:
              pass
          try:
              return self.environment.coredata.compiler_options[optname].value
          except KeyError:
              pass
          if not coredata.is_builtin_option(optname) and self.is_subproject():
              optname = self.subproject + ':' + optname
          try:
              opt = self.environment.coredata.user_options[optname]
              if opt.yielding and ':' in optname:
                  # If option not present in superproject, keep the original.
                  opt = self.environment.coredata.user_options.get(undecorated_optname, opt)
              return opt.value
          except KeyError:
              pass
          if optname.endswith('_link_args'):
              try:
                  lang = optname[:-10]
                  return self.coredata.external_link_args[lang]
              except KeyError:
                  pass
          if optname.endswith('_args'):
              try:
                  lang = optname[:-5]
                  return self.coredata.external_args[lang]
              except KeyError:
                  pass
          # Some base options are not defined in some environments, return the default value.
          try:
              return compilers.base_options[optname].value
          except KeyError:
              pass
          raise InterpreterException('Tried to access unknown option "%s".' % optname)
  
      @noKwargs
      def func_configuration_data(self, node, args, kwargs):
          if args:
              raise InterpreterException('configuration_data takes no arguments')
          return ConfigurationDataHolder()
  
      def parse_default_options(self, default_options):
          default_options = listify(default_options)
          for option in default_options:
              if not isinstance(option, str):
                  mlog.debug(option)
                  raise InterpreterException('Default options must be strings')
              if '=' not in option:
                  raise InterpreterException('All default options must be of type key=value.')
              key, value = option.split('=', 1)
              if coredata.is_builtin_option(key):
                  if self.subproject != '':
                      continue # Only the master project is allowed to set global options.
                  # If this was set on the command line, do not override.
                  if not self.environment.had_argument_for(key):
                      self.coredata.set_builtin_option(key, value)
                      # If we are setting the prefix, then other options which
                      # have prefix-dependent defaults need their value updating,
                      # if they haven't been explicitly set (i.e. have their
                      # default value)
                      if key == 'prefix':
                          for option in coredata.builtin_dir_noprefix_options:
                              if not (self.environment.had_argument_for(option) or
                                      any([k.startswith(option + '=') for k in default_options])):
                                  self.coredata.set_builtin_option(option, coredata.get_builtin_option_default(option, value))
              else:
                  # Option values set with subproject() default_options override those
                  # set in project() default_options.
                  pref = key + '='
                  for i in self.default_project_options:
                      if i.startswith(pref):
                          option = i
                          break
                  # If we are in a subproject, add the subproject prefix to option
                  # name.
                  if self.subproject != '':
                      option = self.subproject + ':' + option
                  newoptions = [option] + self.environment.cmd_line_options.projectoptions
                  self.environment.cmd_line_options.projectoptions = newoptions
          # Add options that are only in default_options.
          for defopt in self.default_project_options:
              key, value = defopt.split('=')
              pref = key + '='
              for i in default_options:
                  if i.startswith(pref):
                      break
              else:
                  defopt = self.subproject + ':' + defopt
                  newoptions = [defopt] + self.environment.cmd_line_options.projectoptions
                  self.environment.cmd_line_options.projectoptions = newoptions
  
      @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))
          default_options = kwargs.get('default_options', [])
          if self.environment.first_invocation and (len(default_options) > 0 or
                                                    len(self.default_project_options) > 0):
              self.parse_default_options(default_options)
          if not self.is_subproject():
              self.build.project_name = proj_name
          if os.path.exists(self.option_file):
              oi = optinterpreter.OptionInterpreter(self.subproject,
                                                    self.build.environment.cmd_line_options.projectoptions,
                                                    )
              oi.process(self.option_file)
              self.build.environment.merge_options(oi.options)
          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']
              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='')
          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):
          return self.add_languages(args, kwargs.get('required', True))
  
      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, 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)
  
      @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 i in new_options:
              if not i.startswith(optprefix):
                  raise InterpreterException('Internal error, %s has incorrect prefix.' % i)
              cmd_prefix = i + '='
              for cmd_arg in self.environment.cmd_line_options.projectoptions:
                  if cmd_arg.startswith(cmd_prefix):
                      value = cmd_arg.split('=', 1)[1]
                      new_options[i].set_value(value)
          new_options.update(self.coredata.compiler_options)
          self.coredata.compiler_options = new_options
          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='')
  
              # If <language>_args/_link_args settings are given on the
              # command line, use them.
              for optspec in self.build.environment.cmd_line_options.projectoptions:
                  (optname, optvalue) = optspec.split('=', maxsplit=1)
                  if optname.endswith('_link_args'):
                      lang = optname[:-10]
                      self.coredata.external_link_args.setdefault(lang, []).append(optvalue)
                  elif optname.endswith('_args'):
                      lang = optname[:-5]
                      self.coredata.external_args.setdefault(lang, []).append(optvalue)
              # Otherwise, look for definitions from environment
              # variables such as CFLAGS.
              if not comp.get_language() in self.coredata.external_args:
                  (preproc_args, compile_args, link_args) = environment.get_args_from_envvars(comp)
                  self.coredata.external_preprocess_args[comp.get_language()] = preproc_args
                  self.coredata.external_args[comp.get_language()] = compile_args
                  self.coredata.external_link_args[comp.get_language()] = link_args
              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 add_base_options(self, compiler):
          proj_opt = self.environment.cmd_line_options.projectoptions
          for optname in compiler.base_options:
              if optname in self.coredata.base_options:
                  continue
              oobj = compilers.base_options[optname]
              for po in proj_opt:
                  if po.startswith(optname + '='):
                      oobj.set_value(po.split('=', 1)[1])
                      break
              self.coredata.base_options[optname] = oobj
  
      def program_from_cross_file(self, prognames):
          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)
                  progobj = ExternalProgramHolder(extprog)
                  return progobj
  
      def program_from_system(self, args):
          # 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)
              progobj = ExternalProgramHolder(extprog)
              if progobj.found():
                  return progobj
  
      @permittedKwargs(permitted_kwargs['find_program'])
      def func_find_program(self, node, args, kwargs):
          if not args:
              raise InterpreterException('No program name specified.')
          required = kwargs.get('required', True)
          if not isinstance(required, bool):
              raise InvalidArguments('"required" argument must be a boolean.')
          progobj = None
          if self.build.environment.is_cross_build():
              use_native = kwargs.get('native', False)
              if not isinstance(use_native, bool):
                  raise InvalidArguments('Argument to "native" must be a boolean.')
              if not use_native:
                  progobj = self.program_from_cross_file(args)
          if progobj is None:
              progobj = self.program_from_system(args)
          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())
          return progobj
  
      def func_find_library(self, node, args, kwargs):
          raise InvalidCode('find_library() is removed, use the corresponding method in a compiler object instead.')
  
      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(found, wanted):
              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
  
      @permittedKwargs(permitted_kwargs['dependency'])
      def func_dependency(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          required = kwargs.get('required', True)
          if not isinstance(required, bool):
              raise DependencyException('Keyword "required" must be a boolean.')
          name = args[0]
  
          if name == '':
              if required:
                  raise InvalidArguments('Dependency is both required and not-found')
              return DependencyHolder(Dependency('not-found', {}))
  
          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 = None
  
              # Search for it outside the project
              try:
                  dep = dependencies.find_external_dependency(name, self.environment, kwargs)
              except DependencyException as e:
                  exception = e
  
              # Search inside the projects list
              if not dep or 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 not dep:
                      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)
  
      @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:\nAutomatic wrap-based fallback '
                       'dependency downloading is disabled.')
              return None
          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('Also couldn\'t find a 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
  
      @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):
          return self.build_target(node, args, kwargs, SharedLibraryHolder)
  
      @permittedKwargs(permitted_kwargs['shared_module'])
      def func_shared_module(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, SharedModuleHolder)
  
      def func_library(self, node, args, kwargs):
          if self.coredata.get_builtin_option('default_library') == 'shared':
              return self.func_shared_lib(node, args, kwargs)
          return self.func_static_lib(node, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['jar'])
      def func_jar(self, node, args, kwargs):
          kwargs['target_type'] = 'jar'
          return self.build_target(node, args, kwargs, JarHolder)
  
      @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.func_executable(node, args, kwargs)
          elif target_type == 'shared_library':
              return self.func_shared_lib(node, args, kwargs)
          elif target_type == 'static_library':
              return self.func_static_lib(node, args, kwargs)
          elif target_type == 'library':
              return self.func_library(node, args, kwargs)
          elif target_type == 'jar':
              return self.func_jar(node, args, kwargs)
          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')
          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_always', True)
          return self.func_custom_target(node, [kwargs['output']], kwargs)
  
      @stringArgs
      @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')
          name = args[0]
          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')
          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:
              try:
                  d = d.held_object
              except AttributeError:
                  pass
              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)
  
      @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)
          t = Test(args[0], prj, suite, exe.held_object, 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='')
  
      @permittedKwargs(permitted_kwargs['install_headers'])
      def func_install_headers(self, node, args, kwargs):
          source_files = self.source_strings_to_files(args)
          h = Headers(source_files, kwargs)
          self.build.headers.append(h)
          return h
  
      @permittedKwargs(permitted_kwargs['install_man'])
      def func_install_man(self, node, args, kwargs):
          fargs = self.source_strings_to_files(args)
          m = Man(fargs, kwargs)
          self.build.man.append(m)
          return m
  
      @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
          self.evaluate_codeblock(codeblock)
          self.subdir = prev_subdir
  
      def _get_kwarg_install_mode(self, kwargs):
          if 'install_mode' not in kwargs:
              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)
  
      @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)
          data = DataHolder(build.Data(sources, install_dir, install_mode))
          self.build.data.append(data.held_object)
          return data
  
      @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
  
      @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.')
          if 'configuration' in kwargs and 'command' in kwargs:
              raise InterpreterException('Must not specify both "configuration" '
                                         'and "command" keyword arguments since '
                                         'they are mutually exclusive.')
          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.')
  
          # 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)
          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)
                  missing_variables = mesonlib.do_conf_file(ifile_abs, ofile_abs,
                                                            conf.held_object)
                  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)
              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 + '~'
                  with open(dst_tmp, 'w', encoding='utf-8') as f:
                      f.writelines(res.stdout)
                  if ifile_abs:
                      shutil.copymode(ifile_abs, dst_tmp)
                  mesonlib.replace_if_different(ofile_abs, dst_tmp)
          else:
              raise InterpreterException('Configure_file must have either "configuration" or "command".')
          # 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
          idir = kwargs.get('install_dir', None)
          if isinstance(idir, str):
              cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
              self.build.data.append(build.Data([cfile], idir))
          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')
              exe_wrapper = []
              for i in inp:
                  if hasattr(i, 'held_object'):
                      i = i.held_object
                  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))))
  
      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()
  
      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')
          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)
          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
      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
      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
  from .dependencies import ExternalProgram
  from .dependencies import InternalDependency, Dependency, DependencyException
  from .interpreterbase import InterpreterBase
  from .interpreterbase import check_stringlist, noPosargs, noKwargs, stringArgs, permittedKwargs, permittedMethodKwargs
  from .interpreterbase import InterpreterException, InvalidArguments, InvalidCode
  from .interpreterbase import InterpreterObject, MutableInterpreterObject, Disabler
  from .modules import ModuleReturnValue
  
  import os, sys, shutil, uuid
  import re, shlex
  from collections import namedtuple
  from pathlib import PurePath
  
  import importlib
  
  
  def stringifyUserArguments(args):
      if isinstance(args, list):
          return '[%s]' % ', '.join([stringifyUserArguments(x) for x in args])
      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 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,
                               })
  
      def returncode_method(self, args, kwargs):
          return self.res.returncode
  
      def compiled_method(self, args, kwargs):
          return self.res.compiled
  
      def stdout_method(self, args, kwargs):
          return self.res.stdout
  
      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):
          super().__init__()
          if not isinstance(cmd, ExternalProgram):
              raise AssertionError('BUG: RunProcess must be passed an ExternalProgram')
          pc, self.stdout, self.stderr = self.run_command(cmd, args, source_dir, build_dir, subdir, mesonintrospect, in_builddir)
          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):
          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)
          mlog.debug('Running command:', ' '.join(command_array))
          try:
              p, o, e = Popen_safe(command_array, env=child_env, cwd=cwd)
              mlog.debug('--- stdout----')
              mlog.debug(o)
              mlog.debug('----stderr----')
              mlog.debug(e)
              mlog.debug('')
              return p, o, e
          except FileNotFoundError:
              raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array))
  
      def returncode_method(self, args, kwargs):
          return self.returncode
  
      def stdout_method(self, args, kwargs):
          return self.stdout
  
      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)
  
      @stringArgs
      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))
  
      def set_method(self, args, kwargs):
          self.add_var(self.held_object.set, args, kwargs)
  
      def append_method(self, args, kwargs):
          self.add_var(self.held_object.append, args, kwargs)
  
      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) != 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
  
      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
  
      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)
  
      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,
                               })
  
      def type_name_method(self, args, kwargs):
          return self.held_object.type_name
  
      def found_method(self, args, kwargs):
          if self.held_object.type_name == 'internal':
              return True
          return self.held_object.found()
  
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
      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)
  
      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)
  
  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,
                               })
  
      def found_method(self, args, kwargs):
          return True
  
      def version_method(self, args, kwargs):
          return self.held_object.get_version()
  
  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})
  
      def found_method(self, args, kwargs):
          return self.found()
  
      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})
  
      def found(self):
          return self.held_object.found()
  
      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()
  
  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})
  
      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,
                               })
  
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      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,
                               })
  
      def cpu_family_method(self, args, kwargs):
          return self.held_object.cpu_family
  
      def cpu_method(self, args, kwargs):
          return self.held_object.cpu
  
      def system_method(self, args, kwargs):
          return self.held_object.system
  
      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)
          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
  
  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)
          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_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()
  
      def private_dir_include_method(self, args, kwargs):
          return IncludeDirsHolder(build.IncludeDirs('', [], False,
                                                     [self.interpreter.backend.get_target_private_dir(self.held_object)]))
  
      def full_path_method(self, args, kwargs):
          return self.interpreter.backend.get_target_filename_abs(self.held_object)
  
      def outdir_method(self, args, kwargs):
          return self.interpreter.backend.get_target_dir(self.held_object)
  
      def extract_objects_method(self, args, kwargs):
          gobjs = self.held_object.extract_objects(args)
          return GeneratedObjectsHolder(gobjs)
  
      def extract_all_objects_method(self, args, kwargs):
          gobjs = self.held_object.extract_all_objects()
          return GeneratedObjectsHolder(gobjs)
  
      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)
  
  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)
  
      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')
  
  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, 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.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,
                               })
  
      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,
                               '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,
                               'unittest_args': self.unittest_args_method,
                               'symbols_have_underscore_prefix': self.symbols_have_underscore_prefix_method,
                               })
  
      @permittedMethodKwargs({})
      def version_method(self, args, kwargs):
          return self.compiler.version
  
      @permittedMethodKwargs({})
      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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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)
  
      @permittedMethodKwargs({})
      def get_id_method(self, args, kwargs):
          return self.compiler.get_id()
  
      @permittedMethodKwargs({})
      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)
  
      @permittedMethodKwargs({})
      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)
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          'prefix',
          'no_builtin_args',
          'include_directories',
          'args',
          'dependencies',
      })
      def has_members_method(self, args, kwargs):
          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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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', '')
          l = kwargs.get('low', -1024)
          h = kwargs.get('high', 1024)
          guess = kwargs.get('guess', None)
          if not isinstance(prefix, str):
              raise InterpreterException('Prefix argument of compute_int must be a string.')
          if not isinstance(l, int):
              raise InterpreterException('Low argument of compute_int must be an int.')
          if not isinstance(h, 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, l, h, guess, prefix, self.environment, extra_args, deps)
          mlog.log('Computing int of "%s": %d' % (expression, res))
          return res
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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
  
      @permittedMethodKwargs({
          '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.')
          required = kwargs.get('required', True)
          if not isinstance(required, bool):
              raise InterpreterException('required must be boolean.')
          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)
  
      @permittedMethodKwargs({})
      def has_argument_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          if len(args) != 1:
              raise InterpreterException('Has_arg takes exactly one argument.')
          result = self.compiler.has_argument(args[0], self.environment)
          if result:
              h = mlog.green('YES')
          else:
              h = mlog.red('NO')
          mlog.log('Compiler for {} supports argument {}:'.format(self.compiler.get_display_language(), args[0]), h)
          return result
  
      @permittedMethodKwargs({})
      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
  
      @permittedMethodKwargs({})
      def get_supported_arguments_method(self, args, kwargs):
          args = mesonlib.stringlistify(args)
          result = self.compiler.get_supported_arguments(args, self.environment)
          if len(result) == len(args):
              h = mlog.green('YES')
          elif len(result) > 0:
              h = mlog.yellow('SOME')
          else:
              h = mlog.red('NO')
          mlog.log(
              'Compiler for {} supports arguments {}:'.format(
                  self.compiler.get_display_language(), ' '.join(args)),
              h)
          return result
  
      @permittedMethodKwargs({})
      def first_supported_argument_method(self, args, kwargs):
          for i in mesonlib.stringlistify(args):
              if self.compiler.has_argument(i, self.environment):
                  mlog.log('First supported argument:', mlog.bold(i))
                  return [i]
          mlog.log('First supported 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))
          # 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,
                               '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)
  
      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)
  
      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)
  
      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)
  
      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)
  
      def backend_method(self, args, kwargs):
          return self.interpreter.backend.name
  
      def source_root_method(self, args, kwargs):
          return self.interpreter.environment.source_dir
  
      def build_root_method(self, args, kwargs):
          return self.interpreter.environment.build_dir
  
      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
  
      def is_cross_build_method(self, args, kwargs):
          return self.build.environment.is_cross_build()
  
      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)
  
      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
  
      def is_subproject_method(self, args, kwargs):
          return self.interpreter.is_subproject()
  
      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]
  
      def project_version_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['version']
  
      def project_license_method(self, args, kwargs):
          return self.build.dep_manifest[self.interpreter.active_projectname]['license']
  
      def version_method(self, args, kwargs):
          return coredata.version
  
      def project_name_method(self, args, kwargs):
          return self.interpreter.active_projectname
  
      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)
  
  
  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',
      'name_prefix',
      'name_suffix',
      'native',
      'objects',
      'override_options',
      'pic',
      'sources',
      'vs_module_defs',
  ])
  
  build_target_common_kwargs = (
      buildtarget_kwargs |
      lang_arg_kwargs |
      pch_kwargs |
      vala_kwargs |
      rust_kwargs |
      cs_kwargs)
  
  exe_kwargs = (build_target_common_kwargs) | {'implib', 'export_dynamic'}
  shlib_kwargs = (build_target_common_kwargs) | {'version', 'soversion'}
  shmod_kwargs = shlib_kwargs
  stlib_kwargs = shlib_kwargs
  
  jar_kwargs = exe_kwargs.copy()
  jar_kwargs.update(['main_class'])
  
  build_target_kwargs = exe_kwargs.copy()
  build_target_kwargs.update(['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': build_target_kwargs,
                      'configure_file': {'input', 'output', 'configuration', 'command', 'install_dir', 'capture', 'install'},
                      'custom_target': {'input', 'output', 'command', 'install', 'install_dir', 'build_always', 'capture', 'depends', 'depend_files', 'depfile', 'build_by_default'},
                      'dependency': {'default_options', 'fallback', 'language', 'main', 'method', 'modules', 'optional_modules', 'native', 'required', 'static', 'version'},
                      'declare_dependency': {'include_directories', 'link_with', 'sources', 'dependencies', 'compile_args', 'link_args', 'link_whole', 'version'},
                      'executable': exe_kwargs,
                      'find_program': {'required', 'native'},
                      'generator': {'arguments', 'output', 'depfile', 'capture', 'preserve_path_from'},
                      'include_directories': {'is_system'},
                      'install_data': {'install_dir', 'install_mode', 'sources'},
                      'install_headers': {'install_dir', 'subdir'},
                      'install_man': {'install_dir'},
                      'install_subdir': {'exclude_files', 'exclude_directories', 'install_dir', 'install_mode', 'strip_directory'},
                      'jar': jar_kwargs,
                      'project': {'version', 'meson_version', 'default_options', 'license', 'subproject_dir'},
                      'run_target': {'command', 'depends'},
                      'shared_library': shlib_kwargs,
                      'shared_module': shmod_kwargs,
                      'static_library': stlib_kwargs,
                      'subdir': {'if_found'},
                      'subproject': {'version', 'default_options'},
                      'test': {'args', 'env', 'is_parallel', 'should_fail', 'timeout', 'workdir', 'suite'},
                      'vcs_tag': {'input', 'output', 'fallback', 'command', 'replace_string'},
                      }
  
  
  class Interpreter(InterpreterBase):
  
      def __init__(self, build, backend, subproject='', subdir='', subproject_dir='subprojects',
                   default_project_options=[]):
          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
          # 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 = []
          self.default_project_options = default_project_options[:] # Passed from the outside, only used in subprojects.
          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,
                             'subproject': self.func_subproject,
                             'shared_library': self.func_shared_lib,
                             'shared_module': self.func_shared_module,
                             'static_library': self.func_static_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.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.environment.coredata.modules:
              try:
                  module = importlib.import_module('mesonbuild.modules.' + modname)
              except ImportError:
                  raise InvalidArguments('Module "%s" does not exist' % (modname, ))
              self.environment.coredata.modules[modname] = module.initialize()
          return ModuleHolder(modname, self.environment.coredata.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]
  
      @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.')
  
      @noKwargs
      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:]
          srcdir = self.environment.get_source_dir()
          builddir = self.environment.get_build_dir()
          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)
  
      @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.')
  
      @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):
          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 '\\' in dirname or '/' in 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('\nExecuting subproject ', mlog.bold(dirname), '.\n', sep='')
          subi = Interpreter(self.build, self.backend, dirname, subdir, self.subproject_dir,
                             mesonlib.stringlistify(kwargs.get('default_options', [])))
          subi.subprojects = self.subprojects
  
          subi.subproject_stack = self.subproject_stack + [dirname]
          current_active = self.active_projectname
          subi.run()
          if 'version' in kwargs:
              pv = subi.project_version
              wanted = kwargs['version']
              if pv == 'undefined' or not mesonlib.version_compare(pv, wanted):
                  raise InterpreterException('Subproject %s version is %s but %s required.' % (dirname, pv, wanted))
          self.active_projectname = current_active
          mlog.log('\nSubproject', mlog.bold(dirname), 'finished.')
          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]
  
      @stringArgs
      @noKwargs
      def func_get_option(self, nodes, args, kwargs):
          if len(args) != 1:
              raise InterpreterException('Argument required for get_option.')
          undecorated_optname = 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.''')
          try:
              return self.environment.get_coredata().base_options[optname].value
          except KeyError:
              pass
          try:
              return self.environment.coredata.get_builtin_option(optname)
          except RuntimeError:
              pass
          try:
              return self.environment.coredata.compiler_options[optname].value
          except KeyError:
              pass
          if not coredata.is_builtin_option(optname) and self.is_subproject():
              optname = self.subproject + ':' + optname
          try:
              opt = self.environment.coredata.user_options[optname]
              if opt.yielding and ':' in optname:
                  # If option not present in superproject, keep the original.
                  opt = self.environment.coredata.user_options.get(undecorated_optname, opt)
              return opt.value
          except KeyError:
              pass
          if optname.endswith('_link_args'):
              try:
                  lang = optname[:-10]
                  return self.coredata.external_link_args[lang]
              except KeyError:
                  pass
          if optname.endswith('_args'):
              try:
                  lang = optname[:-5]
                  return self.coredata.external_args[lang]
              except KeyError:
                  pass
          # Some base options are not defined in some environments, return the default value.
          try:
              return compilers.base_options[optname].value
          except KeyError:
              pass
          raise InterpreterException('Tried to access unknown option "%s".' % optname)
  
      @noKwargs
      def func_configuration_data(self, node, args, kwargs):
          if args:
              raise InterpreterException('configuration_data takes no arguments')
          return ConfigurationDataHolder()
  
      def parse_default_options(self, default_options):
          default_options = listify(default_options)
          for option in default_options:
              if not isinstance(option, str):
                  mlog.debug(option)
                  raise InterpreterException('Default options must be strings')
              if '=' not in option:
                  raise InterpreterException('All default options must be of type key=value.')
              key, value = option.split('=', 1)
              if coredata.is_builtin_option(key):
                  if self.subproject != '':
                      continue # Only the master project is allowed to set global options.
                  # If this was set on the command line, do not override.
                  if not self.environment.had_argument_for(key):
                      self.coredata.set_builtin_option(key, value)
                      # If we are setting the prefix, then other options which
                      # have prefix-dependent defaults need their value updating,
                      # if they haven't been explicitly set (i.e. have their
                      # default value)
                      if key == 'prefix':
                          for option in coredata.builtin_dir_noprefix_options:
                              if not (self.environment.had_argument_for(option) or
                                      any([k.startswith(option + '=') for k in default_options])):
                                  self.coredata.set_builtin_option(option, coredata.get_builtin_option_default(option, value))
              else:
                  # Option values set with subproject() default_options override those
                  # set in project() default_options.
                  pref = key + '='
                  for i in self.default_project_options:
                      if i.startswith(pref):
                          option = i
                          break
                  # If we are in a subproject, add the subproject prefix to option
                  # name.
                  if self.subproject != '':
                      option = self.subproject + ':' + option
                  newoptions = [option] + self.environment.cmd_line_options.projectoptions
                  self.environment.cmd_line_options.projectoptions = newoptions
          # Add options that are only in default_options.
          for defopt in self.default_project_options:
              key, value = defopt.split('=')
              pref = key + '='
              for i in default_options:
                  if i.startswith(pref):
                      break
              else:
                  defopt = self.subproject + ':' + defopt
                  newoptions = [defopt] + self.environment.cmd_line_options.projectoptions
                  self.environment.cmd_line_options.projectoptions = newoptions
  
      @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))
          default_options = kwargs.get('default_options', [])
          if self.environment.first_invocation and (len(default_options) > 0 or
                                                    len(self.default_project_options) > 0):
              self.parse_default_options(default_options)
          if not self.is_subproject():
              self.build.project_name = proj_name
          if os.path.exists(self.option_file):
              oi = optinterpreter.OptionInterpreter(self.subproject,
                                                    self.build.environment.cmd_line_options.projectoptions,
                                                    )
              oi.process(self.option_file)
              self.build.environment.merge_options(oi.options)
          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']
              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='')
          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):
          return self.add_languages(args, kwargs.get('required', True))
  
      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, 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)
  
      @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 i in new_options:
              if not i.startswith(optprefix):
                  raise InterpreterException('Internal error, %s has incorrect prefix.' % i)
              cmd_prefix = i + '='
              for cmd_arg in self.environment.cmd_line_options.projectoptions:
                  if cmd_arg.startswith(cmd_prefix):
                      value = cmd_arg.split('=', 1)[1]
                      new_options[i].set_value(value)
          new_options.update(self.coredata.compiler_options)
          self.coredata.compiler_options = new_options
          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='')
  
              # If <language>_args/_link_args settings are given on the
              # command line, use them.
              for optspec in self.build.environment.cmd_line_options.projectoptions:
                  (optname, optvalue) = optspec.split('=', maxsplit=1)
                  if optname.endswith('_link_args'):
                      lang = optname[:-10]
                      self.coredata.external_link_args.setdefault(lang, []).append(optvalue)
                  elif optname.endswith('_args'):
                      lang = optname[:-5]
                      self.coredata.external_args.setdefault(lang, []).append(optvalue)
              # Otherwise, look for definitions from environment
              # variables such as CFLAGS.
              if not comp.get_language() in self.coredata.external_args:
                  (preproc_args, compile_args, link_args) = environment.get_args_from_envvars(comp)
                  self.coredata.external_preprocess_args[comp.get_language()] = preproc_args
                  self.coredata.external_args[comp.get_language()] = compile_args
                  self.coredata.external_link_args[comp.get_language()] = link_args
              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 add_base_options(self, compiler):
          proj_opt = self.environment.cmd_line_options.projectoptions
          for optname in compiler.base_options:
              if optname in self.coredata.base_options:
                  continue
              oobj = compilers.base_options[optname]
              for po in proj_opt:
                  if po.startswith(optname + '='):
                      oobj.set_value(po.split('=', 1)[1])
                      break
              self.coredata.base_options[optname] = oobj
  
      def program_from_cross_file(self, prognames):
          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)
                  progobj = ExternalProgramHolder(extprog)
                  return progobj
  
      def program_from_system(self, args):
          # 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)
              progobj = ExternalProgramHolder(extprog)
              if progobj.found():
                  return progobj
  
      @permittedKwargs(permitted_kwargs['find_program'])
      def func_find_program(self, node, args, kwargs):
          if not args:
              raise InterpreterException('No program name specified.')
          required = kwargs.get('required', True)
          if not isinstance(required, bool):
              raise InvalidArguments('"required" argument must be a boolean.')
          progobj = None
          if self.build.environment.is_cross_build():
              use_native = kwargs.get('native', False)
              if not isinstance(use_native, bool):
                  raise InvalidArguments('Argument to "native" must be a boolean.')
              if not use_native:
                  progobj = self.program_from_cross_file(args)
          if progobj is None:
              progobj = self.program_from_system(args)
          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())
          return progobj
  
      def func_find_library(self, node, args, kwargs):
          raise InvalidCode('find_library() is removed, use the corresponding method in a compiler object instead.')
  
      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(found, wanted):
              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
  
      @permittedKwargs(permitted_kwargs['dependency'])
      def func_dependency(self, node, args, kwargs):
          self.validate_arguments(args, 1, [str])
          required = kwargs.get('required', True)
          if not isinstance(required, bool):
              raise DependencyException('Keyword "required" must be a boolean.')
          name = args[0]
  
          if name == '':
              if required:
                  raise InvalidArguments('Dependency is both required and not-found')
              return DependencyHolder(Dependency('not-found', {}))
  
          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 = None
  
              # Search for it outside the project
              try:
                  dep = dependencies.find_external_dependency(name, self.environment, kwargs)
              except DependencyException as e:
                  exception = e
  
              # Search inside the projects list
              if not dep or 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 not dep:
                      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)
  
      @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:\nAutomatic wrap-based fallback '
                       'dependency downloading is disabled.')
              return None
          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('Also couldn\'t find a 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
  
      @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):
          return self.build_target(node, args, kwargs, SharedLibraryHolder)
  
      @permittedKwargs(permitted_kwargs['shared_module'])
      def func_shared_module(self, node, args, kwargs):
          return self.build_target(node, args, kwargs, SharedModuleHolder)
  
      def func_library(self, node, args, kwargs):
          if self.coredata.get_builtin_option('default_library') == 'shared':
              return self.func_shared_lib(node, args, kwargs)
          return self.func_static_lib(node, args, kwargs)
  
      @permittedKwargs(permitted_kwargs['jar'])
      def func_jar(self, node, args, kwargs):
          kwargs['target_type'] = 'jar'
          return self.build_target(node, args, kwargs, JarHolder)
  
      @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.func_executable(node, args, kwargs)
          elif target_type == 'shared_library':
              return self.func_shared_lib(node, args, kwargs)
          elif target_type == 'static_library':
              return self.func_static_lib(node, args, kwargs)
          elif target_type == 'library':
              return self.func_library(node, args, kwargs)
          elif target_type == 'jar':
              return self.func_jar(node, args, kwargs)
          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')
          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_always', True)
          return self.func_custom_target(node, [kwargs['output']], kwargs)
  
      @stringArgs
      @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')
          name = args[0]
          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')
          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:
              try:
                  d = d.held_object
              except AttributeError:
                  pass
              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)
  
      @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)
          t = Test(args[0], prj, suite, exe.held_object, 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='')
  
      @permittedKwargs(permitted_kwargs['install_headers'])
      def func_install_headers(self, node, args, kwargs):
          source_files = self.source_strings_to_files(args)
          h = Headers(source_files, kwargs)
          self.build.headers.append(h)
          return h
  
      @permittedKwargs(permitted_kwargs['install_man'])
      def func_install_man(self, node, args, kwargs):
          fargs = self.source_strings_to_files(args)
          m = Man(fargs, kwargs)
          self.build.man.append(m)
          return m
  
      @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
          self.evaluate_codeblock(codeblock)
          self.subdir = prev_subdir
  
      def _get_kwarg_install_mode(self, kwargs):
          if 'install_mode' not in kwargs:
              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)
  
      @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)
          data = DataHolder(build.Data(sources, install_dir, install_mode))
          self.build.data.append(data.held_object)
          return data
  
      @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
  
      @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.')
          if 'configuration' in kwargs and 'command' in kwargs:
              raise InterpreterException('Must not specify both "configuration" '
                                         'and "command" keyword arguments since '
                                         'they are mutually exclusive.')
          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.')
  
          # 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)
          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)
                  missing_variables = mesonlib.do_conf_file(ifile_abs, ofile_abs,
                                                            conf.held_object)
                  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)
              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 + '~'
                  with open(dst_tmp, 'w', encoding='utf-8') as f:
                      f.writelines(res.stdout)
                  if ifile_abs:
                      shutil.copymode(ifile_abs, dst_tmp)
                  mesonlib.replace_if_different(ofile_abs, dst_tmp)
          else:
              raise InterpreterException('Configure_file must have either "configuration" or "command".')
          # 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
          idir = kwargs.get('install_dir', None)
          if isinstance(idir, str):
              cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
              self.build.data.append(build.Data([cfile], idir))
          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')
              exe_wrapper = []
              for i in inp:
                  if hasattr(i, 'held_object'):
                      i = i.held_object
                  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))))
  
      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()
  
      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')
          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)
          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
      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
      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-2015 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.
  
  """A library of random helper functionality."""
  
  import sys
  import stat
  import time
  import platform, subprocess, operator, os, shutil, re
  import collections
  from mesonbuild import mlog
  
  from glob import glob
  
  def detect_meson_py_location():
      c = sys.argv[0]
      c_dir, c_fname = os.path.split(c)
  
      # get the absolute path to the <mesontool> folder
      m_dir = None
      if os.path.isabs(c):
          # $ /foo/<mesontool>.py <args>
          m_dir = c_dir
      elif c_dir == '':
          # $ <mesontool> <args> (gets run from /usr/bin/<mesontool>)
          in_path_exe = shutil.which(c_fname)
          if in_path_exe:
              if not os.path.isabs(in_path_exe):
                  m_dir = os.getcwd()
                  c_fname = in_path_exe
              else:
                  m_dir, c_fname = os.path.split(in_path_exe)
      else:
          m_dir = os.path.abspath(c_dir)
  
      # find meson in m_dir
      if m_dir is not None:
          for fname in ['meson', 'meson.py']:
              m_path = os.path.join(m_dir, fname)
              if os.path.exists(m_path):
                  return m_path
  
      # No meson found, which means that either:
      # a) meson is not installed
      # b) meson is installed to a non-standard location
      # c) the script that invoked mesonlib is not the one of meson tools (e.g. run_unittests.py)
      fname = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', 'meson.py'))
      if os.path.exists(fname):
          return fname
      # If meson is still not found, we might be imported by out-of-source tests
      # https://github.com/mesonbuild/meson/issues/3015
      exe = shutil.which('meson')
      if exe is None:
          exe = shutil.which('meson.py')
      if exe is not None:
          return exe
      # Give up.
      raise RuntimeError('Could not determine how to run Meson. Please file a bug with details.')
  
  if os.path.basename(sys.executable) == 'meson.exe':
      # In Windows and using the MSI installed executable.
      meson_command = [sys.executable]
      python_command = [sys.executable, 'runpython']
  else:
      python_command = [sys.executable]
      meson_command = python_command + [detect_meson_py_location()]
  
  def is_ascii_string(astring):
      try:
          if isinstance(astring, str):
              astring.encode('ascii')
          if isinstance(astring, bytes):
              astring.decode('ascii')
      except UnicodeDecodeError:
          return False
      return True
  
  def check_direntry_issues(direntry_array):
      import locale
      # Warn if the locale is not UTF-8. This can cause various unfixable issues
      # such as os.stat not being able to decode filenames with unicode in them.
      # There is no way to reset both the preferred encoding and the filesystem
      # encoding, so we can just warn about it.
      e = locale.getpreferredencoding()
      if e.upper() != 'UTF-8' and not is_windows():
          if not isinstance(direntry_array, list):
              direntry_array = [direntry_array]
          for de in direntry_array:
              if is_ascii_string(de):
                  continue
              mlog.warning('''You are using {!r} which is not a Unicode-compatible '
  locale but you are trying to access a file system entry called {!r} which is
  not pure ASCII. This may cause problems.
  '''.format(e, de), file=sys.stderr)
  
  # Put this in objects that should not get dumped to pickle files
  # by accident.
  import threading
  an_unpicklable_object = threading.Lock()
  
  class MesonException(Exception):
      '''Exceptions thrown by Meson'''
  
  class EnvironmentException(MesonException):
      '''Exceptions thrown while processing and creating the build environment'''
  
  class FileMode:
      # The first triad is for owner permissions, the second for group permissions,
      # and the third for others (everyone else).
      # For the 1st character:
      #  'r' means can read
      #  '-' means not allowed
      # For the 2nd character:
      #  'w' means can write
      #  '-' means not allowed
      # For the 3rd character:
      #  'x' means can execute
      #  's' means can execute and setuid/setgid is set (owner/group triads only)
      #  'S' means cannot execute and setuid/setgid is set (owner/group triads only)
      #  't' means can execute and sticky bit is set ("others" triads only)
      #  'T' means cannot execute and sticky bit is set ("others" triads only)
      #  '-' means none of these are allowed
      #
      # The meanings of 'rwx' perms is not obvious for directories; see:
      # https://www.hackinglinuxexposed.com/articles/20030424.html
      #
      # For information on this notation such as setuid/setgid/sticky bits, see:
      # https://en.wikipedia.org/wiki/File_system_permissions#Symbolic_notation
      symbolic_perms_regex = re.compile('[r-][w-][xsS-]' # Owner perms
                                        '[r-][w-][xsS-]' # Group perms
                                        '[r-][w-][xtT-]') # Others perms
  
      def __init__(self, perms=None, owner=None, group=None):
          self.perms_s = perms
          self.perms = self.perms_s_to_bits(perms)
          self.owner = owner
          self.group = group
  
      def __repr__(self):
          ret = '<FileMode: {!r} owner={} group={}'
          return ret.format(self.perms_s, self.owner, self.group)
  
      @classmethod
      def perms_s_to_bits(cls, perms_s):
          '''
          Does the opposite of stat.filemode(), converts strings of the form
          'rwxr-xr-x' to st_mode enums which can be passed to os.chmod()
          '''
          if perms_s is None:
              # No perms specified, we will not touch the permissions
              return -1
          eg = 'rwxr-xr-x'
          if not isinstance(perms_s, str):
              msg = 'Install perms must be a string. For example, {!r}'
              raise MesonException(msg.format(eg))
          if len(perms_s) != 9 or not cls.symbolic_perms_regex.match(perms_s):
              msg = 'File perms {!r} must be exactly 9 chars. For example, {!r}'
              raise MesonException(msg.format(perms_s, eg))
          perms = 0
          # Owner perms
          if perms_s[0] == 'r':
              perms |= stat.S_IRUSR
          if perms_s[1] == 'w':
              perms |= stat.S_IWUSR
          if perms_s[2] == 'x':
              perms |= stat.S_IXUSR
          elif perms_s[2] == 'S':
              perms |= stat.S_ISUID
          elif perms_s[2] == 's':
              perms |= stat.S_IXUSR
              perms |= stat.S_ISUID
          # Group perms
          if perms_s[3] == 'r':
              perms |= stat.S_IRGRP
          if perms_s[4] == 'w':
              perms |= stat.S_IWGRP
          if perms_s[5] == 'x':
              perms |= stat.S_IXGRP
          elif perms_s[5] == 'S':
              perms |= stat.S_ISGID
          elif perms_s[5] == 's':
              perms |= stat.S_IXGRP
              perms |= stat.S_ISGID
          # Others perms
          if perms_s[6] == 'r':
              perms |= stat.S_IROTH
          if perms_s[7] == 'w':
              perms |= stat.S_IWOTH
          if perms_s[8] == 'x':
              perms |= stat.S_IXOTH
          elif perms_s[8] == 'T':
              perms |= stat.S_ISVTX
          elif perms_s[8] == 't':
              perms |= stat.S_IXOTH
              perms |= stat.S_ISVTX
          return perms
  
  class File:
      def __init__(self, is_built, subdir, fname):
          self.is_built = is_built
          self.subdir = subdir
          self.fname = fname
          assert(isinstance(self.subdir, str))
          assert(isinstance(self.fname, str))
  
      def __str__(self):
          return self.relative_name()
  
      def __repr__(self):
          ret = '<File: {0}'
          if not self.is_built:
              ret += ' (not built)'
          ret += '>'
          return ret.format(self.relative_name())
  
      @staticmethod
      def from_source_file(source_root, subdir, fname):
          if not os.path.isfile(os.path.join(source_root, subdir, fname)):
              raise MesonException('File %s does not exist.' % fname)
          return File(False, subdir, fname)
  
      @staticmethod
      def from_built_file(subdir, fname):
          return File(True, subdir, fname)
  
      @staticmethod
      def from_absolute_file(fname):
          return File(False, '', fname)
  
      def rel_to_builddir(self, build_to_src):
          if self.is_built:
              return self.relative_name()
          else:
              return os.path.join(build_to_src, self.subdir, self.fname)
  
      def absolute_path(self, srcdir, builddir):
          absdir = srcdir
          if self.is_built:
              absdir = builddir
          return os.path.join(absdir, self.relative_name())
  
      def endswith(self, ending):
          return self.fname.endswith(ending)
  
      def split(self, s):
          return self.fname.split(s)
  
      def __eq__(self, other):
          return (self.fname, self.subdir, self.is_built) == (other.fname, other.subdir, other.is_built)
  
      def __hash__(self):
          return hash((self.fname, self.subdir, self.is_built))
  
      def relative_name(self):
          return os.path.join(self.subdir, self.fname)
  
  def get_compiler_for_source(compilers, src):
      for comp in compilers:
          if comp.can_compile(src):
              return comp
      raise RuntimeError('No specified compiler can handle file {!s}'.format(src))
  
  def classify_unity_sources(compilers, sources):
      compsrclist = {}
      for src in sources:
          comp = get_compiler_for_source(compilers, src)
          if comp not in compsrclist:
              compsrclist[comp] = [src]
          else:
              compsrclist[comp].append(src)
      return compsrclist
  
  def is_osx():
      return platform.system().lower() == 'darwin'
  
  def is_linux():
      return platform.system().lower() == 'linux'
  
  def is_android():
      return platform.system().lower() == 'android'
  
  def is_haiku():
      return platform.system().lower() == 'haiku'
  
  def is_windows():
      platname = platform.system().lower()
      return platname == 'windows' or 'mingw' in platname
  
  def is_cygwin():
      platname = platform.system().lower()
      return platname.startswith('cygwin')
  
  def is_debianlike():
      return os.path.isfile('/etc/debian_version')
  
  def is_dragonflybsd():
      return platform.system().lower() == 'dragonfly'
  
  def is_freebsd():
      return platform.system().lower() == 'freebsd'
  
  def for_windows(is_cross, env):
      """
      Host machine is windows?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_windows()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'windows'
      return False
  
  def for_cygwin(is_cross, env):
      """
      Host machine is cygwin?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_cygwin()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'cygwin'
      return False
  
  def for_linux(is_cross, env):
      """
      Host machine is linux?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_linux()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'linux'
      return False
  
  def for_darwin(is_cross, env):
      """
      Host machine is Darwin (iOS/OS X)?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_osx()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'darwin'
      return False
  
  def for_android(is_cross, env):
      """
      Host machine is Android?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_android()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'android'
      return False
  
  def for_haiku(is_cross, env):
      """
      Host machine is Haiku?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_haiku()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'haiku'
      return False
  
  def exe_exists(arglist):
      try:
          p = subprocess.Popen(arglist, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
          p.communicate()
          if p.returncode == 0:
              return True
      except FileNotFoundError:
          pass
      return False
  
  def detect_vcs(source_dir):
      vcs_systems = [
          dict(name = 'git',        cmd = 'git', repo_dir = '.git', get_rev = 'git describe --dirty=+', rev_regex = '(.*)', dep = '.git/logs/HEAD'),
          dict(name = 'mercurial',  cmd = 'hg',  repo_dir = '.hg',  get_rev = 'hg id -i',               rev_regex = '(.*)', dep = '.hg/dirstate'),
          dict(name = 'subversion', cmd = 'svn', repo_dir = '.svn', get_rev = 'svn info',               rev_regex = 'Revision: (.*)', dep = '.svn/wc.db'),
          dict(name = 'bazaar',     cmd = 'bzr', repo_dir = '.bzr', get_rev = 'bzr revno',              rev_regex = '(.*)', dep = '.bzr'),
      ]
  
      segs = source_dir.replace('\\', '/').split('/')
      for i in range(len(segs), -1, -1):
          curdir = '/'.join(segs[:i])
          for vcs in vcs_systems:
              if os.path.isdir(os.path.join(curdir, vcs['repo_dir'])) and shutil.which(vcs['cmd']):
                  vcs['wc_dir'] = curdir
                  return vcs
      return None
  
  def grab_leading_numbers(vstr, strict=False):
      result = []
      for x in vstr.rstrip('.').split('.'):
          try:
              result.append(int(x))
          except ValueError as e:
              if strict:
                  msg = 'Invalid version to compare against: {!r}; only ' \
                        'numeric digits separated by "." are allowed: ' + str(e)
                  raise MesonException(msg.format(vstr))
              break
      return result
  
  numpart = re.compile('[0-9.]+')
  
  def version_compare(vstr1, vstr2, strict=False):
      match = numpart.match(vstr1.strip())
      if match is None:
          msg = 'Uncomparable version string {!r}.'
          raise MesonException(msg.format(vstr1))
      vstr1 = match.group(0)
      if vstr2.startswith('>='):
          cmpop = operator.ge
          vstr2 = vstr2[2:]
      elif vstr2.startswith('<='):
          cmpop = operator.le
          vstr2 = vstr2[2:]
      elif vstr2.startswith('!='):
          cmpop = operator.ne
          vstr2 = vstr2[2:]
      elif vstr2.startswith('=='):
          cmpop = operator.eq
          vstr2 = vstr2[2:]
      elif vstr2.startswith('='):
          cmpop = operator.eq
          vstr2 = vstr2[1:]
      elif vstr2.startswith('>'):
          cmpop = operator.gt
          vstr2 = vstr2[1:]
      elif vstr2.startswith('<'):
          cmpop = operator.lt
          vstr2 = vstr2[1:]
      else:
          cmpop = operator.eq
      varr1 = grab_leading_numbers(vstr1, strict)
      varr2 = grab_leading_numbers(vstr2, strict)
      return cmpop(varr1, varr2)
  
  def version_compare_many(vstr1, conditions):
      if not isinstance(conditions, (list, tuple, frozenset)):
          conditions = [conditions]
      found = []
      not_found = []
      for req in conditions:
          if not version_compare(vstr1, req, strict=True):
              not_found.append(req)
          else:
              found.append(req)
      return not_found == [], not_found, found
  
  def default_libdir():
      if is_debianlike():
          try:
              pc = subprocess.Popen(['dpkg-architecture', '-qDEB_HOST_MULTIARCH'],
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.DEVNULL)
              (stdo, _) = pc.communicate()
              if pc.returncode == 0:
                  archpath = stdo.decode().strip()
                  return 'lib/' + archpath
          except Exception:
              pass
      if os.path.isdir('/usr/lib64') and not os.path.islink('/usr/lib64'):
          return 'lib64'
      return 'lib'
  
  def default_libexecdir():
      # There is no way to auto-detect this, so it must be set at build time
      return 'libexec'
  
  def default_prefix():
      return 'c:/' if is_windows() else '/usr/local'
  
  def get_library_dirs():
      if is_windows():
          return ['C:/mingw/lib'] # Fixme
      if is_osx():
          return ['/usr/lib'] # Fix me as well.
      # The following is probably Debian/Ubuntu specific.
      # /usr/local/lib is first because it contains stuff
      # installed by the sysadmin and is probably more up-to-date
      # than /usr/lib. If you feel that this search order is
      # problematic, please raise the issue on the mailing list.
      unixdirs = ['/usr/local/lib', '/usr/lib', '/lib']
      plat = subprocess.check_output(['uname', '-m']).decode().strip()
      # This is a terrible hack. I admit it and I'm really sorry.
      # I just don't know what the correct solution is.
      if plat == 'i686':
          plat = 'i386'
      if plat.startswith('arm'):
          plat = 'arm'
      unixdirs += glob('/usr/lib/' + plat + '*')
      if os.path.exists('/usr/lib64'):
          unixdirs.append('/usr/lib64')
      unixdirs += glob('/lib/' + plat + '*')
      if os.path.exists('/lib64'):
          unixdirs.append('/lib64')
      unixdirs += glob('/lib/' + plat + '*')
      return unixdirs
  
  def has_path_sep(name, sep='/\\'):
      'Checks if any of the specified @sep path separators are in @name'
      for each in sep:
          if each in name:
              return True
      return False
  
  def do_replacement(regex, line, confdata):
      missing_variables = set()
  
      def variable_replace(match):
          # Pairs of escape characters before '@' or '\@'
          if match.group(0).endswith('\\'):
              num_escapes = match.end(0) - match.start(0)
              return '\\' * (num_escapes // 2)
          # Single escape character and '@'
          elif match.group(0) == '\\@':
              return '@'
          # Template variable to be replaced
          else:
              varname = match.group(1)
              if varname in confdata:
                  (var, desc) = confdata.get(varname)
                  if isinstance(var, str):
                      pass
                  elif isinstance(var, int):
                      var = str(var)
                  else:
                      raise RuntimeError('Tried to replace a variable with something other than a string or int.')
              else:
                  missing_variables.add(varname)
                  var = ''
              return var
      return re.sub(regex, variable_replace, line), missing_variables
  
  def do_mesondefine(line, confdata):
      arr = line.split()
      if len(arr) != 2:
          raise MesonException('#mesondefine does not contain exactly two tokens: %s', line.strip())
      varname = arr[1]
      try:
          (v, desc) = confdata.get(varname)
      except KeyError:
          return '/* #undef %s */\n' % varname
      if isinstance(v, bool):
          if v:
              return '#define %s\n' % varname
          else:
              return '#undef %s\n' % varname
      elif isinstance(v, int):
          return '#define %s %d\n' % (varname, v)
      elif isinstance(v, str):
          return '#define %s %s\n' % (varname, v)
      else:
          raise MesonException('#mesondefine argument "%s" is of unknown type.' % varname)
  
  
  def do_conf_file(src, dst, confdata):
      try:
          with open(src, encoding='utf-8') as f:
              data = f.readlines()
      except Exception as e:
          raise MesonException('Could not read input file %s: %s' % (src, str(e)))
      # Only allow (a-z, A-Z, 0-9, _, -) as valid characters for a define
      # Also allow escaping '@' with '\@'
      regex = re.compile(r'(?:\\\\)+(?=\\?@)|\\@|@([-a-zA-Z0-9_]+)@')
      result = []
      missing_variables = set()
      for line in data:
          if line.startswith('#mesondefine'):
              line = do_mesondefine(line, confdata)
          else:
              line, missing = do_replacement(regex, line, confdata)
              missing_variables.update(missing)
          result.append(line)
      dst_tmp = dst + '~'
      with open(dst_tmp, 'w', encoding='utf-8') as f:
          f.writelines(result)
      shutil.copymode(src, dst_tmp)
      replace_if_different(dst, dst_tmp)
      return missing_variables
  
  def dump_conf_header(ofilename, cdata):
      ofilename_tmp = ofilename + '~'
      with open(ofilename_tmp, 'w', encoding='utf-8') as ofile:
          ofile.write('''/*
   * Autogenerated by the Meson build system.
   * Do not edit, your changes will be lost.
   */
  
  #pragma once
  
  ''')
          for k in sorted(cdata.keys()):
              (v, desc) = cdata.get(k)
              if desc:
                  ofile.write('/* %s */\n' % desc)
              if isinstance(v, bool):
                  if v:
                      ofile.write('#define %s\n\n' % k)
                  else:
                      ofile.write('#undef %s\n\n' % k)
              elif isinstance(v, (int, str)):
                  ofile.write('#define %s %s\n\n' % (k, v))
              else:
                  raise MesonException('Unknown data type in configuration file entry: ' + k)
      replace_if_different(ofilename, ofilename_tmp)
  
  def replace_if_different(dst, dst_tmp):
      # If contents are identical, don't touch the file to prevent
      # unnecessary rebuilds.
      different = True
      try:
          with open(dst, 'rb') as f1, open(dst_tmp, 'rb') as f2:
              if f1.read() == f2.read():
                  different = False
      except FileNotFoundError:
          pass
      if different:
          os.replace(dst_tmp, dst)
      else:
          os.unlink(dst_tmp)
  
  def listify(item, flatten=True, unholder=False):
      '''
      Returns a list with all args embedded in a list if they are not a list.
      This function preserves order.
      @flatten: Convert lists of lists to a flat list
      @unholder: Replace each item with the object it holds, if required
  
      Note: unholding only works recursively when flattening
      '''
      if not isinstance(item, list):
          if unholder and hasattr(item, 'held_object'):
              item = item.held_object
          return [item]
      result = []
      for i in item:
          if unholder and hasattr(i, 'held_object'):
              i = i.held_object
          if flatten and isinstance(i, list):
              result += listify(i, flatten=True, unholder=unholder)
          else:
              result.append(i)
      return result
  
  
  def extract_as_list(dict_object, *keys, pop=False, **kwargs):
      '''
      Extracts all values from given dict_object and listifies them.
      '''
      result = []
      fetch = dict_object.get
      if pop:
          fetch = dict_object.pop
      # If there's only one key, we don't return a list with one element
      if len(keys) == 1:
          return listify(fetch(keys[0], []), **kwargs)
      # Return a list of values corresponding to *keys
      for key in keys:
          result.append(listify(fetch(key, []), **kwargs))
      return result
  
  
  def typeslistify(item, types):
      '''
      Ensure that type(@item) is one of @types or a
      list of items all of which are of type @types
      '''
      if isinstance(item, types):
          item = [item]
      if not isinstance(item, list):
          raise MesonException('Item must be a list or one of {!r}'.format(types))
      for i in item:
          if i is not None and not isinstance(i, types):
              raise MesonException('List item must be one of {!r}'.format(types))
      return item
  
  def stringlistify(item):
      return typeslistify(item, str)
  
  def expand_arguments(args):
      expended_args = []
      for arg in args:
          if not arg.startswith('@'):
              expended_args.append(arg)
              continue
  
          args_file = arg[1:]
          try:
              with open(args_file) as f:
                  extended_args = f.read().split()
              expended_args += extended_args
          except Exception as e:
              print('Error expanding command line arguments, %s not found' % args_file)
              print(e)
              return None
      return expended_args
  
  def Popen_safe(args, write=None, stderr=subprocess.PIPE, **kwargs):
      if sys.version_info < (3, 6) or not sys.stdout.encoding:
          return Popen_safe_legacy(args, write=write, stderr=stderr, **kwargs)
      p = subprocess.Popen(args, universal_newlines=True,
                           close_fds=False,
                           stdout=subprocess.PIPE,
                           stderr=stderr, **kwargs)
      o, e = p.communicate(write)
      return p, o, e
  
  def Popen_safe_legacy(args, write=None, stderr=subprocess.PIPE, **kwargs):
      p = subprocess.Popen(args, universal_newlines=False,
                           stdout=subprocess.PIPE,
                           stderr=stderr, **kwargs)
      if write is not None:
          write = write.encode('utf-8')
      o, e = p.communicate(write)
      if o is not None:
          if sys.stdout.encoding:
              o = o.decode(encoding=sys.stdout.encoding, errors='replace').replace('\r\n', '\n')
          else:
              o = o.decode(errors='replace').replace('\r\n', '\n')
      if e is not None:
          if sys.stderr.encoding:
              e = e.decode(encoding=sys.stderr.encoding, errors='replace').replace('\r\n', '\n')
          else:
              e = e.decode(errors='replace').replace('\r\n', '\n')
      return p, o, e
  
  def iter_regexin_iter(regexiter, initer):
      '''
      Takes each regular expression in @regexiter and tries to search for it in
      every item in @initer. If there is a match, returns that match.
      Else returns False.
      '''
      for regex in regexiter:
          for ii in initer:
              if not isinstance(ii, str):
                  continue
              match = re.search(regex, ii)
              if match:
                  return match.group()
      return False
  
  def _substitute_values_check_errors(command, values):
      # Error checking
      inregex = ('@INPUT([0-9]+)?@', '@PLAINNAME@', '@BASENAME@')
      outregex = ('@OUTPUT([0-9]+)?@', '@OUTDIR@')
      if '@INPUT@' not in values:
          # Error out if any input-derived templates are present in the command
          match = iter_regexin_iter(inregex, command)
          if match:
              m = 'Command cannot have {!r}, since no input files were specified'
              raise MesonException(m.format(match))
      else:
          if len(values['@INPUT@']) > 1:
              # Error out if @PLAINNAME@ or @BASENAME@ is present in the command
              match = iter_regexin_iter(inregex[1:], command)
              if match:
                  raise MesonException('Command cannot have {!r} when there is '
                                       'more than one input file'.format(match))
          # Error out if an invalid @INPUTnn@ template was specified
          for each in command:
              if not isinstance(each, str):
                  continue
              match = re.search(inregex[0], each)
              if match and match.group() not in values:
                  m = 'Command cannot have {!r} since there are only {!r} inputs'
                  raise MesonException(m.format(match.group(), len(values['@INPUT@'])))
      if '@OUTPUT@' not in values:
          # Error out if any output-derived templates are present in the command
          match = iter_regexin_iter(outregex, command)
          if match:
              m = 'Command cannot have {!r} since there are no outputs'
              raise MesonException(m.format(match))
      else:
          # Error out if an invalid @OUTPUTnn@ template was specified
          for each in command:
              if not isinstance(each, str):
                  continue
              match = re.search(outregex[0], each)
              if match and match.group() not in values:
                  m = 'Command cannot have {!r} since there are only {!r} outputs'
                  raise MesonException(m.format(match.group(), len(values['@OUTPUT@'])))
  
  def substitute_values(command, values):
      '''
      Substitute the template strings in the @values dict into the list of
      strings @command and return a new list. For a full list of the templates,
      see get_filenames_templates_dict()
  
      If multiple inputs/outputs are given in the @values dictionary, we
      substitute @INPUT@ and @OUTPUT@ only if they are the entire string, not
      just a part of it, and in that case we substitute *all* of them.
      '''
      # Error checking
      _substitute_values_check_errors(command, values)
      # Substitution
      outcmd = []
      rx_keys = [re.escape(key) for key in values if key not in ('@INPUT@', '@OUTPUT@')]
      value_rx = re.compile('|'.join(rx_keys)) if rx_keys else None
      for vv in command:
          if not isinstance(vv, str):
              outcmd.append(vv)
          elif '@INPUT@' in vv:
              inputs = values['@INPUT@']
              if vv == '@INPUT@':
                  outcmd += inputs
              elif len(inputs) == 1:
                  outcmd.append(vv.replace('@INPUT@', inputs[0]))
              else:
                  raise MesonException("Command has '@INPUT@' as part of a "
                                       "string and more than one input file")
          elif '@OUTPUT@' in vv:
              outputs = values['@OUTPUT@']
              if vv == '@OUTPUT@':
                  outcmd += outputs
              elif len(outputs) == 1:
                  outcmd.append(vv.replace('@OUTPUT@', outputs[0]))
              else:
                  raise MesonException("Command has '@OUTPUT@' as part of a "
                                       "string and more than one output file")
          # Append values that are exactly a template string.
          # This is faster than a string replace.
          elif vv in values:
              outcmd.append(values[vv])
          # Substitute everything else with replacement
          elif value_rx:
              outcmd.append(value_rx.sub(lambda m: values[m.group(0)], vv))
          else:
              outcmd.append(vv)
      return outcmd
  
  def get_filenames_templates_dict(inputs, outputs):
      '''
      Create a dictionary with template strings as keys and values as values for
      the following templates:
  
      @INPUT@  - the full path to one or more input files, from @inputs
      @OUTPUT@ - the full path to one or more output files, from @outputs
      @OUTDIR@ - the full path to the directory containing the output files
  
      If there is only one input file, the following keys are also created:
  
      @PLAINNAME@ - the filename of the input file
      @BASENAME@ - the filename of the input file with the extension removed
  
      If there is more than one input file, the following keys are also created:
  
      @INPUT0@, @INPUT1@, ... one for each input file
  
      If there is more than one output file, the following keys are also created:
  
      @OUTPUT0@, @OUTPUT1@, ... one for each output file
      '''
      values = {}
      # Gather values derived from the input
      if inputs:
          # We want to substitute all the inputs.
          values['@INPUT@'] = inputs
          for (ii, vv) in enumerate(inputs):
              # Write out @INPUT0@, @INPUT1@, ...
              values['@INPUT{}@'.format(ii)] = vv
          if len(inputs) == 1:
              # Just one value, substitute @PLAINNAME@ and @BASENAME@
              values['@PLAINNAME@'] = plain = os.path.basename(inputs[0])
              values['@BASENAME@'] = os.path.splitext(plain)[0]
      if outputs:
          # Gather values derived from the outputs, similar to above.
          values['@OUTPUT@'] = outputs
          for (ii, vv) in enumerate(outputs):
              values['@OUTPUT{}@'.format(ii)] = vv
          # Outdir should be the same for all outputs
          values['@OUTDIR@'] = os.path.dirname(outputs[0])
          # Many external programs fail on empty arguments.
          if values['@OUTDIR@'] == '':
              values['@OUTDIR@'] = '.'
      return values
  
  
  def windows_proof_rmtree(f):
      # On Windows if anyone is holding a file open you can't
      # delete it. As an example an anti virus scanner might
      # be scanning files you are trying to delete. The only
      # way to fix this is to try again and again.
      delays = [0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2]
      for d in delays:
          try:
              shutil.rmtree(f)
              return
          except FileNotFoundError:
              return
          except (OSError, PermissionError):
              time.sleep(d)
      # Try one last time and throw if it fails.
      shutil.rmtree(f)
  
  
  def detect_subprojects(spdir_name, current_dir='', result=None):
      if result is None:
          result = {}
      spdir = os.path.join(current_dir, spdir_name)
      if not os.path.exists(spdir):
          return result
      for trial in glob(os.path.join(spdir, '*')):
          basename = os.path.basename(trial)
          if trial == 'packagecache':
              continue
          append_this = True
          if os.path.isdir(trial):
              detect_subprojects(spdir_name, trial, result)
          elif trial.endswith('.wrap') and os.path.isfile(trial):
              basename = os.path.splitext(basename)[0]
          else:
              append_this = False
          if append_this:
              if basename in result:
                  result[basename].append(trial)
              else:
                  result[basename] = [trial]
      return result
  
  class OrderedSet(collections.MutableSet):
      """A set that preserves the order in which items are added, by first
      insertion.
      """
      def __init__(self, iterable=None):
          self.__container = collections.OrderedDict()
          if iterable:
              self.update(iterable)
  
      def __contains__(self, value):
          return value in self.__container
  
      def __iter__(self):
          return iter(self.__container.keys())
  
      def __len__(self):
          return len(self.__container)
  
      def __repr__(self):
          # Don't print 'OrderedSet("")' for an empty set.
          if self.__container:
              return 'OrderedSet("{}")'.format(
                  '", "'.join(repr(e) for e in self.__container.keys()))
          return 'OrderedSet()'
  
      def add(self, value):
          self.__container[value] = None
  
      def discard(self, value):
          if value in self.__container:
              del self.__container[value]
  
      def update(self, iterable):
          for item in iterable:
              self.__container[item] = None
  
      def difference(self, set_):
          return type(self)(e for e in self if e not in set_)
  
files: mesonbuild/mesonlib.py
files: # Copyright 2012-2015 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.
  
  """A library of random helper functionality."""
  
  import sys
  import stat
  import time
  import platform, subprocess, operator, os, shutil, re
  import collections
  from mesonbuild import mlog
  
  from glob import glob
  
  def detect_meson_py_location():
      c = sys.argv[0]
      c_dir, c_fname = os.path.split(c)
  
      # get the absolute path to the <mesontool> folder
      m_dir = None
      if os.path.isabs(c):
          # $ /foo/<mesontool>.py <args>
          m_dir = c_dir
      elif c_dir == '':
          # $ <mesontool> <args> (gets run from /usr/bin/<mesontool>)
          in_path_exe = shutil.which(c_fname)
          if in_path_exe:
              if not os.path.isabs(in_path_exe):
                  m_dir = os.getcwd()
                  c_fname = in_path_exe
              else:
                  m_dir, c_fname = os.path.split(in_path_exe)
      else:
          m_dir = os.path.abspath(c_dir)
  
      # find meson in m_dir
      if m_dir is not None:
          for fname in ['meson', 'meson.py']:
              m_path = os.path.join(m_dir, fname)
              if os.path.exists(m_path):
                  return m_path
  
      # No meson found, which means that either:
      # a) meson is not installed
      # b) meson is installed to a non-standard location
      # c) the script that invoked mesonlib is not the one of meson tools (e.g. run_unittests.py)
      fname = os.path.normpath(os.path.join(os.path.dirname(__file__), '..', 'meson.py'))
      if os.path.exists(fname):
          return fname
      # If meson is still not found, we might be imported by out-of-source tests
      # https://github.com/mesonbuild/meson/issues/3015
      exe = shutil.which('meson')
      if exe is None:
          exe = shutil.which('meson.py')
      if exe is not None:
          return exe
      # Give up.
      raise RuntimeError('Could not determine how to run Meson. Please file a bug with details.')
  
  if os.path.basename(sys.executable) == 'meson.exe':
      # In Windows and using the MSI installed executable.
      meson_command = [sys.executable]
      python_command = [sys.executable, 'runpython']
  else:
      python_command = [sys.executable]
      meson_command = python_command + [detect_meson_py_location()]
  
  def is_ascii_string(astring):
      try:
          if isinstance(astring, str):
              astring.encode('ascii')
          if isinstance(astring, bytes):
              astring.decode('ascii')
      except UnicodeDecodeError:
          return False
      return True
  
  def check_direntry_issues(direntry_array):
      import locale
      # Warn if the locale is not UTF-8. This can cause various unfixable issues
      # such as os.stat not being able to decode filenames with unicode in them.
      # There is no way to reset both the preferred encoding and the filesystem
      # encoding, so we can just warn about it.
      e = locale.getpreferredencoding()
      if e.upper() != 'UTF-8' and not is_windows():
          if not isinstance(direntry_array, list):
              direntry_array = [direntry_array]
          for de in direntry_array:
              if is_ascii_string(de):
                  continue
              mlog.warning('''You are using {!r} which is not a Unicode-compatible '
  locale but you are trying to access a file system entry called {!r} which is
  not pure ASCII. This may cause problems.
  '''.format(e, de), file=sys.stderr)
  
  # Put this in objects that should not get dumped to pickle files
  # by accident.
  import threading
  an_unpicklable_object = threading.Lock()
  
  class MesonException(Exception):
      '''Exceptions thrown by Meson'''
  
  class EnvironmentException(MesonException):
      '''Exceptions thrown while processing and creating the build environment'''
  
  class FileMode:
      # The first triad is for owner permissions, the second for group permissions,
      # and the third for others (everyone else).
      # For the 1st character:
      #  'r' means can read
      #  '-' means not allowed
      # For the 2nd character:
      #  'w' means can write
      #  '-' means not allowed
      # For the 3rd character:
      #  'x' means can execute
      #  's' means can execute and setuid/setgid is set (owner/group triads only)
      #  'S' means cannot execute and setuid/setgid is set (owner/group triads only)
      #  't' means can execute and sticky bit is set ("others" triads only)
      #  'T' means cannot execute and sticky bit is set ("others" triads only)
      #  '-' means none of these are allowed
      #
      # The meanings of 'rwx' perms is not obvious for directories; see:
      # https://www.hackinglinuxexposed.com/articles/20030424.html
      #
      # For information on this notation such as setuid/setgid/sticky bits, see:
      # https://en.wikipedia.org/wiki/File_system_permissions#Symbolic_notation
      symbolic_perms_regex = re.compile('[r-][w-][xsS-]' # Owner perms
                                        '[r-][w-][xsS-]' # Group perms
                                        '[r-][w-][xtT-]') # Others perms
  
      def __init__(self, perms=None, owner=None, group=None):
          self.perms_s = perms
          self.perms = self.perms_s_to_bits(perms)
          self.owner = owner
          self.group = group
  
      def __repr__(self):
          ret = '<FileMode: {!r} owner={} group={}'
          return ret.format(self.perms_s, self.owner, self.group)
  
      @classmethod
      def perms_s_to_bits(cls, perms_s):
          '''
          Does the opposite of stat.filemode(), converts strings of the form
          'rwxr-xr-x' to st_mode enums which can be passed to os.chmod()
          '''
          if perms_s is None:
              # No perms specified, we will not touch the permissions
              return -1
          eg = 'rwxr-xr-x'
          if not isinstance(perms_s, str):
              msg = 'Install perms must be a string. For example, {!r}'
              raise MesonException(msg.format(eg))
          if len(perms_s) != 9 or not cls.symbolic_perms_regex.match(perms_s):
              msg = 'File perms {!r} must be exactly 9 chars. For example, {!r}'
              raise MesonException(msg.format(perms_s, eg))
          perms = 0
          # Owner perms
          if perms_s[0] == 'r':
              perms |= stat.S_IRUSR
          if perms_s[1] == 'w':
              perms |= stat.S_IWUSR
          if perms_s[2] == 'x':
              perms |= stat.S_IXUSR
          elif perms_s[2] == 'S':
              perms |= stat.S_ISUID
          elif perms_s[2] == 's':
              perms |= stat.S_IXUSR
              perms |= stat.S_ISUID
          # Group perms
          if perms_s[3] == 'r':
              perms |= stat.S_IRGRP
          if perms_s[4] == 'w':
              perms |= stat.S_IWGRP
          if perms_s[5] == 'x':
              perms |= stat.S_IXGRP
          elif perms_s[5] == 'S':
              perms |= stat.S_ISGID
          elif perms_s[5] == 's':
              perms |= stat.S_IXGRP
              perms |= stat.S_ISGID
          # Others perms
          if perms_s[6] == 'r':
              perms |= stat.S_IROTH
          if perms_s[7] == 'w':
              perms |= stat.S_IWOTH
          if perms_s[8] == 'x':
              perms |= stat.S_IXOTH
          elif perms_s[8] == 'T':
              perms |= stat.S_ISVTX
          elif perms_s[8] == 't':
              perms |= stat.S_IXOTH
              perms |= stat.S_ISVTX
          return perms
  
  class File:
      def __init__(self, is_built, subdir, fname):
          self.is_built = is_built
          self.subdir = subdir
          self.fname = fname
          assert(isinstance(self.subdir, str))
          assert(isinstance(self.fname, str))
  
      def __str__(self):
          return self.relative_name()
  
      def __repr__(self):
          ret = '<File: {0}'
          if not self.is_built:
              ret += ' (not built)'
          ret += '>'
          return ret.format(self.relative_name())
  
      @staticmethod
      def from_source_file(source_root, subdir, fname):
          if not os.path.isfile(os.path.join(source_root, subdir, fname)):
              raise MesonException('File %s does not exist.' % fname)
          return File(False, subdir, fname)
  
      @staticmethod
      def from_built_file(subdir, fname):
          return File(True, subdir, fname)
  
      @staticmethod
      def from_absolute_file(fname):
          return File(False, '', fname)
  
      def rel_to_builddir(self, build_to_src):
          if self.is_built:
              return self.relative_name()
          else:
              return os.path.join(build_to_src, self.subdir, self.fname)
  
      def absolute_path(self, srcdir, builddir):
          absdir = srcdir
          if self.is_built:
              absdir = builddir
          return os.path.join(absdir, self.relative_name())
  
      def endswith(self, ending):
          return self.fname.endswith(ending)
  
      def split(self, s):
          return self.fname.split(s)
  
      def __eq__(self, other):
          return (self.fname, self.subdir, self.is_built) == (other.fname, other.subdir, other.is_built)
  
      def __hash__(self):
          return hash((self.fname, self.subdir, self.is_built))
  
      def relative_name(self):
          return os.path.join(self.subdir, self.fname)
  
  def get_compiler_for_source(compilers, src):
      for comp in compilers:
          if comp.can_compile(src):
              return comp
      raise RuntimeError('No specified compiler can handle file {!s}'.format(src))
  
  def classify_unity_sources(compilers, sources):
      compsrclist = {}
      for src in sources:
          comp = get_compiler_for_source(compilers, src)
          if comp not in compsrclist:
              compsrclist[comp] = [src]
          else:
              compsrclist[comp].append(src)
      return compsrclist
  
  def is_osx():
      return platform.system().lower() == 'darwin'
  
  def is_linux():
      return platform.system().lower() == 'linux'
  
  def is_android():
      return platform.system().lower() == 'android'
  
  def is_haiku():
      return platform.system().lower() == 'haiku'
  
  def is_windows():
      platname = platform.system().lower()
      return platname == 'windows' or 'mingw' in platname
  
  def is_cygwin():
      platname = platform.system().lower()
      return platname.startswith('cygwin')
  
  def is_debianlike():
      return os.path.isfile('/etc/debian_version')
  
  def is_dragonflybsd():
      return platform.system().lower() == 'dragonfly'
  
  def is_freebsd():
      return platform.system().lower() == 'freebsd'
  
  def for_windows(is_cross, env):
      """
      Host machine is windows?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_windows()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'windows'
      return False
  
  def for_cygwin(is_cross, env):
      """
      Host machine is cygwin?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_cygwin()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'cygwin'
      return False
  
  def for_linux(is_cross, env):
      """
      Host machine is linux?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_linux()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'linux'
      return False
  
  def for_darwin(is_cross, env):
      """
      Host machine is Darwin (iOS/OS X)?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_osx()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'darwin'
      return False
  
  def for_android(is_cross, env):
      """
      Host machine is Android?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_android()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'android'
      return False
  
  def for_haiku(is_cross, env):
      """
      Host machine is Haiku?
  
      Note: 'host' is the machine on which compiled binaries will run
      """
      if not is_cross:
          return is_haiku()
      elif env.cross_info.has_host():
          return env.cross_info.config['host_machine']['system'] == 'haiku'
      return False
  
  def exe_exists(arglist):
      try:
          p = subprocess.Popen(arglist, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
          p.communicate()
          if p.returncode == 0:
              return True
      except FileNotFoundError:
          pass
      return False
  
  def detect_vcs(source_dir):
      vcs_systems = [
          dict(name = 'git',        cmd = 'git', repo_dir = '.git', get_rev = 'git describe --dirty=+', rev_regex = '(.*)', dep = '.git/logs/HEAD'),
          dict(name = 'mercurial',  cmd = 'hg',  repo_dir = '.hg',  get_rev = 'hg id -i',               rev_regex = '(.*)', dep = '.hg/dirstate'),
          dict(name = 'subversion', cmd = 'svn', repo_dir = '.svn', get_rev = 'svn info',               rev_regex = 'Revision: (.*)', dep = '.svn/wc.db'),
          dict(name = 'bazaar',     cmd = 'bzr', repo_dir = '.bzr', get_rev = 'bzr revno',              rev_regex = '(.*)', dep = '.bzr'),
      ]
  
      segs = source_dir.replace('\\', '/').split('/')
      for i in range(len(segs), -1, -1):
          curdir = '/'.join(segs[:i])
          for vcs in vcs_systems:
              if os.path.isdir(os.path.join(curdir, vcs['repo_dir'])) and shutil.which(vcs['cmd']):
                  vcs['wc_dir'] = curdir
                  return vcs
      return None
  
  def grab_leading_numbers(vstr, strict=False):
      result = []
      for x in vstr.rstrip('.').split('.'):
          try:
              result.append(int(x))
          except ValueError as e:
              if strict:
                  msg = 'Invalid version to compare against: {!r}; only ' \
                        'numeric digits separated by "." are allowed: ' + str(e)
                  raise MesonException(msg.format(vstr))
              break
      return result
  
  numpart = re.compile('[0-9.]+')
  
  def version_compare(vstr1, vstr2, strict=False):
      match = numpart.match(vstr1.strip())
      if match is None:
          msg = 'Uncomparable version string {!r}.'
          raise MesonException(msg.format(vstr1))
      vstr1 = match.group(0)
      if vstr2.startswith('>='):
          cmpop = operator.ge
          vstr2 = vstr2[2:]
      elif vstr2.startswith('<='):
          cmpop = operator.le
          vstr2 = vstr2[2:]
      elif vstr2.startswith('!='):
          cmpop = operator.ne
          vstr2 = vstr2[2:]
      elif vstr2.startswith('=='):
          cmpop = operator.eq
          vstr2 = vstr2[2:]
      elif vstr2.startswith('='):
          cmpop = operator.eq
          vstr2 = vstr2[1:]
      elif vstr2.startswith('>'):
          cmpop = operator.gt
          vstr2 = vstr2[1:]
      elif vstr2.startswith('<'):
          cmpop = operator.lt
          vstr2 = vstr2[1:]
      else:
          cmpop = operator.eq
      varr1 = grab_leading_numbers(vstr1, strict)
      varr2 = grab_leading_numbers(vstr2, strict)
      return cmpop(varr1, varr2)
  
  def version_compare_many(vstr1, conditions):
      if not isinstance(conditions, (list, tuple, frozenset)):
          conditions = [conditions]
      found = []
      not_found = []
      for req in conditions:
          if not version_compare(vstr1, req, strict=True):
              not_found.append(req)
          else:
              found.append(req)
      return not_found == [], not_found, found
  
  def default_libdir():
      if is_debianlike():
          try:
              pc = subprocess.Popen(['dpkg-architecture', '-qDEB_HOST_MULTIARCH'],
                                    stdout=subprocess.PIPE,
                                    stderr=subprocess.DEVNULL)
              (stdo, _) = pc.communicate()
              if pc.returncode == 0:
                  archpath = stdo.decode().strip()
                  return 'lib/' + archpath
          except Exception:
              pass
      if os.path.isdir('/usr/lib64') and not os.path.islink('/usr/lib64'):
          return 'lib64'
      return 'lib'
  
  def default_libexecdir():
      # There is no way to auto-detect this, so it must be set at build time
      return 'libexec'
  
  def default_prefix():
      return 'c:/' if is_windows() else '/usr/local'
  
  def get_library_dirs():
      if is_windows():
          return ['C:/mingw/lib'] # Fixme
      if is_osx():
          return ['/usr/lib'] # Fix me as well.
      # The following is probably Debian/Ubuntu specific.
      # /usr/local/lib is first because it contains stuff
      # installed by the sysadmin and is probably more up-to-date
      # than /usr/lib. If you feel that this search order is
      # problematic, please raise the issue on the mailing list.
      unixdirs = ['/usr/local/lib', '/usr/lib', '/lib']
      plat = subprocess.check_output(['uname', '-m']).decode().strip()
      # This is a terrible hack. I admit it and I'm really sorry.
      # I just don't know what the correct solution is.
      if plat == 'i686':
          plat = 'i386'
      if plat.startswith('arm'):
          plat = 'arm'
      unixdirs += glob('/usr/lib/' + plat + '*')
      if os.path.exists('/usr/lib64'):
          unixdirs.append('/usr/lib64')
      unixdirs += glob('/lib/' + plat + '*')
      if os.path.exists('/lib64'):
          unixdirs.append('/lib64')
      unixdirs += glob('/lib/' + plat + '*')
      return unixdirs
  
  
  def do_replacement(regex, line, confdata):
      missing_variables = set()
  
      def variable_replace(match):
          # Pairs of escape characters before '@' or '\@'
          if match.group(0).endswith('\\'):
              num_escapes = match.end(0) - match.start(0)
              return '\\' * (num_escapes // 2)
          # Single escape character and '@'
          elif match.group(0) == '\\@':
              return '@'
          # Template variable to be replaced
          else:
              varname = match.group(1)
              if varname in confdata:
                  (var, desc) = confdata.get(varname)
                  if isinstance(var, str):
                      pass
                  elif isinstance(var, int):
                      var = str(var)
                  else:
                      raise RuntimeError('Tried to replace a variable with something other than a string or int.')
              else:
                  missing_variables.add(varname)
                  var = ''
              return var
      return re.sub(regex, variable_replace, line), missing_variables
  
  def do_mesondefine(line, confdata):
      arr = line.split()
      if len(arr) != 2:
          raise MesonException('#mesondefine does not contain exactly two tokens: %s', line.strip())
      varname = arr[1]
      try:
          (v, desc) = confdata.get(varname)
      except KeyError:
          return '/* #undef %s */\n' % varname
      if isinstance(v, bool):
          if v:
              return '#define %s\n' % varname
          else:
              return '#undef %s\n' % varname
      elif isinstance(v, int):
          return '#define %s %d\n' % (varname, v)
      elif isinstance(v, str):
          return '#define %s %s\n' % (varname, v)
      else:
          raise MesonException('#mesondefine argument "%s" is of unknown type.' % varname)
  
  
  def do_conf_file(src, dst, confdata):
      try:
          with open(src, encoding='utf-8') as f:
              data = f.readlines()
      except Exception as e:
          raise MesonException('Could not read input file %s: %s' % (src, str(e)))
      # Only allow (a-z, A-Z, 0-9, _, -) as valid characters for a define
      # Also allow escaping '@' with '\@'
      regex = re.compile(r'(?:\\\\)+(?=\\?@)|\\@|@([-a-zA-Z0-9_]+)@')
      result = []
      missing_variables = set()
      for line in data:
          if line.startswith('#mesondefine'):
              line = do_mesondefine(line, confdata)
          else:
              line, missing = do_replacement(regex, line, confdata)
              missing_variables.update(missing)
          result.append(line)
      dst_tmp = dst + '~'
      with open(dst_tmp, 'w', encoding='utf-8') as f:
          f.writelines(result)
      shutil.copymode(src, dst_tmp)
      replace_if_different(dst, dst_tmp)
      return missing_variables
  
  def dump_conf_header(ofilename, cdata):
      ofilename_tmp = ofilename + '~'
      with open(ofilename_tmp, 'w', encoding='utf-8') as ofile:
          ofile.write('''/*
   * Autogenerated by the Meson build system.
   * Do not edit, your changes will be lost.
   */
  
  #pragma once
  
  ''')
          for k in sorted(cdata.keys()):
              (v, desc) = cdata.get(k)
              if desc:
                  ofile.write('/* %s */\n' % desc)
              if isinstance(v, bool):
                  if v:
                      ofile.write('#define %s\n\n' % k)
                  else:
                      ofile.write('#undef %s\n\n' % k)
              elif isinstance(v, (int, str)):
                  ofile.write('#define %s %s\n\n' % (k, v))
              else:
                  raise MesonException('Unknown data type in configuration file entry: ' + k)
      replace_if_different(ofilename, ofilename_tmp)
  
  def replace_if_different(dst, dst_tmp):
      # If contents are identical, don't touch the file to prevent
      # unnecessary rebuilds.
      different = True
      try:
          with open(dst, 'rb') as f1, open(dst_tmp, 'rb') as f2:
              if f1.read() == f2.read():
                  different = False
      except FileNotFoundError:
          pass
      if different:
          os.replace(dst_tmp, dst)
      else:
          os.unlink(dst_tmp)
  
  def listify(item, flatten=True, unholder=False):
      '''
      Returns a list with all args embedded in a list if they are not a list.
      This function preserves order.
      @flatten: Convert lists of lists to a flat list
      @unholder: Replace each item with the object it holds, if required
  
      Note: unholding only works recursively when flattening
      '''
      if not isinstance(item, list):
          if unholder and hasattr(item, 'held_object'):
              item = item.held_object
          return [item]
      result = []
      for i in item:
          if unholder and hasattr(i, 'held_object'):
              i = i.held_object
          if flatten and isinstance(i, list):
              result += listify(i, flatten=True, unholder=unholder)
          else:
              result.append(i)
      return result
  
  
  def extract_as_list(dict_object, *keys, pop=False, **kwargs):
      '''
      Extracts all values from given dict_object and listifies them.
      '''
      result = []
      fetch = dict_object.get
      if pop:
          fetch = dict_object.pop
      # If there's only one key, we don't return a list with one element
      if len(keys) == 1:
          return listify(fetch(keys[0], []), **kwargs)
      # Return a list of values corresponding to *keys
      for key in keys:
          result.append(listify(fetch(key, []), **kwargs))
      return result
  
  
  def typeslistify(item, types):
      '''
      Ensure that type(@item) is one of @types or a
      list of items all of which are of type @types
      '''
      if isinstance(item, types):
          item = [item]
      if not isinstance(item, list):
          raise MesonException('Item must be a list or one of {!r}'.format(types))
      for i in item:
          if i is not None and not isinstance(i, types):
              raise MesonException('List item must be one of {!r}'.format(types))
      return item
  
  def stringlistify(item):
      return typeslistify(item, str)
  
  def expand_arguments(args):
      expended_args = []
      for arg in args:
          if not arg.startswith('@'):
              expended_args.append(arg)
              continue
  
          args_file = arg[1:]
          try:
              with open(args_file) as f:
                  extended_args = f.read().split()
              expended_args += extended_args
          except Exception as e:
              print('Error expanding command line arguments, %s not found' % args_file)
              print(e)
              return None
      return expended_args
  
  def Popen_safe(args, write=None, stderr=subprocess.PIPE, **kwargs):
      if sys.version_info < (3, 6) or not sys.stdout.encoding:
          return Popen_safe_legacy(args, write=write, stderr=stderr, **kwargs)
      p = subprocess.Popen(args, universal_newlines=True,
                           close_fds=False,
                           stdout=subprocess.PIPE,
                           stderr=stderr, **kwargs)
      o, e = p.communicate(write)
      return p, o, e
  
  def Popen_safe_legacy(args, write=None, stderr=subprocess.PIPE, **kwargs):
      p = subprocess.Popen(args, universal_newlines=False,
                           stdout=subprocess.PIPE,
                           stderr=stderr, **kwargs)
      if write is not None:
          write = write.encode('utf-8')
      o, e = p.communicate(write)
      if o is not None:
          if sys.stdout.encoding:
              o = o.decode(encoding=sys.stdout.encoding, errors='replace').replace('\r\n', '\n')
          else:
              o = o.decode(errors='replace').replace('\r\n', '\n')
      if e is not None:
          if sys.stderr.encoding:
              e = e.decode(encoding=sys.stderr.encoding, errors='replace').replace('\r\n', '\n')
          else:
              e = e.decode(errors='replace').replace('\r\n', '\n')
      return p, o, e
  
  def iter_regexin_iter(regexiter, initer):
      '''
      Takes each regular expression in @regexiter and tries to search for it in
      every item in @initer. If there is a match, returns that match.
      Else returns False.
      '''
      for regex in regexiter:
          for ii in initer:
              if not isinstance(ii, str):
                  continue
              match = re.search(regex, ii)
              if match:
                  return match.group()
      return False
  
  def _substitute_values_check_errors(command, values):
      # Error checking
      inregex = ('@INPUT([0-9]+)?@', '@PLAINNAME@', '@BASENAME@')
      outregex = ('@OUTPUT([0-9]+)?@', '@OUTDIR@')
      if '@INPUT@' not in values:
          # Error out if any input-derived templates are present in the command
          match = iter_regexin_iter(inregex, command)
          if match:
              m = 'Command cannot have {!r}, since no input files were specified'
              raise MesonException(m.format(match))
      else:
          if len(values['@INPUT@']) > 1:
              # Error out if @PLAINNAME@ or @BASENAME@ is present in the command
              match = iter_regexin_iter(inregex[1:], command)
              if match:
                  raise MesonException('Command cannot have {!r} when there is '
                                       'more than one input file'.format(match))
          # Error out if an invalid @INPUTnn@ template was specified
          for each in command:
              if not isinstance(each, str):
                  continue
              match = re.search(inregex[0], each)
              if match and match.group() not in values:
                  m = 'Command cannot have {!r} since there are only {!r} inputs'
                  raise MesonException(m.format(match.group(), len(values['@INPUT@'])))
      if '@OUTPUT@' not in values:
          # Error out if any output-derived templates are present in the command
          match = iter_regexin_iter(outregex, command)
          if match:
              m = 'Command cannot have {!r} since there are no outputs'
              raise MesonException(m.format(match))
      else:
          # Error out if an invalid @OUTPUTnn@ template was specified
          for each in command:
              if not isinstance(each, str):
                  continue
              match = re.search(outregex[0], each)
              if match and match.group() not in values:
                  m = 'Command cannot have {!r} since there are only {!r} outputs'
                  raise MesonException(m.format(match.group(), len(values['@OUTPUT@'])))
  
  def substitute_values(command, values):
      '''
      Substitute the template strings in the @values dict into the list of
      strings @command and return a new list. For a full list of the templates,
      see get_filenames_templates_dict()
  
      If multiple inputs/outputs are given in the @values dictionary, we
      substitute @INPUT@ and @OUTPUT@ only if they are the entire string, not
      just a part of it, and in that case we substitute *all* of them.
      '''
      # Error checking
      _substitute_values_check_errors(command, values)
      # Substitution
      outcmd = []
      rx_keys = [re.escape(key) for key in values if key not in ('@INPUT@', '@OUTPUT@')]
      value_rx = re.compile('|'.join(rx_keys)) if rx_keys else None
      for vv in command:
          if not isinstance(vv, str):
              outcmd.append(vv)
          elif '@INPUT@' in vv:
              inputs = values['@INPUT@']
              if vv == '@INPUT@':
                  outcmd += inputs
              elif len(inputs) == 1:
                  outcmd.append(vv.replace('@INPUT@', inputs[0]))
              else:
                  raise MesonException("Command has '@INPUT@' as part of a "
                                       "string and more than one input file")
          elif '@OUTPUT@' in vv:
              outputs = values['@OUTPUT@']
              if vv == '@OUTPUT@':
                  outcmd += outputs
              elif len(outputs) == 1:
                  outcmd.append(vv.replace('@OUTPUT@', outputs[0]))
              else:
                  raise MesonException("Command has '@OUTPUT@' as part of a "
                                       "string and more than one output file")
          # Append values that are exactly a template string.
          # This is faster than a string replace.
          elif vv in values:
              outcmd.append(values[vv])
          # Substitute everything else with replacement
          elif value_rx:
              outcmd.append(value_rx.sub(lambda m: values[m.group(0)], vv))
          else:
              outcmd.append(vv)
      return outcmd
  
  def get_filenames_templates_dict(inputs, outputs):
      '''
      Create a dictionary with template strings as keys and values as values for
      the following templates:
  
      @INPUT@  - the full path to one or more input files, from @inputs
      @OUTPUT@ - the full path to one or more output files, from @outputs
      @OUTDIR@ - the full path to the directory containing the output files
  
      If there is only one input file, the following keys are also created:
  
      @PLAINNAME@ - the filename of the input file
      @BASENAME@ - the filename of the input file with the extension removed
  
      If there is more than one input file, the following keys are also created:
  
      @INPUT0@, @INPUT1@, ... one for each input file
  
      If there is more than one output file, the following keys are also created:
  
      @OUTPUT0@, @OUTPUT1@, ... one for each output file
      '''
      values = {}
      # Gather values derived from the input
      if inputs:
          # We want to substitute all the inputs.
          values['@INPUT@'] = inputs
          for (ii, vv) in enumerate(inputs):
              # Write out @INPUT0@, @INPUT1@, ...
              values['@INPUT{}@'.format(ii)] = vv
          if len(inputs) == 1:
              # Just one value, substitute @PLAINNAME@ and @BASENAME@
              values['@PLAINNAME@'] = plain = os.path.basename(inputs[0])
              values['@BASENAME@'] = os.path.splitext(plain)[0]
      if outputs:
          # Gather values derived from the outputs, similar to above.
          values['@OUTPUT@'] = outputs
          for (ii, vv) in enumerate(outputs):
              values['@OUTPUT{}@'.format(ii)] = vv
          # Outdir should be the same for all outputs
          values['@OUTDIR@'] = os.path.dirname(outputs[0])
          # Many external programs fail on empty arguments.
          if values['@OUTDIR@'] == '':
              values['@OUTDIR@'] = '.'
      return values
  
  
  def windows_proof_rmtree(f):
      # On Windows if anyone is holding a file open you can't
      # delete it. As an example an anti virus scanner might
      # be scanning files you are trying to delete. The only
      # way to fix this is to try again and again.
      delays = [0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2]
      for d in delays:
          try:
              shutil.rmtree(f)
              return
          except FileNotFoundError:
              return
          except (OSError, PermissionError):
              time.sleep(d)
      # Try one last time and throw if it fails.
      shutil.rmtree(f)
  
  
  def detect_subprojects(spdir_name, current_dir='', result=None):
      if result is None:
          result = {}
      spdir = os.path.join(current_dir, spdir_name)
      if not os.path.exists(spdir):
          return result
      for trial in glob(os.path.join(spdir, '*')):
          basename = os.path.basename(trial)
          if trial == 'packagecache':
              continue
          append_this = True
          if os.path.isdir(trial):
              detect_subprojects(spdir_name, trial, result)
          elif trial.endswith('.wrap') and os.path.isfile(trial):
              basename = os.path.splitext(basename)[0]
          else:
              append_this = False
          if append_this:
              if basename in result:
                  result[basename].append(trial)
              else:
                  result[basename] = [trial]
      return result
  
  class OrderedSet(collections.MutableSet):
      """A set that preserves the order in which items are added, by first
      insertion.
      """
      def __init__(self, iterable=None):
          self.__container = collections.OrderedDict()
          if iterable:
              self.update(iterable)
  
      def __contains__(self, value):
          return value in self.__container
  
      def __iter__(self):
          return iter(self.__container.keys())
  
      def __len__(self):
          return len(self.__container)
  
      def __repr__(self):
          # Don't print 'OrderedSet("")' for an empty set.
          if self.__container:
              return 'OrderedSet("{}")'.format(
                  '", "'.join(repr(e) for e in self.__container.keys()))
          return 'OrderedSet()'
  
      def add(self, value):
          self.__container[value] = None
  
      def discard(self, value):
          if value in self.__container:
              del self.__container[value]
  
      def update(self, iterable):
          for item in iterable:
              self.__container[item] = None
  
      def difference(self, set_):
          return type(self)(e for e in self if e not in set_)
  
files: mesonbuild/mesonlib.py
files: # Copyright 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
  import subprocess
  import shutil
  import argparse
  from .. import mlog
  from ..mesonlib import has_path_sep
  from . import destdir_join
  from .gettext import read_linguas
  
  parser = argparse.ArgumentParser()
  parser.add_argument('command')
  parser.add_argument('--id', dest='project_id')
  parser.add_argument('--subdir', dest='subdir')
  parser.add_argument('--installdir', dest='install_dir')
  parser.add_argument('--sources', dest='sources')
  parser.add_argument('--media', dest='media', default='')
  parser.add_argument('--langs', dest='langs', default='')
  parser.add_argument('--symlinks', type=bool, dest='symlinks', default=False)
  
  def build_pot(srcdir, project_id, sources):
      # Must be relative paths
      sources = [os.path.join('C', source) for source in sources]
      outfile = os.path.join(srcdir, project_id + '.pot')
      subprocess.call(['itstool', '-o', outfile] + sources)
  
  def update_po(srcdir, project_id, langs):
      potfile = os.path.join(srcdir, project_id + '.pot')
      for lang in langs:
          pofile = os.path.join(srcdir, lang, lang + '.po')
          subprocess.call(['msgmerge', '-q', '-o', pofile, pofile, potfile])
  
  def build_translations(srcdir, blddir, langs):
      for lang in langs:
          outdir = os.path.join(blddir, lang)
          os.makedirs(outdir, exist_ok=True)
          subprocess.call([
              'msgfmt', os.path.join(srcdir, lang, lang + '.po'),
              '-o', os.path.join(outdir, lang + '.gmo')
          ])
  
  def merge_translations(blddir, sources, langs):
      for lang in langs:
          subprocess.call([
              'itstool', '-m', os.path.join(blddir, lang, lang + '.gmo'),
              '-o', os.path.join(blddir, lang)
          ] + sources)
  
  def install_help(srcdir, blddir, sources, media, langs, install_dir, destdir, project_id, symlinks):
      c_install_dir = os.path.join(install_dir, 'C', project_id)
      for lang in langs + ['C']:
          indir = destdir_join(destdir, os.path.join(install_dir, lang, project_id))
          os.makedirs(indir, exist_ok=True)
          for source in sources:
              infile = os.path.join(srcdir if lang == 'C' else blddir, lang, source)
              outfile = os.path.join(indir, source)
              mlog.log('Installing %s to %s' % (infile, outfile))
              shutil.copyfile(infile, outfile)
              shutil.copystat(infile, outfile)
          for m in media:
              infile = os.path.join(srcdir, lang, m)
              outfile = os.path.join(indir, m)
              if not os.path.exists(infile):
                  if lang == 'C':
                      mlog.warning('Media file "%s" did not exist in C directory' % m)
                      continue
                  elif symlinks:
                      srcfile = os.path.join(c_install_dir, m)
                      mlog.log('Symlinking %s to %s.' % (outfile, srcfile))
                      if has_path_sep(m):
                          os.makedirs(os.path.dirname(outfile), exist_ok=True)
                      try:
                          try:
                              os.symlink(srcfile, outfile)
                          except FileExistsError:
                              os.remove(outfile)
                              os.symlink(srcfile, outfile)
                          continue
                      except (NotImplementedError, OSError):
                          mlog.warning('Symlinking not supported, falling back to copying')
                  else:
                      # Lang doesn't have media file so copy it over 'C' one
                      infile = os.path.join(srcdir, 'C', m)
              mlog.log('Installing %s to %s' % (infile, outfile))
              if has_path_sep(m):
                  os.makedirs(os.path.dirname(outfile), exist_ok=True)
              shutil.copyfile(infile, outfile)
              shutil.copystat(infile, outfile)
  
  def run(args):
      options = parser.parse_args(args)
      langs = options.langs.split('@@') if options.langs else []
      media = options.media.split('@@') if options.media else []
      sources = options.sources.split('@@')
      destdir = os.environ.get('DESTDIR', '')
      src_subdir = os.path.join(os.environ['MESON_SOURCE_ROOT'], options.subdir)
      build_subdir = os.path.join(os.environ['MESON_BUILD_ROOT'], options.subdir)
      abs_sources = [os.path.join(src_subdir, 'C', source) for source in sources]
  
      if not langs:
          langs = read_linguas(src_subdir)
  
      if options.command == 'pot':
          build_pot(src_subdir, options.project_id, sources)
      elif options.command == 'update-po':
          build_pot(src_subdir, options.project_id, sources)
          update_po(src_subdir, options.project_id, langs)
      elif options.command == 'build':
          if langs:
              build_translations(src_subdir, build_subdir, langs)
      elif options.command == 'install':
          install_dir = os.path.join(os.environ['MESON_INSTALL_PREFIX'], options.install_dir)
          if langs:
              build_translations(src_subdir, build_subdir, langs)
              merge_translations(build_subdir, abs_sources, langs)
          install_help(src_subdir, build_subdir, sources, media, langs, install_dir,
                       destdir, options.project_id, options.symlinks)
  
files: mesonbuild/scripts/yelphelper.py
files: # Copyright 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
  import subprocess
  import shutil
  import argparse
  from .. import mlog
  from . import destdir_join
  from .gettext import read_linguas
  
  parser = argparse.ArgumentParser()
  parser.add_argument('command')
  parser.add_argument('--id', dest='project_id')
  parser.add_argument('--subdir', dest='subdir')
  parser.add_argument('--installdir', dest='install_dir')
  parser.add_argument('--sources', dest='sources')
  parser.add_argument('--media', dest='media', default='')
  parser.add_argument('--langs', dest='langs', default='')
  parser.add_argument('--symlinks', type=bool, dest='symlinks', default=False)
  
  def build_pot(srcdir, project_id, sources):
      # Must be relative paths
      sources = [os.path.join('C', source) for source in sources]
      outfile = os.path.join(srcdir, project_id + '.pot')
      subprocess.call(['itstool', '-o', outfile] + sources)
  
  def update_po(srcdir, project_id, langs):
      potfile = os.path.join(srcdir, project_id + '.pot')
      for lang in langs:
          pofile = os.path.join(srcdir, lang, lang + '.po')
          subprocess.call(['msgmerge', '-q', '-o', pofile, pofile, potfile])
  
  def build_translations(srcdir, blddir, langs):
      for lang in langs:
          outdir = os.path.join(blddir, lang)
          os.makedirs(outdir, exist_ok=True)
          subprocess.call([
              'msgfmt', os.path.join(srcdir, lang, lang + '.po'),
              '-o', os.path.join(outdir, lang + '.gmo')
          ])
  
  def merge_translations(blddir, sources, langs):
      for lang in langs:
          subprocess.call([
              'itstool', '-m', os.path.join(blddir, lang, lang + '.gmo'),
              '-o', os.path.join(blddir, lang)
          ] + sources)
  
  def install_help(srcdir, blddir, sources, media, langs, install_dir, destdir, project_id, symlinks):
      c_install_dir = os.path.join(install_dir, 'C', project_id)
      for lang in langs + ['C']:
          indir = destdir_join(destdir, os.path.join(install_dir, lang, project_id))
          os.makedirs(indir, exist_ok=True)
          for source in sources:
              infile = os.path.join(srcdir if lang == 'C' else blddir, lang, source)
              outfile = os.path.join(indir, source)
              mlog.log('Installing %s to %s' % (infile, outfile))
              shutil.copyfile(infile, outfile)
              shutil.copystat(infile, outfile)
          for m in media:
              infile = os.path.join(srcdir, lang, m)
              outfile = os.path.join(indir, m)
              if not os.path.exists(infile):
                  if lang == 'C':
                      mlog.warning('Media file "%s" did not exist in C directory' % m)
                      continue
                  elif symlinks:
                      srcfile = os.path.join(c_install_dir, m)
                      mlog.log('Symlinking %s to %s.' % (outfile, srcfile))
                      if '/' in m or '\\' in m:
                          os.makedirs(os.path.dirname(outfile), exist_ok=True)
                      try:
                          try:
                              os.symlink(srcfile, outfile)
                          except FileExistsError:
                              os.remove(outfile)
                              os.symlink(srcfile, outfile)
                          continue
                      except (NotImplementedError, OSError):
                          mlog.warning('Symlinking not supported, falling back to copying')
                  else:
                      # Lang doesn't have media file so copy it over 'C' one
                      infile = os.path.join(srcdir, 'C', m)
              mlog.log('Installing %s to %s' % (infile, outfile))
              if '/' in m or '\\' in m:
                  os.makedirs(os.path.dirname(outfile), exist_ok=True)
              shutil.copyfile(infile, outfile)
              shutil.copystat(infile, outfile)
  
  def run(args):
      options = parser.parse_args(args)
      langs = options.langs.split('@@') if options.langs else []
      media = options.media.split('@@') if options.media else []
      sources = options.sources.split('@@')
      destdir = os.environ.get('DESTDIR', '')
      src_subdir = os.path.join(os.environ['MESON_SOURCE_ROOT'], options.subdir)
      build_subdir = os.path.join(os.environ['MESON_BUILD_ROOT'], options.subdir)
      abs_sources = [os.path.join(src_subdir, 'C', source) for source in sources]
  
      if not langs:
          langs = read_linguas(src_subdir)
  
      if options.command == 'pot':
          build_pot(src_subdir, options.project_id, sources)
      elif options.command == 'update-po':
          build_pot(src_subdir, options.project_id, sources)
          update_po(src_subdir, options.project_id, langs)
      elif options.command == 'build':
          if langs:
              build_translations(src_subdir, build_subdir, langs)
      elif options.command == 'install':
          install_dir = os.path.join(os.environ['MESON_INSTALL_PREFIX'], options.install_dir)
          if langs:
              build_translations(src_subdir, build_subdir, langs)
              merge_translations(build_subdir, abs_sources, langs)
          install_help(src_subdir, build_subdir, sources, media, langs, install_dir,
                       destdir, options.project_id, options.symlinks)
  
files: mesonbuild/scripts/yelphelper.py