| #! /usr/bin/env python |
| |
| """Freeze a Python script into a binary. |
| |
| usage: freeze [options...] script [module]... |
| |
| Options: |
| -p prefix: This is the prefix used when you ran ``make install'' |
| in the Python build directory. |
| (If you never ran this, freeze won't work.) |
| The default is whatever sys.prefix evaluates to. |
| It can also be the top directory of the Python source |
| tree; then -P must point to the build tree. |
| |
| -P exec_prefix: Like -p but this is the 'exec_prefix', used to |
| install objects etc. The default is whatever sys.exec_prefix |
| evaluates to, or the -p argument if given. |
| If -p points to the Python source tree, -P must point |
| to the build tree, if different. |
| |
| -e extension: A directory containing additional .o files that |
| may be used to resolve modules. This directory |
| should also have a Setup file describing the .o files. |
| On Windows, the name of a .INI file describing one |
| or more extensions is passed. |
| More than one -e option may be given. |
| |
| -o dir: Directory where the output files are created; default '.'. |
| |
| -m: Additional arguments are module names instead of filenames. |
| |
| -a package=dir: Additional directories to be added to the package's |
| __path__. Used to simulate directories added by the |
| package at runtime (eg, by OpenGL and win32com). |
| More than one -a option may be given for each package. |
| |
| -l file: Pass the file to the linker (windows only) |
| |
| -d: Debugging mode for the module finder. |
| |
| -q: Make the module finder totally quiet. |
| |
| -h: Print this help message. |
| |
| -x module Exclude the specified module. It will still be imported |
| by the frozen binary if it exists on the host system. |
| |
| -X module Like -x, except the module can never be imported by |
| the frozen binary. |
| |
| -E: Freeze will fail if any modules can't be found (that |
| were not excluded using -x or -X). |
| |
| -i filename: Include a file with additional command line options. Used |
| to prevent command lines growing beyond the capabilities of |
| the shell/OS. All arguments specified in filename |
| are read and the -i option replaced with the parsed |
| params (note - quoting args in this file is NOT supported) |
| |
| -s subsystem: Specify the subsystem (For Windows only.); |
| 'console' (default), 'windows', 'service' or 'com_dll' |
| |
| -w: Toggle Windows (NT or 95) behavior. |
| (For debugging only -- on a win32 platform, win32 behavior |
| is automatic.) |
| |
| -r prefix=f: Replace path prefix. |
| Replace prefix with f in the source path references |
| contained in the resulting binary. |
| |
| Arguments: |
| |
| script: The Python script to be executed by the resulting binary. |
| |
| module ...: Additional Python modules (referenced by pathname) |
| that will be included in the resulting binary. These |
| may be .py or .pyc files. If -m is specified, these are |
| module names that are search in the path instead. |
| |
| NOTES: |
| |
| In order to use freeze successfully, you must have built Python and |
| installed it ("make install"). |
| |
| The script should not use modules provided only as shared libraries; |
| if it does, the resulting binary is not self-contained. |
| """ |
| |
| |
| # Import standard modules |
| |
| import modulefinder |
| import getopt |
| import os |
| import sys |
| |
| |
| # Import the freeze-private modules |
| |
| import checkextensions |
| import makeconfig |
| import makefreeze |
| import makemakefile |
| import parsesetup |
| import bkfile |
| |
| |
| # Main program |
| |
| def main(): |
| # overridable context |
| prefix = None # settable with -p option |
| exec_prefix = None # settable with -P option |
| extensions = [] |
| exclude = [] # settable with -x option |
| addn_link = [] # settable with -l, but only honored under Windows. |
| path = sys.path[:] |
| modargs = 0 |
| debug = 1 |
| odir = '' |
| win = sys.platform[:3] == 'win' |
| replace_paths = [] # settable with -r option |
| error_if_any_missing = 0 |
| |
| # default the exclude list for each platform |
| if win: exclude = exclude + [ |
| 'dos', 'dospath', 'mac', 'macpath', 'macfs', 'MACFS', 'posix', |
| 'os2', 'ce', 'riscos', 'riscosenviron', 'riscospath', |
| ] |
| |
| fail_import = exclude[:] |
| |
| # output files |
| frozen_c = 'frozen.c' |
| config_c = 'config.c' |
| target = 'a.out' # normally derived from script name |
| makefile = 'Makefile' |
| subsystem = 'console' |
| |
| # parse command line by first replacing any "-i" options with the |
| # file contents. |
| pos = 1 |
| while pos < len(sys.argv)-1: |
| # last option can not be "-i", so this ensures "pos+1" is in range! |
| if sys.argv[pos] == '-i': |
| try: |
| options = open(sys.argv[pos+1]).read().split() |
| except IOError, why: |
| usage("File name '%s' specified with the -i option " |
| "can not be read - %s" % (sys.argv[pos+1], why) ) |
| # Replace the '-i' and the filename with the read params. |
| sys.argv[pos:pos+2] = options |
| pos = pos + len(options) - 1 # Skip the name and the included args. |
| pos = pos + 1 |
| |
| # Now parse the command line with the extras inserted. |
| try: |
| opts, args = getopt.getopt(sys.argv[1:], 'r:a:dEe:hmo:p:P:qs:wX:x:l:') |
| except getopt.error, msg: |
| usage('getopt error: ' + str(msg)) |
| |
| # process option arguments |
| for o, a in opts: |
| if o == '-h': |
| print __doc__ |
| return |
| if o == '-d': |
| debug = debug + 1 |
| if o == '-e': |
| extensions.append(a) |
| if o == '-m': |
| modargs = 1 |
| if o == '-o': |
| odir = a |
| if o == '-p': |
| prefix = a |
| if o == '-P': |
| exec_prefix = a |
| if o == '-q': |
| debug = 0 |
| if o == '-w': |
| win = not win |
| if o == '-s': |
| if not win: |
| usage("-s subsystem option only on Windows") |
| subsystem = a |
| if o == '-x': |
| exclude.append(a) |
| if o == '-X': |
| exclude.append(a) |
| fail_import.append(a) |
| if o == '-E': |
| error_if_any_missing = 1 |
| if o == '-l': |
| addn_link.append(a) |
| if o == '-a': |
| apply(modulefinder.AddPackagePath, tuple(a.split("=", 2))) |
| if o == '-r': |
| f,r = a.split("=", 2) |
| replace_paths.append( (f,r) ) |
| |
| # modules that are imported by the Python runtime |
| implicits = [] |
| for module in ('site', 'warnings',): |
| if module not in exclude: |
| implicits.append(module) |
| |
| # default prefix and exec_prefix |
| if not exec_prefix: |
| if prefix: |
| exec_prefix = prefix |
| else: |
| exec_prefix = sys.exec_prefix |
| if not prefix: |
| prefix = sys.prefix |
| |
| # determine whether -p points to the Python source tree |
| ishome = os.path.exists(os.path.join(prefix, 'Python', 'ceval.c')) |
| |
| # locations derived from options |
| version = sys.version[:3] |
| if win: |
| extensions_c = 'frozen_extensions.c' |
| if ishome: |
| print "(Using Python source directory)" |
| binlib = exec_prefix |
| incldir = os.path.join(prefix, 'Include') |
| config_h_dir = exec_prefix |
| config_c_in = os.path.join(prefix, 'Modules', 'config.c.in') |
| frozenmain_c = os.path.join(prefix, 'Python', 'frozenmain.c') |
| makefile_in = os.path.join(exec_prefix, 'Makefile') |
| if win: |
| frozendllmain_c = os.path.join(exec_prefix, 'Pc\\frozen_dllmain.c') |
| else: |
| binlib = os.path.join(exec_prefix, |
| 'lib', 'python%s' % version, 'config') |
| incldir = os.path.join(prefix, 'include', 'python%s' % version) |
| config_h_dir = os.path.join(exec_prefix, 'include', |
| 'python%s' % version) |
| config_c_in = os.path.join(binlib, 'config.c.in') |
| frozenmain_c = os.path.join(binlib, 'frozenmain.c') |
| makefile_in = os.path.join(binlib, 'Makefile') |
| frozendllmain_c = os.path.join(binlib, 'frozen_dllmain.c') |
| supp_sources = [] |
| defines = [] |
| includes = ['-I' + incldir, '-I' + config_h_dir] |
| |
| # sanity check of directories and files |
| check_dirs = [prefix, exec_prefix, binlib, incldir] |
| if not win: |
| # These are not directories on Windows. |
| check_dirs = check_dirs + extensions |
| for dir in check_dirs: |
| if not os.path.exists(dir): |
| usage('needed directory %s not found' % dir) |
| if not os.path.isdir(dir): |
| usage('%s: not a directory' % dir) |
| if win: |
| files = supp_sources + extensions # extensions are files on Windows. |
| else: |
| files = [config_c_in, makefile_in] + supp_sources |
| for file in supp_sources: |
| if not os.path.exists(file): |
| usage('needed file %s not found' % file) |
| if not os.path.isfile(file): |
| usage('%s: not a plain file' % file) |
| if not win: |
| for dir in extensions: |
| setup = os.path.join(dir, 'Setup') |
| if not os.path.exists(setup): |
| usage('needed file %s not found' % setup) |
| if not os.path.isfile(setup): |
| usage('%s: not a plain file' % setup) |
| |
| # check that enough arguments are passed |
| if not args: |
| usage('at least one filename argument required') |
| |
| # check that file arguments exist |
| for arg in args: |
| if arg == '-m': |
| break |
| # if user specified -m on the command line before _any_ |
| # file names, then nothing should be checked (as the |
| # very first file should be a module name) |
| if modargs: |
| break |
| if not os.path.exists(arg): |
| usage('argument %s not found' % arg) |
| if not os.path.isfile(arg): |
| usage('%s: not a plain file' % arg) |
| |
| # process non-option arguments |
| scriptfile = args[0] |
| modules = args[1:] |
| |
| # derive target name from script name |
| base = os.path.basename(scriptfile) |
| base, ext = os.path.splitext(base) |
| if base: |
| if base != scriptfile: |
| target = base |
| else: |
| target = base + '.bin' |
| |
| # handle -o option |
| base_frozen_c = frozen_c |
| base_config_c = config_c |
| base_target = target |
| if odir and not os.path.isdir(odir): |
| try: |
| os.mkdir(odir) |
| print "Created output directory", odir |
| except os.error, msg: |
| usage('%s: mkdir failed (%s)' % (odir, str(msg))) |
| base = '' |
| if odir: |
| base = os.path.join(odir, '') |
| frozen_c = os.path.join(odir, frozen_c) |
| config_c = os.path.join(odir, config_c) |
| target = os.path.join(odir, target) |
| makefile = os.path.join(odir, makefile) |
| if win: extensions_c = os.path.join(odir, extensions_c) |
| |
| # Handle special entry point requirements |
| # (on Windows, some frozen programs do not use __main__, but |
| # import the module directly. Eg, DLLs, Services, etc |
| custom_entry_point = None # Currently only used on Windows |
| python_entry_is_main = 1 # Is the entry point called __main__? |
| # handle -s option on Windows |
| if win: |
| import winmakemakefile |
| try: |
| custom_entry_point, python_entry_is_main = \ |
| winmakemakefile.get_custom_entry_point(subsystem) |
| except ValueError, why: |
| usage(why) |
| |
| |
| # Actual work starts here... |
| |
| # collect all modules of the program |
| dir = os.path.dirname(scriptfile) |
| path[0] = dir |
| mf = modulefinder.ModuleFinder(path, debug, exclude, replace_paths) |
| |
| if win and subsystem=='service': |
| # If a Windows service, then add the "built-in" module. |
| mod = mf.add_module("servicemanager") |
| mod.__file__="dummy.pyd" # really built-in to the resulting EXE |
| |
| for mod in implicits: |
| mf.import_hook(mod) |
| for mod in modules: |
| if mod == '-m': |
| modargs = 1 |
| continue |
| if modargs: |
| if mod[-2:] == '.*': |
| mf.import_hook(mod[:-2], None, ["*"]) |
| else: |
| mf.import_hook(mod) |
| else: |
| mf.load_file(mod) |
| |
| # Add the main script as either __main__, or the actual module name. |
| if python_entry_is_main: |
| mf.run_script(scriptfile) |
| else: |
| mf.load_file(scriptfile) |
| |
| if debug > 0: |
| mf.report() |
| print |
| dict = mf.modules |
| |
| if error_if_any_missing: |
| missing = mf.any_missing() |
| if missing: |
| sys.exit("There are some missing modules: %r" % missing) |
| |
| # generate output for frozen modules |
| files = makefreeze.makefreeze(base, dict, debug, custom_entry_point, |
| fail_import) |
| |
| # look for unfrozen modules (builtin and of unknown origin) |
| builtins = [] |
| unknown = [] |
| mods = dict.keys() |
| mods.sort() |
| for mod in mods: |
| if dict[mod].__code__: |
| continue |
| if not dict[mod].__file__: |
| builtins.append(mod) |
| else: |
| unknown.append(mod) |
| |
| # search for unknown modules in extensions directories (not on Windows) |
| addfiles = [] |
| frozen_extensions = [] # Windows list of modules. |
| if unknown or (not win and builtins): |
| if not win: |
| addfiles, addmods = \ |
| checkextensions.checkextensions(unknown+builtins, |
| extensions) |
| for mod in addmods: |
| if mod in unknown: |
| unknown.remove(mod) |
| builtins.append(mod) |
| else: |
| # Do the windows thang... |
| import checkextensions_win32 |
| # Get a list of CExtension instances, each describing a module |
| # (including its source files) |
| frozen_extensions = checkextensions_win32.checkextensions( |
| unknown, extensions, prefix) |
| for mod in frozen_extensions: |
| unknown.remove(mod.name) |
| |
| # report unknown modules |
| if unknown: |
| sys.stderr.write('Warning: unknown modules remain: %s\n' % |
| ' '.join(unknown)) |
| |
| # windows gets different treatment |
| if win: |
| # Taking a shortcut here... |
| import winmakemakefile, checkextensions_win32 |
| checkextensions_win32.write_extension_table(extensions_c, |
| frozen_extensions) |
| # Create a module definition for the bootstrap C code. |
| xtras = [frozenmain_c, os.path.basename(frozen_c), |
| frozendllmain_c, os.path.basename(extensions_c)] + files |
| maindefn = checkextensions_win32.CExtension( '__main__', xtras ) |
| frozen_extensions.append( maindefn ) |
| outfp = open(makefile, 'w') |
| try: |
| winmakemakefile.makemakefile(outfp, |
| locals(), |
| frozen_extensions, |
| os.path.basename(target)) |
| finally: |
| outfp.close() |
| return |
| |
| # generate config.c and Makefile |
| builtins.sort() |
| infp = open(config_c_in) |
| outfp = bkfile.open(config_c, 'w') |
| try: |
| makeconfig.makeconfig(infp, outfp, builtins) |
| finally: |
| outfp.close() |
| infp.close() |
| |
| cflags = ['$(OPT)'] |
| cppflags = defines + includes |
| libs = [os.path.join(binlib, 'libpython$(VERSION).a')] |
| |
| somevars = {} |
| if os.path.exists(makefile_in): |
| makevars = parsesetup.getmakevars(makefile_in) |
| for key in makevars.keys(): |
| somevars[key] = makevars[key] |
| |
| somevars['CFLAGS'] = ' '.join(cflags) # override |
| somevars['CPPFLAGS'] = ' '.join(cppflags) # override |
| files = [base_config_c, base_frozen_c] + \ |
| files + supp_sources + addfiles + libs + \ |
| ['$(MODLIBS)', '$(LIBS)', '$(SYSLIBS)'] |
| |
| outfp = bkfile.open(makefile, 'w') |
| try: |
| makemakefile.makemakefile(outfp, somevars, files, base_target) |
| finally: |
| outfp.close() |
| |
| # Done! |
| |
| if odir: |
| print 'Now run "make" in', odir, |
| print 'to build the target:', base_target |
| else: |
| print 'Now run "make" to build the target:', base_target |
| |
| |
| # Print usage message and exit |
| |
| def usage(msg): |
| sys.stdout = sys.stderr |
| print "Error:", msg |
| print "Use ``%s -h'' for help" % sys.argv[0] |
| sys.exit(2) |
| |
| |
| main() |
