#!/usr/bin/env python

"""Ninja toolchain abstraction for Clang compiler suite"""

import os
import subprocess

import toolchain

class ClangToolchain(toolchain.Toolchain):

  def initialize(self, project, archs, configs, includepaths, dependlibs, libpaths, variables, subninja):
    #Local variable defaults
    self.toolchain = ''
    self.sdkpath = ''
    self.includepaths = []
    self.libpaths = libpaths
    self.ccompiler = os.environ.get('CC') or 'clang'
    self.cxxcompiler = os.environ.get('CXX') or 'clang++'
    if self.target.is_windows():
      self.archiver = os.environ.get('AR') or 'llvm-ar'
      self.linker = os.environ.get('CC') or 'lld-link'
      self.cxxlinker = os.environ.get('CXX') or 'lld-link'
    else:
      self.archiver = os.environ.get('AR') or 'ar'
      self.linker = os.environ.get('CC') or 'clang'
      self.cxxlinker = os.environ.get('CXX') or 'clang++'

    #Default variables
    self.sysroot = ''
    if self.target.is_ios():
      self.deploymenttarget = '9.0'
    if self.target.is_macos():
      self.deploymenttarget = '10.7'

    #Command definitions
    self.cccmd = '$toolchain$cc -MMD -MT $out -MF $out.d $includepaths $moreincludepaths $cflags $carchflags $cconfigflags $cmoreflags $cenvflags -c $in -o $out'
    self.cxxcmd = '$toolchain$cxx -MMD -MT $out -MF $out.d $includepaths $moreincludepaths $cxxflags $carchflags $cconfigflags $cmoreflags $cxxenvflags -c $in -o $out'
    self.ccdeps = 'gcc'
    self.ccdepfile = '$out.d'
    self.arcmd = self.rmcmd('$out') + ' && $toolchain$ar crs $ararchflags $arflags $arenvflags $out $in'
    if self.target.is_windows():
      self.linkcmd = '$toolchain$link $libpaths $configlibpaths $linkflags $linkarchflags $linkconfigflags $linkenvflags /debug /nologo /subsystem:console /dynamicbase /nxcompat /manifest /manifestuac:\"level=\'asInvoker\' uiAccess=\'false\'\" /tlbid:1 /pdb:$pdbpath /out:$out $in $libs $archlibs $oslibs $frameworks'
      self.dllcmd = self.linkcmd + ' /dll'
    else:
      self.linkcmd = '$toolchain$link $libpaths $configlibpaths $linkflags $linkarchflags $linkconfigflags $linkenvflags -o $out $in $libs $archlibs $oslibs $frameworks'

    #Base flags
    self.cflags = ['-D' + project.upper() + '_COMPILE=1',
                   '-funit-at-a-time', '-fstrict-aliasing', '-fvisibility=hidden', '-fno-stack-protector',
                   '-fomit-frame-pointer', '-fno-math-errno','-ffinite-math-only', '-funsafe-math-optimizations',
                   '-fno-trapping-math', '-ffast-math']
    self.cwarnflags = ['-W', '-Werror', '-pedantic', '-Wall', '-Weverything',
                       '-Wno-c++98-compat', '-Wno-padded', '-Wno-documentation-unknown-command',
                       '-Wno-implicit-fallthrough', '-Wno-static-in-inline', '-Wno-reserved-id-macro', '-Wno-disabled-macro-expansion']
    self.cmoreflags = []
    self.mflags = []
    self.arflags = []
    self.linkflags = []
    self.oslibs = []
    self.frameworks = []

    self.initialize_subninja(subninja)
    self.initialize_archs(archs)
    self.initialize_configs(configs)
    self.initialize_project(project)
    self.initialize_toolchain()
    self.initialize_depends(dependlibs)

    self.parse_default_variables(variables)
    self.read_build_prefs()

    if self.target.is_linux() or self.target.is_bsd() or self.target.is_raspberrypi() or self.target.is_sunos():
      self.cflags += ['-D_GNU_SOURCE=1']
      self.linkflags += ['-pthread']
      self.oslibs += ['m']
    if self.target.is_linux() or self.target.is_raspberrypi():
      self.oslibs += ['dl']
    if self.target.is_raspberrypi():
      self.linkflags += ['-latomic']
    if self.target.is_bsd():
      self.oslibs += ['execinfo']
    if self.target.is_haiku():
      self.cflags += ['-D_GNU_SOURCE=1']
      self.linkflags += ['-lpthread']
      self.oslibs += ['m']
    if not self.target.is_windows():
      self.linkflags += ['-fomit-frame-pointer']

    self.includepaths = self.prefix_includepaths((includepaths or []) + ['.'])

    if self.is_monolithic():
      self.cflags += ['-DBUILD_MONOLITHIC=1']
    if self.use_coverage():
      self.cflags += ['--coverage']
      self.linkflags += ['--coverage']

    if not 'nowarning' in variables or not variables['nowarning']:
      self.cflags += self.cwarnflags
    else:
      self.cflags += ['-w']
    self.cxxflags = list(self.cflags)

    self.cflags += ['-std=c11']
    if self.target.is_macos() or self.target.is_ios():
      self.cxxflags += ['-std=c++14', '-stdlib=libc++']
    else:
      self.cxxflags += ['-std=c++14']

    #Overrides
    self.objext = '.o'

    #Builders
    self.builders['c'] = self.builder_cc
    self.builders['cc'] = self.builder_cxx
    self.builders['cpp'] = self.builder_cxx
    self.builders['lib'] = self.builder_lib
    self.builders['sharedlib'] = self.builder_sharedlib
    self.builders['bin'] = self.builder_bin
    if self.target.is_macos() or self.target.is_ios():
      self.builders['m'] = self.builder_cm
      self.builders['multilib'] = self.builder_apple_multilib
      self.builders['multisharedlib'] = self.builder_apple_multisharedlib
      self.builders['multibin'] = self.builder_apple_multibin
    else:
      self.builders['multilib'] = self.builder_multicopy
      self.builders['multisharedlib'] = self.builder_multicopy
      self.builders['multibin'] = self.builder_multicopy

    #Setup target platform
    self.build_toolchain()

  def name(self):
    return 'clang'

  def parse_prefs(self, prefs):
    super(ClangToolchain, self).parse_prefs(prefs)
    if 'clang' in prefs:
      clangprefs = prefs['clang']
      if 'toolchain' in clangprefs:
        self.toolchain = clangprefs['toolchain']
        if os.path.split(self.toolchain)[1] != 'bin':
          self.toolchain = os.path.join(self.toolchain, 'bin')
      if 'archiver' in clangprefs:
        self.archiver = clangprefs['archiver']
    if self.target.is_ios() and 'ios' in prefs:
      iosprefs = prefs['ios']
      if 'deploymenttarget' in iosprefs:
        self.deploymenttarget = iosprefs['deploymenttarget']
    if self.target.is_macos() and 'macos' in prefs:
      macosprefs = prefs['macos']
      if 'deploymenttarget' in macosprefs:
        self.deploymenttarget = macosprefs['deploymenttarget']

  def write_variables(self, writer):
    super(ClangToolchain, self).write_variables(writer)
    writer.variable('toolchain', self.toolchain)
    writer.variable('sdkpath', self.sdkpath)
    writer.variable('sysroot', self.sysroot)
    writer.variable('cc', self.ccompiler)
    writer.variable('cxx', self.cxxcompiler)
    writer.variable('ar', self.archiver)
    writer.variable('link', self.linker)
    if self.target.is_macos() or self.target.is_ios():
      writer.variable('lipo', self.lipo)
    writer.variable('includepaths', self.make_includepaths(self.includepaths))
    writer.variable('moreincludepaths', '')
    writer.variable('cflags', self.cflags)
    writer.variable('cxxflags', self.cxxflags)
    if self.target.is_macos() or self.target.is_ios():
      writer.variable('mflags', self.mflags)
    writer.variable('carchflags', '')
    writer.variable('cconfigflags', '')
    writer.variable('cmoreflags', self.cmoreflags)
    writer.variable('cenvflags', (os.environ.get('CFLAGS') or '').split())
    writer.variable('cxxenvflags', (os.environ.get('CXXFLAGS') or '').split())
    writer.variable('arflags', self.arflags)
    writer.variable('ararchflags', '')
    writer.variable('arconfigflags', '')
    writer.variable('arenvflags', (os.environ.get('ARFLAGS') or '').split())
    writer.variable('linkflags', self.linkflags)
    writer.variable('linkarchflags', '')
    writer.variable('linkconfigflags', '')
    writer.variable('linkenvflags', (os.environ.get('LDFLAGS') or '').split())
    writer.variable('libs', '')
    writer.variable('libpaths', self.make_libpaths(self.libpaths))
    writer.variable('configlibpaths', '')
    writer.variable('archlibs', '')
    writer.variable('oslibs', self.make_libs(self.oslibs))
    writer.variable('frameworks', '')
    if self.target.is_windows():
      writer.variable('pdbpath', 'ninja.pdb')
    writer.newline()

  def write_rules(self, writer):
    super(ClangToolchain, self).write_rules(writer)
    writer.rule('cc', command = self.cccmd, depfile = self.ccdepfile, deps = self.ccdeps, description = 'CC $in')
    writer.rule('cxx', command = self.cxxcmd, depfile = self.ccdepfile, deps = self.ccdeps, description = 'CXX $in')
    if self.target.is_macos() or self.target.is_ios():
      writer.rule('cm', command = self.cmcmd, depfile = self.ccdepfile, deps = self.ccdeps, description = 'CM $in')
      writer.rule( 'lipo', command = self.lipocmd, description = 'LIPO $out' )
    writer.rule('ar', command = self.arcmd, description = 'LIB $out')
    writer.rule('link', command = self.linkcmd, description = 'LINK $out')
    if self.target.is_windows():
      writer.rule('dll', command = self.dllcmd, description = 'DLL $out')
    else:
      writer.rule('so', command = self.linkcmd, description = 'SO $out')
    writer.newline()

  def build_toolchain(self):
    super(ClangToolchain, self).build_toolchain()
    if self.target.is_windows():
      self.build_windows_toolchain()
    elif self.target.is_android():
      self.build_android_toolchain()
    elif self.target.is_macos() or self.target.is_ios():
      self.build_xcode_toolchain()
    if self.toolchain != '' and not self.toolchain.endswith('/') and not self.toolchain.endswith('\\'):
      self.toolchain += os.sep

  def build_windows_toolchain(self):
    self.cflags += ['-U__STRICT_ANSI__', '-Wno-reserved-id-macro']
    self.oslibs = ['kernel32', 'user32', 'shell32', 'advapi32']

  def build_android_toolchain(self):
    self.archiver = 'ar'

    self.cccmd += ' --sysroot=$sysroot'
    self.linkcmd += ' -shared -Wl,-soname,$liblinkname --sysroot=$sysroot'
    self.cflags += ['-fpic', '-ffunction-sections', '-funwind-tables', '-fstack-protector', '-fomit-frame-pointer',
                    '-no-canonical-prefixes', '-Wa,--noexecstack']

    self.linkflags += ['-no-canonical-prefixes', '-Wl,--no-undefined', '-Wl,-z,noexecstack', '-Wl,-z,relro', '-Wl,-z,now']

    self.includepaths += [os.path.join('$ndk', 'sources', 'android', 'native_app_glue'),
                          os.path.join('$ndk', 'sources', 'android', 'cpufeatures')]

    self.oslibs += ['log']

    self.toolchain = os.path.join('$ndk', 'toolchains', 'llvm', 'prebuilt', self.android.hostarchname, 'bin', '')

  def build_xcode_toolchain(self):
    if self.target.is_macos():
      sdk = 'macosx'
      deploytarget = 'MACOSX_DEPLOYMENT_TARGET=' + self.deploymenttarget
      self.cflags += ['-fasm-blocks', '-mmacosx-version-min=' + self.deploymenttarget, '-isysroot', '$sysroot']
      self.cxxflags += ['-fasm-blocks', '-mmacosx-version-min=' + self.deploymenttarget, '-isysroot', '$sysroot']
      self.arflags += ['-static', '-no_warning_for_no_symbols']
      self.linkflags += ['-isysroot', '$sysroot']
    elif self.target.is_ios():
      sdk = 'iphoneos'
      deploytarget = 'IPHONEOS_DEPLOYMENT_TARGET=' + self.deploymenttarget
      self.cflags += ['-fasm-blocks', '-miphoneos-version-min=' + self.deploymenttarget, '-isysroot', '$sysroot']
      self.cxxflags += ['-fasm-blocks', '-miphoneos-version-min=' + self.deploymenttarget, '-isysroot', '$sysroot']
      self.arflags += ['-static', '-no_warning_for_no_symbols']
      self.linkflags += ['-isysroot', '$sysroot']
    self.cflags += ['-fembed-bitcode-marker']

    platformpath = toolchain.check_output(['xcrun', '--sdk', sdk, '--show-sdk-platform-path'])
    localpath = platformpath + "/Developer/usr/bin:/Applications/Xcode.app/Contents/Developer/usr/bin:/usr/bin:/bin:/usr/sbin:/sbin"

    self.sysroot = toolchain.check_output(['xcrun', '--sdk', sdk, '--show-sdk-path'])

    self.ccompiler = "PATH=" + localpath + " " + toolchain.check_output(['xcrun', '--sdk', sdk, '-f', 'clang'])
    self.archiver = "PATH=" + localpath + " " + toolchain.check_output(['xcrun', '--sdk', sdk, '-f', 'libtool'])
    self.linker = deploytarget + " " + self.ccompiler
    self.lipo = "PATH=" + localpath + " " + toolchain.check_output(['xcrun', '--sdk', sdk, '-f', 'lipo'])

    self.mflags += list(self.cflags) + ['-fobjc-arc', '-fno-objc-exceptions', '-x', 'objective-c']
    self.cflags += ['-x', 'c']
    self.cxxflags += ['-x', 'c++']

    self.cmcmd = self.cccmd.replace('$cflags', '$mflags')
    self.arcmd = self.rmcmd('$out') + ' && $ar $ararchflags $arflags $in -o $out'
    self.lipocmd = '$lipo $in -create -output $out'

    if self.target.is_macos():
      self.frameworks = ['Cocoa', 'CoreFoundation']
    if self.target.is_ios():
      self.frameworks = ['CoreGraphics', 'UIKit', 'Foundation']

  def make_includepaths(self, includepaths):
    if not includepaths is None:
      return ['-I' + path for path in list(includepaths)]
    return []

  def make_libpath(self, path):
    return self.path_escape(path)

  def make_libpaths(self, libpaths):
    if not libpaths is None:
      if self.target.is_windows():
        return ['/libpath:' + self.path_escape(path) for path in libpaths]
      return ['-L' + self.make_libpath(path) for path in libpaths]
    return []

  def make_targetarchflags(self, arch, targettype):
    flags = []
    if self.target.is_android():
      if arch == 'x86':
        flags += ['-target', 'i686-none-linux-android']
        flags += ['-march=i686', '-mtune=intel', '-mssse3', '-mfpmath=sse', '-m32']
      elif arch == 'x86-64':
        flags += ['-target', 'x86_64-none-linux-android']
        flags += ['-march=x86-64', '-msse4.2', '-mpopcnt', '-m64', '-mtune=intel']
      elif arch == 'arm6':
        flags += ['-target', 'armv5te-none-linux-androideabi']
        flags += ['-march=armv5te', '-mtune=xscale', '-msoft-float', '-marm']
      elif arch == 'arm7':
        flags += ['-target', 'armv7-none-linux-androideabi']
        flags += ['-march=armv7-a', '-mhard-float', '-mfpu=vfpv3-d16', '-mfpu=neon', '-D_NDK_MATH_NO_SOFTFP=1', '-marm']
      elif arch == 'arm64':
        flags += ['-target', 'aarch64-none-linux-android']
      elif arch == 'mips':
        flags += ['-target', 'mipsel-none-linux-android']
      elif arch == 'mips64':
        flags += ['-target', 'mips64el-none-linux-android']
      flags += ['-gcc-toolchain', self.android.make_gcc_toolchain_path(arch)]
    elif self.target.is_macos() or self.target.is_ios():
      if arch == 'x86':
        flags += ['-arch', 'x86']
      elif arch == 'x86-64':
        flags += ['-arch', 'x86_64']
      elif arch == 'arm7':
        flags += ['-arch', 'armv7']
      elif arch == 'arm64':
        flags += ['-arch', 'arm64']
    elif self.target.is_windows():
      if arch == 'x86':
        flags += ['-target', 'x86-pc-windows-msvc']
      elif arch == 'x64':
        flags += ['-target', 'x86_64-pc-windows-msvc']
    else:
      if arch == 'x86':
        flags += ['-m32']
      elif arch == 'x86-64':
        flags += ['-m64']
    return flags

  def make_carchflags(self, arch, targettype):
    flags = []
    if targettype == 'sharedlib':
      flags += ['-DBUILD_DYNAMIC_LINK=1']
      if self.target.is_linux() or self.target.is_bsd() or self.target.is_sunos():
       flags += ['-fPIC']
    flags += self.make_targetarchflags(arch, targettype)
    return flags

  def make_cconfigflags(self, config, targettype):
    flags = ['-g']
    if config == 'debug':
      flags += ['-DBUILD_DEBUG=1']
    elif config == 'release':
      flags += ['-DBUILD_RELEASE=1', '-O3', '-funroll-loops']
    elif config == 'profile':
      flags += ['-DBUILD_PROFILE=1', '-O3', '-funroll-loops']
    elif config == 'deploy':
      flags += ['-DBUILD_DEPLOY=1', '-O3', '-funroll-loops']
    return flags

  def make_ararchflags(self, arch, targettype):
    flags = []
    return flags

  def make_arconfigflags(self, config, targettype):
    flags = []
    return flags

  def make_linkarchflags(self, arch, targettype, variables):
    flags = []
    flags += self.make_targetarchflags(arch, targettype)
    if self.target.is_android():
      if arch == 'arm7':
        flags += ['-Wl,--no-warn-mismatch', '-Wl,--fix-cortex-a8']
    if self.target.is_windows():
      # Ignore target arch flags from above, add link style arch instead
      flags = []
      if arch == 'x86':
        flags += ['/machine:x86']
      elif arch == 'x86-64':
        flags += ['/machine:x64']
    if self.target.is_macos() and variables != None and 'support_lua' in variables and variables['support_lua']:
      flags += ['-pagezero_size', '10000', '-image_base', '100000000']
    return flags

  def make_linkconfigflags(self, config, targettype, variables):
    flags = []
    if self.target.is_windows():
      if config == 'debug':
        flags += ['/incremental', '/defaultlib:libcmtd']
      else:
        flags += ['/incremental:no', '/opt:ref', '/opt:icf', '/defaultlib:libcmt']
    elif self.target.is_macos() or self.target.is_ios():
      if targettype == 'sharedlib' or targettype == 'multisharedlib':
        flags += ['-dynamiclib']
    else:
      if targettype == 'sharedlib':
        flags += ['-shared', '-fPIC']
    if config != 'debug':
      if (targettype == 'bin' or targettype == 'sharedlib') and self.use_lto():
        flags += ['-flto']
    return flags

  def make_linkarchlibs(self, arch, targettype):
    archlibs = []
    if self.target.is_android():
      if arch == 'arm7':
        archlibs += ['m_hard']
      else:
        archlibs += ['m']
      archlibs += ['gcc', 'android']
    return archlibs

  def make_libs(self, libs):
    if libs != None:
      if self.target.is_windows():
        return [lib + ".lib" for lib in libs]
      return ['-l' + lib for lib in libs]
    return []

  def make_frameworks(self, frameworks):
    if frameworks != None:
      return ['-framework ' + framework for framework in frameworks]
    return []

  def make_configlibpaths(self, config, arch, extralibpaths):
    libpaths = [self.libpath, os.path.join(self.libpath, config)]
    if not self.target.is_macos() and not self.target.is_ios():
      libpaths += [os.path.join(self.libpath, arch)]
      libpaths += [os.path.join(self.libpath, config, arch)]
    if extralibpaths != None:
      libpaths += [os.path.join(libpath, self.libpath) for libpath in extralibpaths]
      libpaths += [os.path.join(libpath, self.libpath, config) for libpath in extralibpaths]
      if not self.target.is_macos() and not self.target.is_ios():
        libpaths += [os.path.join(libpath, self.libpath, arch) for libpath in extralibpaths]
        libpaths += [os.path.join(libpath, self.libpath, config, arch) for libpath in extralibpaths]
    return self.make_libpaths(libpaths)

  def cc_variables(self, config, arch, targettype, variables):
    localvariables = []
    if 'includepaths' in variables:
      moreincludepaths = self.make_includepaths(variables['includepaths'])
      if not moreincludepaths == []:
        localvariables += [('moreincludepaths', moreincludepaths)]
    carchflags = self.make_carchflags(arch, targettype)
    if carchflags != []:
      localvariables += [('carchflags', carchflags)]
    cconfigflags = self.make_cconfigflags(config, targettype)
    if cconfigflags != []:
      localvariables += [('cconfigflags', cconfigflags)]
    if self.target.is_android():
      localvariables += [('sysroot', self.android.make_sysroot_path(arch))]
    if 'defines' in variables:
      localvariables += [('cmoreflags', ['-D' + define for define in variables['defines']])]
    return localvariables

  def ar_variables(self, config, arch, targettype, variables):
    localvariables = []
    ararchflags = self.make_ararchflags(arch, targettype)
    if ararchflags != []:
      localvariables += [('ararchflags', ararchflags)]
    arconfigflags = self.make_arconfigflags(config, targettype)
    if arconfigflags != []:
      localvariables += [('arconfigflags', arconfigflags)]
    if self.target.is_android():
      localvariables += [('toolchain', self.android.make_gcc_bin_path(arch))]
    return localvariables

  def link_variables(self, config, arch, targettype, variables):
    if variables == None:
        variables = {}
    localvariables = []
    linkarchflags = self.make_linkarchflags(arch, targettype, variables)
    if linkarchflags != []:
      localvariables += [('linkarchflags', linkarchflags)]
    linkconfigflags = self.make_linkconfigflags(config, targettype, variables)
    if linkconfigflags != []:
      localvariables += [('linkconfigflags', linkconfigflags)]
    if 'libs' in variables:
      libvar = self.make_libs(variables['libs'])
      if libvar != []:
        localvariables += [('libs', libvar)]

    localframeworks = self.frameworks or []
    if 'frameworks' in variables and variables['frameworks'] != None:
      localframeworks += list(variables['frameworks'])
    if len(localframeworks) > 0:
      localvariables += [('frameworks', self.make_frameworks(list(localframeworks)))]

    libpaths = []
    if 'libpaths' in variables:
      libpaths = variables['libpaths']
    localvariables += [('configlibpaths', self.make_configlibpaths(config, arch, libpaths))]
    if self.target.is_android():
      localvariables += [('sysroot', self.android.make_sysroot_path(arch))]
    archlibs = self.make_linkarchlibs(arch, targettype)
    if archlibs != []:
      localvariables += [('archlibs', self.make_libs(archlibs))]

    if 'runtime' in variables and variables['runtime'] == 'c++':
      localvariables += [('link', self.cxxlinker)]

    return localvariables

  def builder_cc(self, writer, config, arch, targettype, infile, outfile, variables):
    return writer.build(outfile, 'cc', infile, implicit = self.implicit_deps(config, variables), variables = self.cc_variables(config, arch, targettype, variables))

  def builder_cxx(self, writer, config, arch, targettype, infile, outfile, variables):
    return writer.build(outfile, 'cxx', infile, implicit = self.implicit_deps(config, variables), variables = self.cc_variables(config, arch, targettype, variables))

  def builder_cm(self, writer, config, arch, targettype, infile, outfile, variables):
    return writer.build(outfile, 'cm', infile, implicit = self.implicit_deps(config, variables), variables = self.cc_variables(config, arch, targettype, variables))

  def builder_lib(self, writer, config, arch, targettype, infiles, outfile, variables):
    return writer.build(outfile, 'ar', infiles, implicit = self.implicit_deps(config, variables), variables = self.ar_variables(config, arch, targettype, variables))

  def builder_sharedlib(self, writer, config, arch, targettype, infiles, outfile, variables):
    if self.target.is_windows():
      return writer.build(outfile, 'dll', infiles, implicit = self.implicit_deps(config, variables), variables = self.link_variables(config, arch, targettype, variables))
    return writer.build(outfile, 'so', infiles, implicit = self.implicit_deps(config, variables), variables = self.link_variables(config, arch, targettype, variables))

  def builder_bin(self, writer, config, arch, targettype, infiles, outfile, variables):
    return writer.build(outfile, 'link', infiles, implicit = self.implicit_deps(config, variables), variables = self.link_variables(config, arch, targettype, variables))

  #Apple universal targets
  def builder_apple_multilib(self, writer, config, arch, targettype, infiles, outfile, variables):
    localvariables = [('arflags', '-static -no_warning_for_no_symbols')]
    if variables != None:
      localvariables = variables + localvariables
    return writer.build(os.path.join(outfile, self.buildtarget), 'ar', infiles, variables = localvariables);

  def builder_apple_multisharedlib(self, writer, config, arch, targettype, infiles, outfile, variables):
    return writer.build(os.path.join(outfile, self.buildtarget), 'so', infiles, implicit = self.implicit_deps(config, variables), variables = self.link_variables(config, arch, targettype, variables))

  def builder_apple_multibin(self, writer, config, arch, targettype, infiles, outfile, variables):
    return writer.build(os.path.join(outfile, self.buildtarget), 'lipo', infiles, variables = variables)

def create(host, target, toolchain):
  return ClangToolchain(host, target, toolchain)