← Back to branch summary

~ubuntu-branches/ubuntu/trusty/mapnik/trusty

« back to all changes in this revision

Viewing changes to scons/scons-local-0.97.0d20071212/SCons/Tool/mslink.py

  • Committer: Bazaar Package Importer
  • Author(s): Andres Rodriguez
  • Date: 2009-05-20 15:39:58 UTC
  • mfrom: (3.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090520153958-cf6z1ql9zva4y4dq
Tags: 0.6.0-1ubuntu1
https://launchpad.net/bugs/378819
* Merge from debian unstable (LP: #378819), remaining changes:
  - debian/control:
    + Change bdeps from python2.5-dev to python-all-dev (>= 2.5)
    + Change XS-Python-Version from 2.5 to >= 2.5
  - debian/rules:
    + Various changes to enable python2.5 and python2.6 builds
* debian/patches/libtool2_2.diff Dropped. Included upsteam.
* Removed quilt support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scons/scons-local-0.97.0d20071212/SCons/Tool/mslink.py
1
 
"""SCons.Tool.mslink
2
 
 
3
 
Tool-specific initialization for the Microsoft linker.
4
 
 
5
 
There normally shouldn't be any need to import this module directly.
6
 
It will usually be imported through the generic SCons.Tool.Tool()
7
 
selection method.
8
 
 
9
 
"""
10
 
 
11
 
#
12
 
# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007 The SCons Foundation
13
 
#
14
 
# Permission is hereby granted, free of charge, to any person obtaining
15
 
# a copy of this software and associated documentation files (the
16
 
# "Software"), to deal in the Software without restriction, including
17
 
# without limitation the rights to use, copy, modify, merge, publish,
18
 
# distribute, sublicense, and/or sell copies of the Software, and to
19
 
# permit persons to whom the Software is furnished to do so, subject to
20
 
# the following conditions:
21
 
#
22
 
# The above copyright notice and this permission notice shall be included
23
 
# in all copies or substantial portions of the Software.
24
 
#
25
 
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
26
 
# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
27
 
# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28
 
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
29
 
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
30
 
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
31
 
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
32
 
#
33
 
 
34
 
__revision__ = "src/engine/SCons/Tool/mslink.py 2523 2007/12/12 09:37:41 knight"
35
 
 
36
 
import os.path
37
 
 
38
 
import SCons.Action
39
 
import SCons.Defaults
40
 
import SCons.Errors
41
 
import SCons.Platform.win32
42
 
import SCons.Tool
43
 
import SCons.Tool.msvc
44
 
import SCons.Tool.msvs
45
 
import SCons.Util
46
 
 
47
 
def pdbGenerator(env, target, source, for_signature):
48
 
    try:
49
 
        return ['/PDB:%s' % target[0].attributes.pdb, '/DEBUG']
50
 
    except (AttributeError, IndexError):
51
 
        return None
52
 
 
53
 
def windowsShlinkTargets(target, source, env, for_signature):
54
 
    listCmd = []
55
 
    dll = env.FindIxes(target, 'SHLIBPREFIX', 'SHLIBSUFFIX')
56
 
    if dll: listCmd.append("/out:%s"%dll.get_string(for_signature))
57
 
 
58
 
    implib = env.FindIxes(target, 'LIBPREFIX', 'LIBSUFFIX')
59
 
    if implib: listCmd.append("/implib:%s"%implib.get_string(for_signature))
60
 
 
61
 
    return listCmd
62
 
 
63
 
def windowsShlinkSources(target, source, env, for_signature):
64
 
    listCmd = []
65
 
 
66
 
    deffile = env.FindIxes(source, "WINDOWSDEFPREFIX", "WINDOWSDEFSUFFIX")
67
 
    for src in source:
68
 
        if src == deffile:
69
 
            # Treat this source as a .def file.
70
 
            listCmd.append("/def:%s" % src.get_string(for_signature))
71
 
        else:
72
 
            # Just treat it as a generic source file.
73
 
            listCmd.append(src)
74
 
    return listCmd
75
 
 
76
 
def windowsLibEmitter(target, source, env):
77
 
    SCons.Tool.msvc.validate_vars(env)
78
 
 
79
 
    dll = env.FindIxes(target, "SHLIBPREFIX", "SHLIBSUFFIX")
80
 
    no_import_lib = env.get('no_import_lib', 0)
81
 
 
82
 
    if not dll:
83
 
        raise SCons.Errors.UserError, "A shared library should have exactly one target with the suffix: %s" % env.subst("$SHLIBSUFFIX")
84
 
 
85
 
    insert_def = env.subst("$WINDOWS_INSERT_DEF")
86
 
    if not insert_def in ['', '0', 0] and \
87
 
       not env.FindIxes(source, "WINDOWSDEFPREFIX", "WINDOWSDEFSUFFIX"):
88
 
 
89
 
        # append a def file to the list of sources
90
 
        source.append(env.ReplaceIxes(dll,
91
 
                                      "SHLIBPREFIX", "SHLIBSUFFIX",
92
 
                                      "WINDOWSDEFPREFIX", "WINDOWSDEFSUFFIX"))
93
 
 
94
 
    version_num, suite = SCons.Tool.msvs.msvs_parse_version(env.get('MSVS_VERSION', '6.0'))
95
 
    if version_num >= 8.0 and env.get('WINDOWS_INSERT_MANIFEST', 0):
96
 
        # MSVC 8 automatically generates .manifest files that must be installed
97
 
        target.append(env.ReplaceIxes(dll,
98
 
                                      "SHLIBPREFIX", "SHLIBSUFFIX",
99
 
                                      "WINDOWSSHLIBMANIFESTPREFIX", "WINDOWSSHLIBMANIFESTSUFFIX"))
100
 
 
101
 
    if env.has_key('PDB') and env['PDB']:
102
 
        pdb = env.arg2nodes('$PDB', target=target, source=source)[0]
103
 
        target.append(pdb)
104
 
        target[0].attributes.pdb = pdb
105
 
 
106
 
    if not no_import_lib and \
107
 
       not env.FindIxes(target, "LIBPREFIX", "LIBSUFFIX"):
108
 
        # Append an import library to the list of targets.
109
 
        target.append(env.ReplaceIxes(dll,
110
 
                                      "SHLIBPREFIX", "SHLIBSUFFIX",
111
 
                                      "LIBPREFIX", "LIBSUFFIX"))
112
 
        # and .exp file is created if there are exports from a DLL
113
 
        target.append(env.ReplaceIxes(dll,
114
 
                                      "SHLIBPREFIX", "SHLIBSUFFIX",
115
 
                                      "WINDOWSEXPPREFIX", "WINDOWSEXPSUFFIX"))
116
 
 
117
 
    return (target, source)
118
 
 
119
 
def prog_emitter(target, source, env):
120
 
    SCons.Tool.msvc.validate_vars(env)
121
 
 
122
 
    exe = env.FindIxes(target, "PROGPREFIX", "PROGSUFFIX")
123
 
    if not exe:
124
 
        raise SCons.Errors.UserError, "An executable should have exactly one target with the suffix: %s" % env.subst("$PROGSUFFIX")
125
 
 
126
 
    version_num, suite = SCons.Tool.msvs.msvs_parse_version(env.get('MSVS_VERSION', '6.0'))
127
 
    if version_num >= 8.0 and env.get('WINDOWS_INSERT_MANIFEST', 0):
128
 
        # MSVC 8 automatically generates .manifest files that have to be installed
129
 
        target.append(env.ReplaceIxes(exe,
130
 
                                      "PROGPREFIX", "PROGSUFFIX",
131
 
                                      "WINDOWSPROGMANIFESTPREFIX", "WINDOWSPROGMANIFESTSUFFIX"))
132
 
 
133
 
    if env.has_key('PDB') and env['PDB']:
134
 
        pdb = env.arg2nodes('$PDB', target=target, source=source)[0]
135
 
        target.append(pdb)
136
 
        target[0].attributes.pdb = pdb
137
 
 
138
 
    return (target,source)
139
 
 
140
 
def RegServerFunc(target, source, env):
141
 
    if env.has_key('register') and env['register']:
142
 
        ret = regServerAction([target[0]], [source[0]], env)
143
 
        if ret:
144
 
            raise SCons.Errors.UserError, "Unable to register %s" % target[0]
145
 
        else:
146
 
            print "Registered %s sucessfully" % target[0]
147
 
        return ret
148
 
    return 0
149
 
 
150
 
regServerAction = SCons.Action.Action("$REGSVRCOM", "$REGSVRCOMSTR")
151
 
regServerCheck = SCons.Action.Action(RegServerFunc, None)
152
 
shlibLinkAction = SCons.Action.Action('${TEMPFILE("$SHLINK $SHLINKFLAGS $_SHLINK_TARGETS $( $_LIBDIRFLAGS $) $_LIBFLAGS $_PDB $_SHLINK_SOURCES")}')
153
 
compositeLinkAction = shlibLinkAction + regServerCheck
154
 
 
155
 
def generate(env):
156
 
    """Add Builders and construction variables for ar to an Environment."""
157
 
    SCons.Tool.createSharedLibBuilder(env)
158
 
    SCons.Tool.createProgBuilder(env)
159
 
 
160
 
    env['SHLINK']      = '$LINK'
161
 
    env['SHLINKFLAGS'] = SCons.Util.CLVar('$LINKFLAGS /dll')
162
 
    env['_SHLINK_TARGETS'] = windowsShlinkTargets
163
 
    env['_SHLINK_SOURCES'] = windowsShlinkSources
164
 
    env['SHLINKCOM']   =  compositeLinkAction
165
 
    env.Append(SHLIBEMITTER = [windowsLibEmitter])
166
 
    env['LINK']        = 'link'
167
 
    env['LINKFLAGS']   = SCons.Util.CLVar('/nologo')
168
 
    env['_PDB'] = pdbGenerator
169
 
    env['LINKCOM'] = '${TEMPFILE("$LINK $LINKFLAGS /OUT:$TARGET.windows $( $_LIBDIRFLAGS $) $_LIBFLAGS $_PDB $SOURCES.windows")}'
170
 
    env.Append(PROGEMITTER = [prog_emitter])
171
 
    env['LIBDIRPREFIX']='/LIBPATH:'
172
 
    env['LIBDIRSUFFIX']=''
173
 
    env['LIBLINKPREFIX']=''
174
 
    env['LIBLINKSUFFIX']='$LIBSUFFIX'
175
 
 
176
 
    env['WIN32DEFPREFIX']        = ''
177
 
    env['WIN32DEFSUFFIX']        = '.def'
178
 
    env['WIN32_INSERT_DEF']      = 0
179
 
    env['WINDOWSDEFPREFIX']      = '${WIN32DEFPREFIX}'
180
 
    env['WINDOWSDEFSUFFIX']      = '${WIN32DEFSUFFIX}'
181
 
    env['WINDOWS_INSERT_DEF']    = '${WIN32_INSERT_DEF}'
182
 
 
183
 
    env['WIN32EXPPREFIX']        = ''
184
 
    env['WIN32EXPSUFFIX']        = '.exp'
185
 
    env['WINDOWSEXPPREFIX']      = '${WIN32EXPPREFIX}'
186
 
    env['WINDOWSEXPSUFFIX']      = '${WIN32EXPSUFFIX}'
187
 
 
188
 
    env['WINDOWSSHLIBMANIFESTPREFIX'] = ''
189
 
    env['WINDOWSSHLIBMANIFESTSUFFIX'] = '${SHLIBSUFFIX}.manifest'
190
 
    env['WINDOWSPROGMANIFESTPREFIX']  = ''
191
 
    env['WINDOWSPROGMANIFESTSUFFIX']  = '${PROGSUFFIX}.manifest'
192
 
 
193
 
    env['REGSVRACTION'] = regServerCheck
194
 
    env['REGSVR'] = os.path.join(SCons.Platform.win32.get_system_root(),'System32','regsvr32')
195
 
    env['REGSVRFLAGS'] = '/s '
196
 
    env['REGSVRCOM'] = '$REGSVR $REGSVRFLAGS ${TARGET.windows}'
197
 
 
198
 
    try:
199
 
        version = SCons.Tool.msvs.get_default_visualstudio_version(env)
200
 
 
201
 
        if env.has_key('MSVS_IGNORE_IDE_PATHS') and env['MSVS_IGNORE_IDE_PATHS']:
202
 
            include_path, lib_path, exe_path = SCons.Tool.msvc.get_msvc_default_paths(env,version)
203
 
        else:
204
 
            include_path, lib_path, exe_path = SCons.Tool.msvc.get_msvc_paths(env,version)
205
 
 
206
 
        # since other tools can set these, we just make sure that the
207
 
        # relevant stuff from MSVS is in there somewhere.
208
 
        env.PrependENVPath('INCLUDE', include_path)
209
 
        env.PrependENVPath('LIB', lib_path)
210
 
        env.PrependENVPath('PATH', exe_path)
211
 
    except (SCons.Util.RegError, SCons.Errors.InternalError):
212
 
        pass
213
 
 
214
 
    # For most platforms, a loadable module is the same as a shared
215
 
    # library.  Platforms which are different can override these, but
216
 
    # setting them the same means that LoadableModule works everywhere.
217
 
    SCons.Tool.createLoadableModuleBuilder(env)
218
 
    env['LDMODULE'] = '$SHLINK'
219
 
    env['LDMODULEPREFIX'] = '$SHLIBPREFIX'
220
 
    env['LDMODULESUFFIX'] = '$SHLIBSUFFIX'
221
 
    env['LDMODULEFLAGS'] = '$SHLINKFLAGS'
222
 
    # We can't use '$SHLINKCOM' here because that will stringify the
223
 
    # action list on expansion, and will then try to execute expanded
224
 
    # strings, with the upshot that it would try to execute RegServerFunc
225
 
    # as a command.
226
 
    env['LDMODULECOM'] = compositeLinkAction
227
 
 
228
 
def exists(env):
229
 
    platform = env.get('PLATFORM', '')
230
 
    if SCons.Tool.msvs.is_msvs_installed():
231
 
        # there's at least one version of MSVS installed.
232
 
        return 1
233
 
    elif platform in ('win32', 'cygwin'):
234
 
        # Only explicitly search for a 'link' executable on Windows
235
 
        # systems.  Some other systems (e.g. Ubuntu Linux) have an
236
 
        # executable named 'link' and we don't want that to make SCons
237
 
        # think Visual Studio is installed.
238
 
        return env.Detect('link')
239
 
    return None