| 1 | #! /usr/bin/env python
|
|---|
| 2 |
|
|---|
| 3 | """Freeze a Python script into a binary.
|
|---|
| 4 |
|
|---|
| 5 | usage: freeze [options...] script [module]...
|
|---|
| 6 |
|
|---|
| 7 | Options:
|
|---|
| 8 | -p prefix: This is the prefix used when you ran ``make install''
|
|---|
| 9 | in the Python build directory.
|
|---|
| 10 | (If you never ran this, freeze won't work.)
|
|---|
| 11 | The default is whatever sys.prefix evaluates to.
|
|---|
| 12 | It can also be the top directory of the Python source
|
|---|
| 13 | tree; then -P must point to the build tree.
|
|---|
| 14 |
|
|---|
| 15 | -P exec_prefix: Like -p but this is the 'exec_prefix', used to
|
|---|
| 16 | install objects etc. The default is whatever sys.exec_prefix
|
|---|
| 17 | evaluates to, or the -p argument if given.
|
|---|
| 18 | If -p points to the Python source tree, -P must point
|
|---|
| 19 | to the build tree, if different.
|
|---|
| 20 |
|
|---|
| 21 | -e extension: A directory containing additional .o files that
|
|---|
| 22 | may be used to resolve modules. This directory
|
|---|
| 23 | should also have a Setup file describing the .o files.
|
|---|
| 24 | On Windows, the name of a .INI file describing one
|
|---|
| 25 | or more extensions is passed.
|
|---|
| 26 | More than one -e option may be given.
|
|---|
| 27 |
|
|---|
| 28 | -o dir: Directory where the output files are created; default '.'.
|
|---|
| 29 |
|
|---|
| 30 | -m: Additional arguments are module names instead of filenames.
|
|---|
| 31 |
|
|---|
| 32 | -a package=dir: Additional directories to be added to the package's
|
|---|
| 33 | __path__. Used to simulate directories added by the
|
|---|
| 34 | package at runtime (eg, by OpenGL and win32com).
|
|---|
| 35 | More than one -a option may be given for each package.
|
|---|
| 36 |
|
|---|
| 37 | -l file: Pass the file to the linker (windows only)
|
|---|
| 38 |
|
|---|
| 39 | -d: Debugging mode for the module finder.
|
|---|
| 40 |
|
|---|
| 41 | -q: Make the module finder totally quiet.
|
|---|
| 42 |
|
|---|
| 43 | -h: Print this help message.
|
|---|
| 44 |
|
|---|
| 45 | -x module Exclude the specified module. It will still be imported
|
|---|
| 46 | by the frozen binary if it exists on the host system.
|
|---|
| 47 |
|
|---|
| 48 | -X module Like -x, except the module can never be imported by
|
|---|
| 49 | the frozen binary.
|
|---|
| 50 |
|
|---|
| 51 | -E: Freeze will fail if any modules can't be found (that
|
|---|
| 52 | were not excluded using -x or -X).
|
|---|
| 53 |
|
|---|
| 54 | -i filename: Include a file with additional command line options. Used
|
|---|
| 55 | to prevent command lines growing beyond the capabilities of
|
|---|
| 56 | the shell/OS. All arguments specified in filename
|
|---|
| 57 | are read and the -i option replaced with the parsed
|
|---|
| 58 | params (note - quoting args in this file is NOT supported)
|
|---|
| 59 |
|
|---|
| 60 | -s subsystem: Specify the subsystem (For Windows only.);
|
|---|
| 61 | 'console' (default), 'windows', 'service' or 'com_dll'
|
|---|
| 62 |
|
|---|
| 63 | -w: Toggle Windows (NT or 95) behavior.
|
|---|
| 64 | (For debugging only -- on a win32 platform, win32 behavior
|
|---|
| 65 | is automatic.)
|
|---|
| 66 |
|
|---|
| 67 | -r prefix=f: Replace path prefix.
|
|---|
| 68 | Replace prefix with f in the source path references
|
|---|
| 69 | contained in the resulting binary.
|
|---|
| 70 |
|
|---|
| 71 | Arguments:
|
|---|
| 72 |
|
|---|
| 73 | script: The Python script to be executed by the resulting binary.
|
|---|
| 74 |
|
|---|
| 75 | module ...: Additional Python modules (referenced by pathname)
|
|---|
| 76 | that will be included in the resulting binary. These
|
|---|
| 77 | may be .py or .pyc files. If -m is specified, these are
|
|---|
| 78 | module names that are search in the path instead.
|
|---|
| 79 |
|
|---|
| 80 | NOTES:
|
|---|
| 81 |
|
|---|
| 82 | In order to use freeze successfully, you must have built Python and
|
|---|
| 83 | installed it ("make install").
|
|---|
| 84 |
|
|---|
| 85 | The script should not use modules provided only as shared libraries;
|
|---|
| 86 | if it does, the resulting binary is not self-contained.
|
|---|
| 87 | """
|
|---|
| 88 |
|
|---|
| 89 |
|
|---|
| 90 | # Import standard modules
|
|---|
| 91 |
|
|---|
| 92 | import modulefinder
|
|---|
| 93 | import getopt
|
|---|
| 94 | import os
|
|---|
| 95 | import sys
|
|---|
| 96 |
|
|---|
| 97 |
|
|---|
| 98 | # Import the freeze-private modules
|
|---|
| 99 |
|
|---|
| 100 | import checkextensions
|
|---|
| 101 | import makeconfig
|
|---|
| 102 | import makefreeze
|
|---|
| 103 | import makemakefile
|
|---|
| 104 | import parsesetup
|
|---|
| 105 | import bkfile
|
|---|
| 106 |
|
|---|
| 107 |
|
|---|
| 108 | # Main program
|
|---|
| 109 |
|
|---|
| 110 | def main():
|
|---|
| 111 | # overridable context
|
|---|
| 112 | prefix = None # settable with -p option
|
|---|
| 113 | exec_prefix = None # settable with -P option
|
|---|
| 114 | extensions = []
|
|---|
| 115 | exclude = [] # settable with -x option
|
|---|
| 116 | addn_link = [] # settable with -l, but only honored under Windows.
|
|---|
| 117 | path = sys.path[:]
|
|---|
| 118 | modargs = 0
|
|---|
| 119 | debug = 1
|
|---|
| 120 | odir = ''
|
|---|
| 121 | win = sys.platform[:3] == 'win'
|
|---|
| 122 | replace_paths = [] # settable with -r option
|
|---|
| 123 | error_if_any_missing = 0
|
|---|
| 124 |
|
|---|
| 125 | # default the exclude list for each platform
|
|---|
| 126 | if win: exclude = exclude + [
|
|---|
| 127 | 'dos', 'dospath', 'mac', 'macpath', 'macfs', 'MACFS', 'posix',
|
|---|
| 128 | 'os2', 'ce', 'riscos', 'riscosenviron', 'riscospath',
|
|---|
| 129 | ]
|
|---|
| 130 |
|
|---|
| 131 | fail_import = exclude[:]
|
|---|
| 132 |
|
|---|
| 133 | # output files
|
|---|
| 134 | frozen_c = 'frozen.c'
|
|---|
| 135 | config_c = 'config.c'
|
|---|
| 136 | target = 'a.out' # normally derived from script name
|
|---|
| 137 | makefile = 'Makefile'
|
|---|
| 138 | subsystem = 'console'
|
|---|
| 139 |
|
|---|
| 140 | # parse command line by first replacing any "-i" options with the
|
|---|
| 141 | # file contents.
|
|---|
| 142 | pos = 1
|
|---|
| 143 | while pos < len(sys.argv)-1:
|
|---|
| 144 | # last option can not be "-i", so this ensures "pos+1" is in range!
|
|---|
| 145 | if sys.argv[pos] == '-i':
|
|---|
| 146 | try:
|
|---|
| 147 | options = open(sys.argv[pos+1]).read().split()
|
|---|
| 148 | except IOError, why:
|
|---|
| 149 | usage("File name '%s' specified with the -i option "
|
|---|
| 150 | "can not be read - %s" % (sys.argv[pos+1], why) )
|
|---|
| 151 | # Replace the '-i' and the filename with the read params.
|
|---|
| 152 | sys.argv[pos:pos+2] = options
|
|---|
| 153 | pos = pos + len(options) - 1 # Skip the name and the included args.
|
|---|
| 154 | pos = pos + 1
|
|---|
| 155 |
|
|---|
| 156 | # Now parse the command line with the extras inserted.
|
|---|
| 157 | try:
|
|---|
| 158 | opts, args = getopt.getopt(sys.argv[1:], 'r:a:dEe:hmo:p:P:qs:wX:x:l:')
|
|---|
| 159 | except getopt.error, msg:
|
|---|
| 160 | usage('getopt error: ' + str(msg))
|
|---|
| 161 |
|
|---|
| 162 | # proces option arguments
|
|---|
| 163 | for o, a in opts:
|
|---|
| 164 | if o == '-h':
|
|---|
| 165 | print __doc__
|
|---|
| 166 | return
|
|---|
| 167 | if o == '-d':
|
|---|
| 168 | debug = debug + 1
|
|---|
| 169 | if o == '-e':
|
|---|
| 170 | extensions.append(a)
|
|---|
| 171 | if o == '-m':
|
|---|
| 172 | modargs = 1
|
|---|
| 173 | if o == '-o':
|
|---|
| 174 | odir = a
|
|---|
| 175 | if o == '-p':
|
|---|
| 176 | prefix = a
|
|---|
| 177 | if o == '-P':
|
|---|
| 178 | exec_prefix = a
|
|---|
| 179 | if o == '-q':
|
|---|
| 180 | debug = 0
|
|---|
| 181 | if o == '-w':
|
|---|
| 182 | win = not win
|
|---|
| 183 | if o == '-s':
|
|---|
| 184 | if not win:
|
|---|
| 185 | usage("-s subsystem option only on Windows")
|
|---|
| 186 | subsystem = a
|
|---|
| 187 | if o == '-x':
|
|---|
| 188 | exclude.append(a)
|
|---|
| 189 | if o == '-X':
|
|---|
| 190 | exclude.append(a)
|
|---|
| 191 | fail_import.append(a)
|
|---|
| 192 | if o == '-E':
|
|---|
| 193 | error_if_any_missing = 1
|
|---|
| 194 | if o == '-l':
|
|---|
| 195 | addn_link.append(a)
|
|---|
| 196 | if o == '-a':
|
|---|
| 197 | apply(modulefinder.AddPackagePath, tuple(a.split("=", 2)))
|
|---|
| 198 | if o == '-r':
|
|---|
| 199 | f,r = a.split("=", 2)
|
|---|
| 200 | replace_paths.append( (f,r) )
|
|---|
| 201 |
|
|---|
| 202 | # modules that are imported by the Python runtime
|
|---|
| 203 | implicits = []
|
|---|
| 204 | for module in ('site', 'warnings',):
|
|---|
| 205 | if module not in exclude:
|
|---|
| 206 | implicits.append(module)
|
|---|
| 207 |
|
|---|
| 208 | # default prefix and exec_prefix
|
|---|
| 209 | if not exec_prefix:
|
|---|
| 210 | if prefix:
|
|---|
| 211 | exec_prefix = prefix
|
|---|
| 212 | else:
|
|---|
| 213 | exec_prefix = sys.exec_prefix
|
|---|
| 214 | if not prefix:
|
|---|
| 215 | prefix = sys.prefix
|
|---|
| 216 |
|
|---|
| 217 | # determine whether -p points to the Python source tree
|
|---|
| 218 | ishome = os.path.exists(os.path.join(prefix, 'Python', 'ceval.c'))
|
|---|
| 219 |
|
|---|
| 220 | # locations derived from options
|
|---|
| 221 | version = sys.version[:3]
|
|---|
| 222 | if win:
|
|---|
| 223 | extensions_c = 'frozen_extensions.c'
|
|---|
| 224 | if ishome:
|
|---|
| 225 | print "(Using Python source directory)"
|
|---|
| 226 | binlib = exec_prefix
|
|---|
| 227 | incldir = os.path.join(prefix, 'Include')
|
|---|
| 228 | config_h_dir = exec_prefix
|
|---|
| 229 | config_c_in = os.path.join(prefix, 'Modules', 'config.c.in')
|
|---|
| 230 | frozenmain_c = os.path.join(prefix, 'Python', 'frozenmain.c')
|
|---|
| 231 | makefile_in = os.path.join(exec_prefix, 'Makefile')
|
|---|
| 232 | if win:
|
|---|
| 233 | frozendllmain_c = os.path.join(exec_prefix, 'Pc\\frozen_dllmain.c')
|
|---|
| 234 | else:
|
|---|
| 235 | binlib = os.path.join(exec_prefix,
|
|---|
| 236 | 'lib', 'python%s' % version, 'config')
|
|---|
| 237 | incldir = os.path.join(prefix, 'include', 'python%s' % version)
|
|---|
| 238 | config_h_dir = os.path.join(exec_prefix, 'include',
|
|---|
| 239 | 'python%s' % version)
|
|---|
| 240 | config_c_in = os.path.join(binlib, 'config.c.in')
|
|---|
| 241 | frozenmain_c = os.path.join(binlib, 'frozenmain.c')
|
|---|
| 242 | makefile_in = os.path.join(binlib, 'Makefile')
|
|---|
| 243 | frozendllmain_c = os.path.join(binlib, 'frozen_dllmain.c')
|
|---|
| 244 | supp_sources = []
|
|---|
| 245 | defines = []
|
|---|
| 246 | includes = ['-I' + incldir, '-I' + config_h_dir]
|
|---|
| 247 |
|
|---|
| 248 | # sanity check of directories and files
|
|---|
| 249 | check_dirs = [prefix, exec_prefix, binlib, incldir]
|
|---|
| 250 | if not win:
|
|---|
| 251 | # These are not directories on Windows.
|
|---|
| 252 | check_dirs = check_dirs + extensions
|
|---|
| 253 | for dir in check_dirs:
|
|---|
| 254 | if not os.path.exists(dir):
|
|---|
| 255 | usage('needed directory %s not found' % dir)
|
|---|
| 256 | if not os.path.isdir(dir):
|
|---|
| 257 | usage('%s: not a directory' % dir)
|
|---|
| 258 | if win:
|
|---|
| 259 | files = supp_sources + extensions # extensions are files on Windows.
|
|---|
| 260 | else:
|
|---|
| 261 | files = [config_c_in, makefile_in] + supp_sources
|
|---|
| 262 | for file in supp_sources:
|
|---|
| 263 | if not os.path.exists(file):
|
|---|
| 264 | usage('needed file %s not found' % file)
|
|---|
| 265 | if not os.path.isfile(file):
|
|---|
| 266 | usage('%s: not a plain file' % file)
|
|---|
| 267 | if not win:
|
|---|
| 268 | for dir in extensions:
|
|---|
| 269 | setup = os.path.join(dir, 'Setup')
|
|---|
| 270 | if not os.path.exists(setup):
|
|---|
| 271 | usage('needed file %s not found' % setup)
|
|---|
| 272 | if not os.path.isfile(setup):
|
|---|
| 273 | usage('%s: not a plain file' % setup)
|
|---|
| 274 |
|
|---|
| 275 | # check that enough arguments are passed
|
|---|
| 276 | if not args:
|
|---|
| 277 | usage('at least one filename argument required')
|
|---|
| 278 |
|
|---|
| 279 | # check that file arguments exist
|
|---|
| 280 | for arg in args:
|
|---|
| 281 | if arg == '-m':
|
|---|
| 282 | break
|
|---|
| 283 | # if user specified -m on the command line before _any_
|
|---|
| 284 | # file names, then nothing should be checked (as the
|
|---|
| 285 | # very first file should be a module name)
|
|---|
| 286 | if modargs:
|
|---|
| 287 | break
|
|---|
| 288 | if not os.path.exists(arg):
|
|---|
| 289 | usage('argument %s not found' % arg)
|
|---|
| 290 | if not os.path.isfile(arg):
|
|---|
| 291 | usage('%s: not a plain file' % arg)
|
|---|
| 292 |
|
|---|
| 293 | # process non-option arguments
|
|---|
| 294 | scriptfile = args[0]
|
|---|
| 295 | modules = args[1:]
|
|---|
| 296 |
|
|---|
| 297 | # derive target name from script name
|
|---|
| 298 | base = os.path.basename(scriptfile)
|
|---|
| 299 | base, ext = os.path.splitext(base)
|
|---|
| 300 | if base:
|
|---|
| 301 | if base != scriptfile:
|
|---|
| 302 | target = base
|
|---|
| 303 | else:
|
|---|
| 304 | target = base + '.bin'
|
|---|
| 305 |
|
|---|
| 306 | # handle -o option
|
|---|
| 307 | base_frozen_c = frozen_c
|
|---|
| 308 | base_config_c = config_c
|
|---|
| 309 | base_target = target
|
|---|
| 310 | if odir and not os.path.isdir(odir):
|
|---|
| 311 | try:
|
|---|
| 312 | os.mkdir(odir)
|
|---|
| 313 | print "Created output directory", odir
|
|---|
| 314 | except os.error, msg:
|
|---|
| 315 | usage('%s: mkdir failed (%s)' % (odir, str(msg)))
|
|---|
| 316 | base = ''
|
|---|
| 317 | if odir:
|
|---|
| 318 | base = os.path.join(odir, '')
|
|---|
| 319 | frozen_c = os.path.join(odir, frozen_c)
|
|---|
| 320 | config_c = os.path.join(odir, config_c)
|
|---|
| 321 | target = os.path.join(odir, target)
|
|---|
| 322 | makefile = os.path.join(odir, makefile)
|
|---|
| 323 | if win: extensions_c = os.path.join(odir, extensions_c)
|
|---|
| 324 |
|
|---|
| 325 | # Handle special entry point requirements
|
|---|
| 326 | # (on Windows, some frozen programs do not use __main__, but
|
|---|
| 327 | # import the module directly. Eg, DLLs, Services, etc
|
|---|
| 328 | custom_entry_point = None # Currently only used on Windows
|
|---|
| 329 | python_entry_is_main = 1 # Is the entry point called __main__?
|
|---|
| 330 | # handle -s option on Windows
|
|---|
| 331 | if win:
|
|---|
| 332 | import winmakemakefile
|
|---|
| 333 | try:
|
|---|
| 334 | custom_entry_point, python_entry_is_main = \
|
|---|
| 335 | winmakemakefile.get_custom_entry_point(subsystem)
|
|---|
| 336 | except ValueError, why:
|
|---|
| 337 | usage(why)
|
|---|
| 338 |
|
|---|
| 339 |
|
|---|
| 340 | # Actual work starts here...
|
|---|
| 341 |
|
|---|
| 342 | # collect all modules of the program
|
|---|
| 343 | dir = os.path.dirname(scriptfile)
|
|---|
| 344 | path[0] = dir
|
|---|
| 345 | mf = modulefinder.ModuleFinder(path, debug, exclude, replace_paths)
|
|---|
| 346 |
|
|---|
| 347 | if win and subsystem=='service':
|
|---|
| 348 | # If a Windows service, then add the "built-in" module.
|
|---|
| 349 | mod = mf.add_module("servicemanager")
|
|---|
| 350 | mod.__file__="dummy.pyd" # really built-in to the resulting EXE
|
|---|
| 351 |
|
|---|
| 352 | for mod in implicits:
|
|---|
| 353 | mf.import_hook(mod)
|
|---|
| 354 | for mod in modules:
|
|---|
| 355 | if mod == '-m':
|
|---|
| 356 | modargs = 1
|
|---|
| 357 | continue
|
|---|
| 358 | if modargs:
|
|---|
| 359 | if mod[-2:] == '.*':
|
|---|
| 360 | mf.import_hook(mod[:-2], None, ["*"])
|
|---|
| 361 | else:
|
|---|
| 362 | mf.import_hook(mod)
|
|---|
| 363 | else:
|
|---|
| 364 | mf.load_file(mod)
|
|---|
| 365 |
|
|---|
| 366 | # Add the main script as either __main__, or the actual module name.
|
|---|
| 367 | if python_entry_is_main:
|
|---|
| 368 | mf.run_script(scriptfile)
|
|---|
| 369 | else:
|
|---|
| 370 | mf.load_file(scriptfile)
|
|---|
| 371 |
|
|---|
| 372 | if debug > 0:
|
|---|
| 373 | mf.report()
|
|---|
| 374 | print
|
|---|
| 375 | dict = mf.modules
|
|---|
| 376 |
|
|---|
| 377 | if error_if_any_missing:
|
|---|
| 378 | missing = mf.any_missing()
|
|---|
| 379 | if missing:
|
|---|
| 380 | sys.exit("There are some missing modules: %r" % missing)
|
|---|
| 381 |
|
|---|
| 382 | # generate output for frozen modules
|
|---|
| 383 | files = makefreeze.makefreeze(base, dict, debug, custom_entry_point,
|
|---|
| 384 | fail_import)
|
|---|
| 385 |
|
|---|
| 386 | # look for unfrozen modules (builtin and of unknown origin)
|
|---|
| 387 | builtins = []
|
|---|
| 388 | unknown = []
|
|---|
| 389 | mods = dict.keys()
|
|---|
| 390 | mods.sort()
|
|---|
| 391 | for mod in mods:
|
|---|
| 392 | if dict[mod].__code__:
|
|---|
| 393 | continue
|
|---|
| 394 | if not dict[mod].__file__:
|
|---|
| 395 | builtins.append(mod)
|
|---|
| 396 | else:
|
|---|
| 397 | unknown.append(mod)
|
|---|
| 398 |
|
|---|
| 399 | # search for unknown modules in extensions directories (not on Windows)
|
|---|
| 400 | addfiles = []
|
|---|
| 401 | frozen_extensions = [] # Windows list of modules.
|
|---|
| 402 | if unknown or (not win and builtins):
|
|---|
| 403 | if not win:
|
|---|
| 404 | addfiles, addmods = \
|
|---|
| 405 | checkextensions.checkextensions(unknown+builtins,
|
|---|
| 406 | extensions)
|
|---|
| 407 | for mod in addmods:
|
|---|
| 408 | if mod in unknown:
|
|---|
| 409 | unknown.remove(mod)
|
|---|
| 410 | builtins.append(mod)
|
|---|
| 411 | else:
|
|---|
| 412 | # Do the windows thang...
|
|---|
| 413 | import checkextensions_win32
|
|---|
| 414 | # Get a list of CExtension instances, each describing a module
|
|---|
| 415 | # (including its source files)
|
|---|
| 416 | frozen_extensions = checkextensions_win32.checkextensions(
|
|---|
| 417 | unknown, extensions, prefix)
|
|---|
| 418 | for mod in frozen_extensions:
|
|---|
| 419 | unknown.remove(mod.name)
|
|---|
| 420 |
|
|---|
| 421 | # report unknown modules
|
|---|
| 422 | if unknown:
|
|---|
| 423 | sys.stderr.write('Warning: unknown modules remain: %s\n' %
|
|---|
| 424 | ' '.join(unknown))
|
|---|
| 425 |
|
|---|
| 426 | # windows gets different treatment
|
|---|
| 427 | if win:
|
|---|
| 428 | # Taking a shortcut here...
|
|---|
| 429 | import winmakemakefile, checkextensions_win32
|
|---|
| 430 | checkextensions_win32.write_extension_table(extensions_c,
|
|---|
| 431 | frozen_extensions)
|
|---|
| 432 | # Create a module definition for the bootstrap C code.
|
|---|
| 433 | xtras = [frozenmain_c, os.path.basename(frozen_c),
|
|---|
| 434 | frozendllmain_c, os.path.basename(extensions_c)] + files
|
|---|
| 435 | maindefn = checkextensions_win32.CExtension( '__main__', xtras )
|
|---|
| 436 | frozen_extensions.append( maindefn )
|
|---|
| 437 | outfp = open(makefile, 'w')
|
|---|
| 438 | try:
|
|---|
| 439 | winmakemakefile.makemakefile(outfp,
|
|---|
| 440 | locals(),
|
|---|
| 441 | frozen_extensions,
|
|---|
| 442 | os.path.basename(target))
|
|---|
| 443 | finally:
|
|---|
| 444 | outfp.close()
|
|---|
| 445 | return
|
|---|
| 446 |
|
|---|
| 447 | # generate config.c and Makefile
|
|---|
| 448 | builtins.sort()
|
|---|
| 449 | infp = open(config_c_in)
|
|---|
| 450 | outfp = bkfile.open(config_c, 'w')
|
|---|
| 451 | try:
|
|---|
| 452 | makeconfig.makeconfig(infp, outfp, builtins)
|
|---|
| 453 | finally:
|
|---|
| 454 | outfp.close()
|
|---|
| 455 | infp.close()
|
|---|
| 456 |
|
|---|
| 457 | cflags = ['$(OPT)']
|
|---|
| 458 | cppflags = defines + includes
|
|---|
| 459 | libs = [os.path.join(binlib, 'libpython$(VERSION).a')]
|
|---|
| 460 |
|
|---|
| 461 | somevars = {}
|
|---|
| 462 | if os.path.exists(makefile_in):
|
|---|
| 463 | makevars = parsesetup.getmakevars(makefile_in)
|
|---|
| 464 | for key in makevars.keys():
|
|---|
| 465 | somevars[key] = makevars[key]
|
|---|
| 466 |
|
|---|
| 467 | somevars['CFLAGS'] = ' '.join(cflags) # override
|
|---|
| 468 | somevars['CPPFLAGS'] = ' '.join(cppflags) # override
|
|---|
| 469 | files = [base_config_c, base_frozen_c] + \
|
|---|
| 470 | files + supp_sources + addfiles + libs + \
|
|---|
| 471 | ['$(MODLIBS)', '$(LIBS)', '$(SYSLIBS)']
|
|---|
| 472 |
|
|---|
| 473 | outfp = bkfile.open(makefile, 'w')
|
|---|
| 474 | try:
|
|---|
| 475 | makemakefile.makemakefile(outfp, somevars, files, base_target)
|
|---|
| 476 | finally:
|
|---|
| 477 | outfp.close()
|
|---|
| 478 |
|
|---|
| 479 | # Done!
|
|---|
| 480 |
|
|---|
| 481 | if odir:
|
|---|
| 482 | print 'Now run "make" in', odir,
|
|---|
| 483 | print 'to build the target:', base_target
|
|---|
| 484 | else:
|
|---|
| 485 | print 'Now run "make" to build the target:', base_target
|
|---|
| 486 |
|
|---|
| 487 |
|
|---|
| 488 | # Print usage message and exit
|
|---|
| 489 |
|
|---|
| 490 | def usage(msg):
|
|---|
| 491 | sys.stdout = sys.stderr
|
|---|
| 492 | print "Error:", msg
|
|---|
| 493 | print "Use ``%s -h'' for help" % sys.argv[0]
|
|---|
| 494 | sys.exit(2)
|
|---|
| 495 |
|
|---|
| 496 |
|
|---|
| 497 | main()
|
|---|
