# vim: set ts=8 sts=2 sw=2 tw=99 et:

 #

 # This file is part of AMBuild.

 # 

 # AMBuild is free software: you can redistribute it and/or modify

 # it under the terms of the GNU General Public License as published by

 # the Free Software Foundation, either version 3 of the License, or

 # (at your option) any later version.

 # 

 # AMBuild is distributed in the hope that it will be useful,

 # but WITHOUT ANY WARRANTY; without even the implied warranty of

 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 # GNU General Public License for more details.

 # 

 # You should have received a copy of the GNU General Public License

 # along with AMBuild. If not, see <http://www.gnu.org/licenses/>.

 from __future__ import print_function

 import subprocess

 import re, os, copy

 from ambuild2 import util

 class Vendor(object):

   def __init__(self, name, version, behavior, command, objSuffix):

     self.name = name

     self.version = version

     self.behavior = behavior

     self.command = command

     self.objSuffix = objSuffix

     self.debuginfo_argv = []

 class MSVC(Vendor):

   def __init__(self, command, version):

     super(MSVC, self).__init__('msvc', version, 'msvc', command, '.obj')

     self.definePrefix = '/D'

     self.debuginfo_argv = ['/Zi']

     if self.version >= 1800:

       self.debuginfo_argv += ['/FS']

   @staticmethod

   def IncludePath(outputPath, includePath):

     # Hack - try and get a relative path because CL, with either 

     # /Zi or /ZI, combined with subprocess, apparently tries and

     # looks for paths like c:\bleh\"c:\bleh" <-- wtf

     # .. this according to Process Monitor

     outputPath = os.path.normcase(outputPath)

     includePath = os.path.normcase(includePath)

     outputDrive = os.path.splitdrive(outputPath)[0]

     includeDrive = os.path.splitdrive(includePath)[0]

     if outputDrive == includeDrive:

       return os.path.relpath(includePath, outputPath)

     return includePath

   def formatInclude(self, outputPath, includePath):

     return ['/I', self.IncludePath(outputPath, includePath)]

   def preprocessArgs(self, sourceFile):

     return ['/showIncludes', '/nologo', '/P', '/c', sourceFile]

   def objectArgs(self, sourceFile, objFile):

     return ['/showIncludes', '/nologo', '/c', sourceFile, '/Fo' + objFile]

 class CompatGCC(Vendor):

   def __init__(self, name, command, version):

     super(CompatGCC, self).__init__(name, version, 'gcc', command, '.o')

     parts = version.split('.')

     self.majorVersion = int(parts[0])

     self.minorVersion = int(parts[1])

     self.definePrefix = '-D'

   def formatInclude(self, outputPath, includePath):

     return ['-I', os.path.normpath(includePath)]

   def objectArgs(self, sourceFile, objFile):

     return ['-H', '-c', sourceFile, '-o', objFile]

 class GCC(CompatGCC):

   def __init__(self, command, version):

     super(GCC, self).__init__('gcc', command, version)

     self.debuginfo_argv = ['-g3', '-ggdb3']

 class Clang(CompatGCC):

   def __init__(self, command, version):

     super(Clang, self).__init__('clang', command, version)

     self.debuginfo_argv = ['-g3']

 class SunPro(Vendor):

   def __init__(self, command, version):

     super(SunPro, self).__init__('sun', version, 'sun', command, '.o')

     self.definePrefix = '-D'

     self.debuginfo_argv = ['-g3']

   def formatInclude(self, outputPath, includePath):

     return ['-I', os.path.normpath(includePath)]

   def objectArgs(self, sourceFile, objFile):

     return ['-H', '-c', sourceFile, '-o', objFile]

 def TryVerifyCompiler(cx, env, mode, cmd):

   if util.IsWindows():

     cc = VerifyCompiler(cx, env, mode, cmd, 'msvc')

     if cc:

       return cc

   return VerifyCompiler(cx, env, mode, cmd, 'gcc')

 CompilerSearch = {

   'CC': {

     'mac': ['cc', 'clang', 'gcc', 'icc'],

     'windows': ['cl'],

     'default': ['cc', 'gcc', 'clang', 'icc']

   },

   'CXX': {

     'mac': ['c++', 'clang++', 'g++', 'icc'],

     'windows': ['cl'],

     'default': ['c++', 'g++', 'clang++', 'icc']

   }

 }

 def DetectCompiler(cx, env, var):

   if var in env:

     trys = [env[var]]

   else:

     if util.Platform() in CompilerSearch[var]:

       trys = CompilerSearch[var][util.Platform()]

     else:

       trys = CompilerSearch[var]['default']

   for i in trys:

     cc = TryVerifyCompiler(cx, env, var, i)

     if cc:

       return cc

   raise Exception('Unable to find a suitable ' + var + ' compiler')

 def VerifyCompiler(cx, env, mode, cmd, vendor):

   args = cmd.split(' ')

   if 'CXXFLAGS' in env:

     args.extend(env['CXXFLAGS'])

   if 'CFLAGS' in env:

     args.extend(env['CFLAGS'])

   if mode == 'CXX' and 'CXXFLAGS' in env:

     args.extend(env['CXXFLAGS'])

   if mode == 'CXX':

     filename = 'test.cpp'

   else:

     filename = 'test.c'

   file = open(filename, 'w')

   file.write("""

 #include <stdio.h>

 #include <stdlib.h>

 int main()

 {

 #if defined __ICC

   printf("icc %d\\n", __ICC);

 #elif defined __clang__

 # if defined(__clang_major__) && defined(__clang_minor__)

   printf("clang %d.%d\\n", __clang_major__, __clang_minor__);

 # else

   printf("clang 1.%d\\n", __GNUC_MINOR__);

 # endif

 #elif defined __GNUC__

   printf("gcc %d.%d\\n", __GNUC__, __GNUC_MINOR__);

 #elif defined _MSC_VER

   printf("msvc %d\\n", _MSC_VER);

 #elif defined __TenDRA__

   printf("tendra 0\\n");

 #elif defined __SUNPRO_C

   printf("sun %x\\n", __SUNPRO_C);

 #elif defined __SUNPRO_CC

   printf("sun %x\\n", __SUNPRO_CC);

 #else

 #error "Unrecognized compiler!"

 #endif

 #if defined __cplusplus

   printf("CXX\\n");

 #else

   printf("CC\\n");

 #endif

   exit(0);

 }

 """)

   file.close()

   if mode == 'CC':

     executable = 'test' + util.ExecutableSuffix()

   elif mode == 'CXX':

     executable = 'testp' + util.ExecutableSuffix()

   # Make sure the exe is gone.

   if os.path.exists(executable):

     os.unlink(executable)

   # Until we can better detect vendors, don't do this.

   # if vendor == 'gcc' and mode == 'CXX':

   #   args.extend(['-fno-exceptions', '-fno-rtti'])

   args.extend([filename, '-o', executable])

   util.con_out(

     util.ConsoleHeader,

     'Checking {0} compiler (vendor test {1})... '.format(mode, vendor),

     util.ConsoleBlue,

     '{0}'.format(args),

     util.ConsoleNormal

   )

   p = util.CreateProcess(args)

   if p == None:

     print('not found')

     return False

   if util.WaitForProcess(p) != 0:

     print('failed with return code {0}'.format(p.returncode))

     return False

   exe = util.MakePath('.', executable)

   p = util.CreateProcess([executable], executable = exe)

   if p == None:

     print('failed to create executable')

     return False

   if util.WaitForProcess(p) != 0:

     print('executable failed with return code {0}'.format(p.returncode))

     return False

   lines = p.stdoutText.splitlines()

   if len(lines) != 2:

     print('invalid executable output')

     return False

   if lines[1] != mode:

     print('requested {0} compiler, found {1}'.format(mode, lines[1]))

     return False

   vendor, version = lines[0].split(' ')

   if vendor == 'gcc':

     v = GCC(cmd, version)

   elif vendor == 'clang':

     v = Clang(cmd, version)

   elif vendor == 'msvc':

     v = MSVC(cmd, version)

   elif vendor == 'sun':

     v = SunPro(cmd, version)

   else:

     print('Unknown vendor {0}'.format(vendor))

     return False

   util.con_out(

     util.ConsoleHeader,

     'found {0} version {1}'.format(vendor, version),

     util.ConsoleNormal

   )

   return v

 class Dep(object):

   def __init__(self, text, node):

     self.text = text

     self.node = node

 class Compiler(object):

   attrs = [

     'includes',         # C and C++ include paths

     'cxxincludes',      # C++-only include paths

     'cflags',           # C and C++ compiler flags

     'cxxflags',         # C++-only compiler flags

     'defines',          # C and C++ #defines

     'cxxdefines',       # C++-only #defines

     'rcdefines',        # Resource Compiler (RC) defines

     # Link flags. If any members are not strings, they will be interpreted as

     # Dep entries created from BinaryBuilder.

     'linkflags',

     # An array of objects to link, after all link flags have been specified.

     # Entries may either be strings containing a path, or Dep entries created

     # from BinaryBuilder.

     'postlink',

     # An array of nodes which should be weak dependencies on each source

     # compilation command.

     'sourcedeps',

   ]

   def __init__(self, cc, cxx):

     self.cc = cc

     self.cxx = cxx

     self.debuginfo = True

     for attr in Compiler.attrs:

       setattr(self, attr, [])

   def clone(self):

     cc = Compiler(self.cc, self.cxx)

     cc.cc = self.cc

     cc.cxx = self.cxx

     cc.debuginfo = self.debuginfo

     for attr in Compiler.attrs:

       setattr(cc, attr, copy.copy(getattr(self, attr)))

     return cc

   def Program(self, name):

     return Program(self, name)

   def Library(self, name):

     return Library(self, name)

   def StaticLibrary(self, name):

     return StaticLibrary(self, name)

   @staticmethod

   def Dep(text, node=None):

     return Dep(text, node)

 # Environment representing a C/C++ compiler invocation. Encapsulates most

 # arguments.

 class CCommandEnv(object):

   def __init__(self, outputPath, config, compiler):

     args = compiler.command.split(' ')

     args += config.cflags

     if config.debuginfo:

       args += compiler.debuginfo_argv

     if compiler == config.cxx:

       args += config.cxxflags

     args += [compiler.definePrefix + define for define in config.defines]

     if compiler == config.cxx:

       args += [compiler.definePrefix + define for define in config.cxxdefines]

     for include in config.includes:

       args += compiler.formatInclude(outputPath, include)

     if compiler == config.cxx:

       for include in config.cxxincludes:

         args += compiler.formatInclude(outputPath, include)

     self.argv = args

     self.compiler = compiler

 def NameForObjectFile(file):

   return re.sub('[^a-zA-Z0-9_]+', '_', os.path.splitext(file)[0]);

 class ObjectFile(object):

   def __init__(self, sourceFile, outputFile, argv, sharedOutputs):

     self.sourceFile = sourceFile

     self.outputFile = outputFile

     self.argv = argv

     self.sharedOutputs = sharedOutputs

 class RCFile(object):

   def __init__(self, sourceFile, preprocFile, outputFile, cl_argv, rc_argv):

     self.sourceFile = sourceFile

     self.preprocFile = preprocFile

     self.outputFile = outputFile

     self.cl_argv = cl_argv 

     self.rc_argv = rc_argv

 class BinaryBuilder(object):

   def __init__(self, compiler, name):

     super(BinaryBuilder, self).__init__()

     self.compiler = compiler.clone()

     self.sources = []

     self.name_ = name

     self.used_cxx_ = False

     self.linker_ = None

   def generate(self, generator, cx):

     return generator.addCxxTasks(cx, self)

   # Make an item that can be passed into linkflags/postlink but has an attached

   # dependency.

   def Dep(self, text, node=None): 

     return Dep(text, node)

   # The folder we'll be in, relative to our build context.

   @property

   def localFolder(self):

     return self.name_

   # Exposed only for frontends.

   @property

   def linker(self):

     return self.linker_

   # Compute the build folder.

   def getBuildFolder(self, builder):

     return os.path.join(builder.buildFolder, self.localFolder)

   def linkFlag(self, cx, item):

     if type(item) is Dep:

       # If the dep is a file dependency (no node attached), and has a relative

       # path, make it absolute so the linker knows where to look.

       if item.node is None and not os.path.isabs(item.text):

         return os.path.join(cx.currentSourcePath, item.text)

       return item.text

     if hasattr(item, 'path'):

       if os.path.isabs(item.path):

         return item.path

       local_path = os.path.join(cx.buildFolder, self.localFolder)

       return os.path.relpath(item.path, local_path)

     return item

   def linkFlags(self, cx):

     argv = [self.linkFlag(cx, item) for item in self.compiler.linkflags]

     argv += [self.linkFlag(cx, item) for item in self.compiler.postlink]

     return argv

   def finish(self, cx):

     # Because we want to compute relative include folders for MSVC (see its

     # vendor object), we need to compute an absolute path to the build folder.

     self.outputFolder = self.getBuildFolder(cx)

     self.outputPath = os.path.join(cx.buildPath, self.outputFolder)

     self.default_c_env = CCommandEnv(self.outputPath, self.compiler, self.compiler.cc)

     self.default_cxx_env = CCommandEnv(self.outputPath, self.compiler, self.compiler.cxx)

     shared_cc_outputs = []

     if self.compiler.debuginfo and self.compiler.cc.behavior == 'msvc':

       cl_version = int(self.compiler.cc.version) - 600

       shared_pdb = 'vc{0}.pdb'.format(int(cl_version / 10))

       shared_cc_outputs += [shared_pdb]

     self.objects = []

     self.resources = []

     for item in self.sources:

       if os.path.isabs(item):

         sourceFile = item

       else:

         sourceFile = os.path.join(cx.currentSourcePath, item)

       sourceFile = os.path.normpath(sourceFile)

       filename, extension = os.path.splitext(item)

       encname = NameForObjectFile(filename)

       if extension == '.rc':

         cenv = self.default_c_env

         objectFile = encname + '.res'

       else:

         if extension == '.c':

           cenv = self.default_c_env

         else:

           cenv = self.default_cxx_env

           self.used_cxx_ = True

         objectFile = encname + cenv.compiler.objSuffix

       if extension == '.rc':

         # This is only relevant on Windows.

         vendor = cenv.compiler

         defines = self.compiler.defines + self.compiler.cxxdefines + self.compiler.rcdefines

         cl_argv = vendor.command.split(' ')

         cl_argv += [vendor.definePrefix + define for define in defines]

         for include in (self.compiler.includes + self.compiler.cxxincludes):

           cl_argv += vendor.formatInclude(objectFile, include)

         cl_argv += vendor.preprocessArgs(sourceFile)

         rc_argv = ['rc', '/nologo']

         for define in defines:

           rc_argv.extend(['/d', define])

         for include in (self.compiler.includes + self.compiler.cxxincludes):

           rc_argv.extend(['/i', MSVC.IncludePath(objectFile, include)])

         rc_argv.append('/fo' + objectFile)

         rc_argv.append(sourceFile)

         self.resources.append(RCFile(sourceFile, encname + '.i', objectFile, cl_argv, rc_argv))

       else:

         argv = cenv.argv + cenv.compiler.objectArgs(sourceFile, objectFile)

         obj = ObjectFile(sourceFile, objectFile, argv, shared_cc_outputs)

         self.objects.append(obj)

     if not self.linker_:

       if self.used_cxx_:

         self.linker_ = self.compiler.cxx

       else:

         self.linker_ = self.compiler.cc

     files = [out.outputFile for out in self.objects + self.resources]

     self.argv = self.generateBinary(cx, files)

     self.linker_outputs = [self.outputFile]

     self.debug_entry = None

     if self.linker_.behavior == 'msvc':

       if isinstance(self, Library):

         # In theory, .dlls should have exports, so MSVC will generate these

         # files. If this turns out not to be true, we may have to get fancier.

         self.linker_outputs += [self.name_ + '.lib']

         self.linker_outputs += [self.name_ + '.exp']

     if self.compiler.debuginfo:

       self.perform_symbol_steps(cx)

   def perform_symbol_steps(self, cx):

     if isinstance(self.linker_, MSVC):

       # Note, pdb is last since we read the pdb as outputs[-1].

       self.linker_outputs += [self.name_ + '.pdb']

     elif cx.target_platform is 'mac':

       bundle_folder = os.path.join(self.localFolder, self.outputFile + '.dSYM')

       bundle_entry = cx.AddFolder(bundle_folder)

       bundle_layout = [

         'Contents',

         'Contents/Resources',

         'Contents/Resources/DWARF',

       ]

       for folder in bundle_layout:

         cx.AddFolder(os.path.join(bundle_folder, folder))

       self.linker_outputs += [

         self.outputFile + '.dSYM/Contents/Info.plist',

         self.outputFile + '.dSYM/Contents/Resources/DWARF/' + self.outputFile

       ]

       self.debug_entry = bundle_entry

       self.argv = ['ambuild_dsymutil_wrapper.sh', self.outputFile] + self.argv

     elif cx.target_platform is 'linux':

       self.linker_outputs += [

         self.outputFile + '.dbg'

       ]

       self.argv = ['ambuild_objcopy_wrapper.sh', self.outputFile] + self.argv

   def link(self, context, folder, inputs):

     # The existence of .ilk files on Windows does not seem reliable, so we

     # treat it as "shared" which does not participate in the DAG (yet).

     shared_outputs = []

     if self.linker_.behavior == 'msvc':

       if not isinstance(self, StaticLibrary) and '/INCREMENTAL:NO' not in self.argv:

         shared_outputs += [self.name_ + '.ilk']

     ignore, outputs = context.AddCommand(

       inputs = inputs,

       argv = self.argv,

       outputs = self.linker_outputs,

       folder = folder,

       shared_outputs = shared_outputs

     )

     if not self.debug_entry and self.compiler.debuginfo:

       self.debug_entry = outputs[-1]

     return outputs[0], self.debug_entry

 class Program(BinaryBuilder):

   def __init__(self, compiler, name):

     super(Program, self).__init__(compiler, name)

     self.outputFile = name + util.ExecutableSuffix()

   def generateBinary(self, cx, files):

     argv = self.linker_.command.split(' ')

     argv += files

     if isinstance(self.linker_, MSVC):

       argv.append('/link')

       argv.extend(self.linkFlags(cx))

       argv.append('/nologo')

       argv += [

         '/OUT:' + self.outputFile,

         '/nologo',

       ]

       if self.compiler.debuginfo:

         argv += ['/DEBUG', '/PDB:"' + self.name_ + '.pdb"']

     else:

       argv.extend(self.linkFlags(cx))

       argv.extend(['-o', self.outputFile])

     return argv

 class Library(BinaryBuilder):

   def __init__(self, compiler, name):

     super(Library, self).__init__(compiler, name)

     self.outputFile = name + util.SharedLibSuffix()

   def generateBinary(self, cx, files):

     argv = self.linker_.command.split(' ')

     argv += files

     if isinstance(self.linker_, MSVC):

       argv.append('/link')

       argv.extend(self.linkFlags(cx))

       argv += [

         '/OUT:' + self.outputFile,

         '/DEBUG',

         '/nologo',

         '/DLL',

       ]

       if self.compiler.debuginfo:

         argv += ['/DEBUG', '/PDB:"' + self.name_ + '.pdb"']

     elif isinstance(self.linker_, CompatGCC):

       argv.extend(self.linkFlags(cx))

       if util.IsMac():

         argv.append('-dynamiclib')

       else:

         argv.append('-shared')

       argv.extend(['-o', self.outputFile])

     return argv

 class StaticLibrary(BinaryBuilder):

   def __init__(self, compiler, name):

     super(StaticLibrary, self).__init__(compiler, name)

     self.outputFile = util.StaticLibPrefix() + name + util.StaticLibSuffix()

   def generateBinary(self, cx, files):

     if isinstance(self.linker_, MSVC):

       argv = ['lib.exe', '/OUT:' + self.outputFile]

     else:

       argv = ['ar', 'rcs', self.outputFile]

     argv += files

     return argv

   def perform_symbol_steps(self, cx):

     pass