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()