Adding cross-compile ability to the make build

pylib/gyp/generator/scons.py

 #!/usr/bin/python
 
 
 import gyp
 import gyp.common
 import gyp.SCons as SCons
 import os.path
 import pprint
 import re
 
@@ skipping 884 matching lines @@
   fp = open(SConstruct, 'w')
   fp.write(header)
   fp.write('SConscript(%s)\n' % repr(fname))
   fp.close()
 
 
 def TargetFilename(target, build_file=None, output_suffix=''):
   """Returns the .scons file name for the specified target.
   """
   if build_file is None:
-    build_file, target = gyp.common.BuildFileAndTarget('', target)[:2]
+    build_file, target = gyp.common.ParseQualifiedTarget(target)[:2]
   output_file = os.path.join(os.path.dirname(build_file),
                              target + output_suffix + '.scons')
   return output_file
 
 
 def GenerateOutput(target_list, target_dicts, data, params):
   """
   Generates all the output files for the specified targets.
   """
   options = params['options']
 
   if options.generator_output:
     def output_path(filename):
       return filename.replace(params['cwd'], options.generator_output)
   else:
     def output_path(filename):
       return filename
 
   default_configuration = None
 
   for qualified_target in target_list:
     spec = target_dicts[qualified_target]
+    if spec['toolset'] != 'target':
+      raise Exception(
+          'Multiple toolsets not supported in scons build (target %s)' %
+          qualified_target)
     scons_target = SCons.Target(spec)
     if scons_target.is_ignored:
       continue
 
     # TODO:  assumes the default_configuration of the first target
     # non-Default target is the correct default for all targets.
     # Need a better model for handle variation between targets.
     if (not default_configuration and
         spec['default_configuration'] != 'Default'):
       default_configuration = spec['default_configuration']
 
-    build_file, target = gyp.common.BuildFileAndTarget('', qualified_target)[:2]
+    build_file, target = gyp.common.ParseQualifiedTarget(qualified_target)[:2]
     output_file = TargetFilename(target, build_file, options.suffix)
     if options.generator_output:
       output_file = output_path(output_file)
 
     if not spec.has_key('libraries'):
       spec['libraries'] = []
 
     # Add dependent static library targets to the 'libraries' value.
     deps = spec.get('dependencies', [])
     spec['scons_dependencies'] = []
@@ skipping 24 matching lines @@
       continue
     output_dir, basename = os.path.split(path)
     output_filename  = path + '_main' + options.suffix + '.scons'
 
     all_targets = gyp.common.AllTargets(target_list, target_dicts, build_file)
     sconscript_files = {}
     for t in all_targets:
       scons_target = SCons.Target(target_dicts[t])
       if scons_target.is_ignored:
         continue
-      bf, target = gyp.common.BuildFileAndTarget('', t)[:2]
+      bf, target = gyp.common.ParseQualifiedTarget(t)[:2]
       target_filename = TargetFilename(target, bf, options.suffix)
       tpath = gyp.common.RelativePath(target_filename, output_dir)
       sconscript_files[target] = tpath
 
     output_filename = output_path(output_filename)
     if sconscript_files:
       GenerateSConscriptWrapper(build_file, data[build_file], basename,
                                 output_filename, sconscript_files,
                                 default_configuration)