Include searchindex.js in python-pysqlite2-doc package (closes: #678050)
[joel/debian/python-pysqlite2.git] / cross_bdist_wininst.py
1 # Gerhard Haering <gh@gharing.d> is responsible for the hacked version of this
2 # module.
3 #
4 # This is a modified version of the bdist_wininst distutils command to make it
5 # possible to build installers *with extension modules* on Unix.
6
7 """distutils.command.bdist_wininst
8
9 Implements the Distutils 'bdist_wininst' command: create a windows installer
10 exe-program."""
11
12 # This module should be kept compatible with Python 2.1.
13
14 __revision__ = "$Id: bdist_wininst.py 59620 2007-12-31 14:47:07Z christian.heimes $"
15
16 import sys, os, string
17 from distutils.core import Command
18 from distutils.util import get_platform
19 from distutils.dir_util import create_tree, remove_tree
20 from distutils.errors import *
21 from distutils.sysconfig import get_python_version
22 from distutils import log
23
24 class bdist_wininst (Command):
25
26     description = "create an executable installer for MS Windows"
27
28     user_options = [('bdist-dir=', None,
29                      "temporary directory for creating the distribution"),
30                     ('keep-temp', 'k',
31                      "keep the pseudo-installation tree around after " +
32                      "creating the distribution archive"),
33                     ('target-version=', None,
34                      "require a specific python version" +
35                      " on the target system"),
36                     ('no-target-compile', 'c',
37                      "do not compile .py to .pyc on the target system"),
38                     ('no-target-optimize', 'o',
39                      "do not compile .py to .pyo (optimized)"
40                      "on the target system"),
41                     ('dist-dir=', 'd',
42                      "directory to put final built distributions in"),
43                     ('bitmap=', 'b',
44                      "bitmap to use for the installer instead of python-powered logo"),
45                     ('title=', 't',
46                      "title to display on the installer background instead of default"),
47                     ('skip-build', None,
48                      "skip rebuilding everything (for testing/debugging)"),
49                     ('install-script=', None,
50                      "basename of installation script to be run after"
51                      "installation or before deinstallation"),
52                     ('pre-install-script=', None,
53                      "Fully qualified filename of a script to be run before "
54                      "any files are installed.  This script need not be in the "
55                      "distribution"),
56                    ]
57
58     boolean_options = ['keep-temp', 'no-target-compile', 'no-target-optimize',
59                        'skip-build']
60
61     def initialize_options (self):
62         self.bdist_dir = None
63         self.keep_temp = 0
64         self.no_target_compile = 0
65         self.no_target_optimize = 0
66         self.target_version = None
67         self.dist_dir = None
68         self.bitmap = None
69         self.title = None
70         self.skip_build = 0
71         self.install_script = None
72         self.pre_install_script = None
73
74     # initialize_options()
75
76
77     def finalize_options (self):
78         if self.bdist_dir is None:
79             bdist_base = self.get_finalized_command('bdist').bdist_base
80             self.bdist_dir = os.path.join(bdist_base, 'wininst')
81         if not self.target_version:
82             self.target_version = ""
83         if not self.skip_build and self.distribution.has_ext_modules():
84             short_version = get_python_version()
85             if self.target_version and self.target_version != short_version:
86                 raise DistutilsOptionError, \
87                       "target version can only be %s, or the '--skip_build'" \
88                       " option must be specified" % (short_version,)
89             self.target_version = short_version
90
91         self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
92
93         if self.install_script:
94             for script in self.distribution.scripts:
95                 if self.install_script == os.path.basename(script):
96                     break
97             else:
98                 raise DistutilsOptionError, \
99                       "install_script '%s' not found in scripts" % \
100                       self.install_script
101     # finalize_options()
102
103
104     def run (self):
105         # HACK I disabled this check.
106         if 0 and (sys.platform != "win32" and
107             (self.distribution.has_ext_modules() or
108              self.distribution.has_c_libraries())):
109             raise DistutilsPlatformError \
110                   ("distribution contains extensions and/or C libraries; "
111                    "must be compiled on a Windows 32 platform")
112
113         if not self.skip_build:
114             self.run_command('build')
115
116         install = self.reinitialize_command('install', reinit_subcommands=1)
117         install.root = self.bdist_dir
118         install.skip_build = self.skip_build
119         install.warn_dir = 0
120
121         install_lib = self.reinitialize_command('install_lib')
122         # we do not want to include pyc or pyo files
123         install_lib.compile = 0
124         install_lib.optimize = 0
125
126         if self.distribution.has_ext_modules():
127             # If we are building an installer for a Python version other
128             # than the one we are currently running, then we need to ensure
129             # our build_lib reflects the other Python version rather than ours.
130             # Note that for target_version!=sys.version, we must have skipped the
131             # build step, so there is no issue with enforcing the build of this
132             # version.
133             target_version = self.target_version
134             if not target_version:
135                 assert self.skip_build, "Should have already checked this"
136                 target_version = sys.version[0:3]
137             plat_specifier = ".%s-%s" % (get_platform(), target_version)
138             build = self.get_finalized_command('build')
139             build.build_lib = os.path.join(build.build_base,
140                                            'lib' + plat_specifier)
141
142         # Use a custom scheme for the zip-file, because we have to decide
143         # at installation time which scheme to use.
144         for key in ('purelib', 'platlib', 'headers', 'scripts', 'data'):
145             value = string.upper(key)
146             if key == 'headers':
147                 value = value + '/Include/$dist_name'
148             setattr(install,
149                     'install_' + key,
150                     value)
151
152         log.info("installing to %s", self.bdist_dir)
153         install.ensure_finalized()
154
155         # avoid warning of 'install_lib' about installing
156         # into a directory not in sys.path
157         sys.path.insert(0, os.path.join(self.bdist_dir, 'PURELIB'))
158
159         install.run()
160
161         del sys.path[0]
162
163         # And make an archive relative to the root of the
164         # pseudo-installation tree.
165         from tempfile import mktemp
166         archive_basename = mktemp()
167         fullname = self.distribution.get_fullname()
168         arcname = self.make_archive(archive_basename, "zip",
169                                     root_dir=self.bdist_dir)
170         # create an exe containing the zip-file
171         self.create_exe(arcname, fullname, self.bitmap)
172         if self.distribution.has_ext_modules():
173             pyversion = get_python_version()
174         else:
175             pyversion = 'any'
176         self.distribution.dist_files.append(('bdist_wininst', pyversion,
177                                              self.get_installer_filename(fullname)))
178         # remove the zip-file again
179         log.debug("removing temporary file '%s'", arcname)
180         os.remove(arcname)
181
182         if not self.keep_temp:
183             remove_tree(self.bdist_dir, dry_run=self.dry_run)
184
185     # run()
186
187     def get_inidata (self):
188         # Return data describing the installation.
189
190         lines = []
191         metadata = self.distribution.metadata
192
193         # Write the [metadata] section.
194         lines.append("[metadata]")
195
196         # 'info' will be displayed in the installer's dialog box,
197         # describing the items to be installed.
198         info = (metadata.long_description or '') + '\n'
199
200         # Escape newline characters
201         def escape(s):
202             return string.replace(s, "\n", "\\n")
203
204         for name in ["author", "author_email", "description", "maintainer",
205                      "maintainer_email", "name", "url", "version"]:
206             data = getattr(metadata, name, "")
207             if data:
208                 info = info + ("\n    %s: %s" % \
209                                (string.capitalize(name), escape(data)))
210                 lines.append("%s=%s" % (name, escape(data)))
211
212         # The [setup] section contains entries controlling
213         # the installer runtime.
214         lines.append("\n[Setup]")
215         if self.install_script:
216             lines.append("install_script=%s" % self.install_script)
217         lines.append("info=%s" % escape(info))
218         lines.append("target_compile=%d" % (not self.no_target_compile))
219         lines.append("target_optimize=%d" % (not self.no_target_optimize))
220         if self.target_version:
221             lines.append("target_version=%s" % self.target_version)
222
223         title = self.title or self.distribution.get_fullname()
224         lines.append("title=%s" % escape(title))
225         import time
226         import distutils
227         build_info = "Built %s with distutils-%s" % \
228                      (time.ctime(time.time()), distutils.__version__)
229         lines.append("build_info=%s" % build_info)
230         return string.join(lines, "\n")
231
232     # get_inidata()
233
234     def create_exe (self, arcname, fullname, bitmap=None):
235         import struct
236
237         self.mkpath(self.dist_dir)
238
239         cfgdata = self.get_inidata()
240
241         installer_name = self.get_installer_filename(fullname)
242         self.announce("creating %s" % installer_name)
243
244         if bitmap:
245             bitmapdata = open(bitmap, "rb").read()
246             bitmaplen = len(bitmapdata)
247         else:
248             bitmaplen = 0
249
250         file = open(installer_name, "wb")
251         file.write(self.get_exe_bytes())
252         if bitmap:
253             file.write(bitmapdata)
254
255         # Convert cfgdata from unicode to ascii, mbcs encoded
256         try:
257             unicode
258         except NameError:
259             pass
260         else:
261             if isinstance(cfgdata, unicode):
262                 cfgdata = cfgdata.encode("mbcs")
263
264         # Append the pre-install script
265         cfgdata = cfgdata + "\0"
266         if self.pre_install_script:
267             script_data = open(self.pre_install_script, "r").read()
268             cfgdata = cfgdata + script_data + "\n\0"
269         else:
270             # empty pre-install script
271             cfgdata = cfgdata + "\0"
272         file.write(cfgdata)
273
274         # The 'magic number' 0x1234567B is used to make sure that the
275         # binary layout of 'cfgdata' is what the wininst.exe binary
276         # expects.  If the layout changes, increment that number, make
277         # the corresponding changes to the wininst.exe sources, and
278         # recompile them.
279         header = struct.pack("<iii",
280                              0x1234567B,       # tag
281                              len(cfgdata),     # length
282                              bitmaplen,        # number of bytes in bitmap
283                              )
284         file.write(header)
285         file.write(open(arcname, "rb").read())
286
287     # create_exe()
288
289     def get_installer_filename(self, fullname):
290         # Factored out to allow overriding in subclasses
291         if self.target_version:
292             # if we create an installer for a specific python version,
293             # it's better to include this in the name
294             installer_name = os.path.join(self.dist_dir,
295                                           "%s.win32-py%s.exe" %
296                                            (fullname, self.target_version))
297         else:
298             installer_name = os.path.join(self.dist_dir,
299                                           "%s.win32.exe" % fullname)
300         return installer_name
301     # get_installer_filename()
302
303     def get_exe_bytes (self):
304         from distutils.msvccompiler import get_build_version
305         # If a target-version other than the current version has been
306         # specified, then using the MSVC version from *this* build is no good.
307         # Without actually finding and executing the target version and parsing
308         # its sys.version, we just hard-code our knowledge of old versions.
309         # NOTE: Possible alternative is to allow "--target-version" to
310         # specify a Python executable rather than a simple version string.
311         # We can then execute this program to obtain any info we need, such
312         # as the real sys.version string for the build.
313         cur_version = get_python_version()
314         if self.target_version and self.target_version != cur_version:
315             if self.target_version < "2.3":
316                 raise NotImplementedError
317             elif self.target_version == "2.3":
318                bv = "6"
319             elif self.target_version in ("2.4", "2.5"):
320                bv = "7.1"
321             elif self.target_version in ("2.6", "2.7"):
322                 bv = "9.0"
323             else:
324                 raise NotImplementedError
325         else:
326             # for current version - use authoritative check.
327             bv = get_build_version()
328
329         # wininst-x.y.exe is in the same directory as this file
330         directory = os.path.dirname(__file__)
331         # we must use a wininst-x.y.exe built with the same C compiler
332         # used for python.  XXX What about mingw, borland, and so on?
333
334         # The uninstallers need to be available in $PYEXT_CROSS/uninst/*.exe
335         # Use http://oss.itsystementwicklung.de/hg/pyext_cross_linux_to_win32/
336         # and copy it alongside your pysqlite checkout.
337
338         filename = os.path.join(directory, os.path.join(os.environ["PYEXT_CROSS"], "uninst", "wininst-%s.exe" % bv))
339         return open(filename, "rb").read()
340 # class bdist_wininst