#! /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))

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