--- /dev/null
+#! /usr/local/bin/python
+
+# Given a Python script, create a binary that runs the script.
+# The binary is 100% independent of Python libraries and binaries.
+# It will not contain any Python source code -- only "compiled" Python
+# (as initialized static variables containing marshalled code objects).
+# It even does the right thing for dynamically loaded modules!
+# The module search path of the binary is set to the current directory.
+#
+# Some problems remain:
+# - You need to have the Python source tree lying around as well as
+# the various libraries used to generate the Python binary.
+# - For scripts that use many modules it generates absurdly large
+# files (frozen.c and config.o as well as the final binary),
+# and is consequently rather slow.
+#
+# Caveats:
+# - The search for modules sometimes finds modules that are never
+# actually imported since the code importing them is never executed.
+# - If an imported module isn't found, you get a warning but the
+# process of freezing continues. The binary will fail if it
+# actually tries to import one of these modules.
+# - This often happens with the module 'mac', which module 'os' tries
+# to import (to determine whether it is running on a Macintosh).
+# You can ignore the warning about this.
+# - If the program dynamically reads or generates Python code and
+# executes it, this code may reference built-in or library modules
+# that aren't present in the frozen binary, and this will fail.
+# - Your program may be using external data files, e.g. compiled
+# forms definitions (*.fd). These aren't incorporated. By default,
+# the sys.path in the resulting binary is only '.' (but you can override
+# that with the -P option).
+#
+# Usage hints:
+# - If you have a bunch of scripts that you want to freeze, instead
+# of freezing each of them separately, you might consider writing
+# a tiny main script that looks at sys.argv[0] and then imports
+# the corresponding module. You can then make links to the
+# frozen binary named after the various scripts you support.
+# Pass the additional scripts as arguments after the main script.
+# A minimal script to do this is the following.
+# import sys, posixpath
+# exec('import ' + posixpath.basename(sys.argv[0]) + '\n')
+#
+# Mods by Jack, August 94:
+# - Removed all static configuration stuff. Now, Setup and Makefile files
+# are parsed to obtain the linking info for the libraries. You have to
+# supply the -B option, though.
+# - Added -P (set sys.path) and -I/-D/-L/-l options (passed on to cc and
+# ld).
+
+import os
+import sys
+import regex
+import getopt
+import regsub
+import string
+import marshal
+
+# Exception used when scanfile fails
+NoSuchFile = 'NoSuchFile'
+
+# Global options
+builddir = '' # -B dir
+quiet = 0 # -q
+verbose = 0 # -v
+noexec = 0 # -n
+nowrite = 0 # -N
+ofile = 'a.out' # -o file
+path = '\'"."\'' # -P path
+
+cc_options = [] # Collects cc options
+ld_options = [] # Collects ld options
+module_libraries = {} # ld options for each module
+global_libraries = [] # Libraries we always need
+include_path = '' # Include path, from Makefile
+lib_path = '' # and lib path, ditto
+compiler = 'cc' # and compiler
+
+# Main program -- argument parsing etc.
+def main():
+ global quiet, verbose, noexec, nowrite, ofile, builddir, path
+ try:
+ opts, args = getopt.getopt(sys.argv[1:], 'B:nNo:P:qvI:D:L:l:')
+ except getopt.error, msg:
+ usage(str(msg))
+ sys.exit(2)
+ for o, a in opts:
+ if o == '-B': builddir = a
+ if o == '-n': noexec = 1
+ if o == '-N': nowrite = 1
+ if o == '-o': ofile = a
+ if o == '-P':
+ if '"' in a:
+ usage('sorry, cannot have " in -P option')
+ sys.exit(2)
+ path = `'"' + a + '"'`
+ if o == '-q': verbose = 0; quiet = 1
+ if o == '-v': verbose = verbose + 1; quiet = 0
+ if o in ('-I', '-D'): cc_options.append(o+a)
+ if o in ('-L', '-l'): ld_options.append(o+a)
+ if not builddir:
+ usage('sorry, you have to pass a -B option')
+ sys.exit(2)
+ if len(args) < 1:
+ usage('please pass at least one file argument')
+ sys.exit(2)
+ process(args[0], args[1:])
+
+# Print usage message to stderr
+def usage(*msgs):
+ sys.stdout = sys.stderr
+ for msg in msgs: print msg
+ print 'Usage: freeze [options] scriptfile [modulefile ...]'
+ print '-B dir : name of python build dir (no default)'
+ print '-n : generate the files but don\'t compile and link'
+ print '-N : don\'t write frozen.c (do compile unless -n given)'
+ print '-o file : binary output file (default a.out)'
+ print '-P path : set sys.path for program (default ".")'
+ print '-q : quiet (no messages at all except errors)'
+ print '-v : verbose (lots of extra messages)'
+ print '-D and -I options are passed to cc, -L and -l to ld'
+
+# Process the script file
+def process(filename, addmodules):
+ global noexec
+ #
+ if not quiet: print 'Computing needed modules ...'
+ todo = {}
+ todo['__main__'] = filename
+ for name in addmodules:
+ mod = os.path.basename(name)
+ if mod[-3:] == '.py': mod = mod[:-3]
+ todo[mod] = name
+ try:
+ dict = closure(todo)
+ except NoSuchFile, filename:
+ sys.stderr.write('Can\'t open file %s\n' % filename)
+ sys.exit(1)
+ #
+ mods = dict.keys()
+ mods.sort()
+ #
+ if verbose:
+ print '%-15s %s' % ('Module', 'Filename')
+ for mod in mods:
+ print '%-15s %s' % (`mod`, dict[mod])
+ #
+ if not quiet: print 'Looking for dynamically linked modules ...'
+ dlmodules = []
+ objs = []
+ libs = []
+ for mod in mods:
+ if dict[mod][-2:] == '.o':
+ if verbose: print 'Found', mod, dict[mod]
+ dlmodules.append(mod)
+ objs.append(dict[mod])
+ libsname = dict[mod][:-2] + '.libs'
+ try:
+ f = open(libsname, 'r')
+ except IOError:
+ f = None
+ if f:
+ libtext = f.read()
+ f.close()
+ for lib in string.split(libtext):
+ if lib in libs: libs.remove(lib)
+ libs.append(lib)
+ #
+ if not nowrite:
+ if not quiet: print 'Writing frozen.c ...'
+ writefrozen('frozen.c', dict)
+ else:
+ if not quiet: print 'NOT writing frozen.c ...'
+ #
+ if not quiet:
+ print 'Deducing compile/link options from', builddir
+ #
+ # Parse the config info
+ #
+ parse(builddir)
+ CONFIG_IN = lib_path + '/config.c.in'
+ FMAIN = lib_path + '/frozenmain.c'
+ CC = compiler
+ #
+## if not dlmodules:
+ if 0:
+ config = CONFIG
+ if not quiet: print 'Using existing', config, '...'
+ else:
+ config = 'tmpconfig.c'
+ if nowrite:
+ if not quiet: print 'NOT writing config.c ...'
+ else:
+ if not quiet:
+ print 'Writing config.c with dl modules ...'
+ f = open(CONFIG_IN, 'r')
+ g = open(config, 'w')
+ m1 = regex.compile('-- ADDMODULE MARKER 1 --')
+ m2 = regex.compile('-- ADDMODULE MARKER 2 --')
+ builtinmodules = []
+ stdmodules = ('sys', '__main__', '__builtin__',
+ 'marshal')
+ for mod in dict.keys():
+ if dict[mod] == '<builtin>' and \
+ mod not in stdmodules:
+ builtinmodules.append(mod)
+ todomodules = builtinmodules + dlmodules
+ while 1:
+ line = f.readline()
+ if not line: break
+ g.write(line)
+ if m1.search(line) >= 0:
+ if verbose: print 'Marker 1 ...'
+ for mod in todomodules:
+ g.write('extern void init' + \
+ mod + '();\n')
+ if m2.search(line) >= 0:
+ if verbose: print 'Marker 2 ...'
+ for mod in todomodules:
+ g.write('{"' + mod + \
+ '", init' + mod + '},\n')
+ g.close()
+ #
+ if not quiet:
+ if noexec: print 'Generating compilation commands ...'
+ else: print 'Starting compilation ...'
+ defs = ['-DNO_MAIN', '-DUSE_FROZEN']
+ defs.append('-DPYTHONPATH='+path)
+ #
+ incs = ['-I.', '-I' + include_path]
+# if dict.has_key('stdwin'):
+# incs.append('-I' + j(STDWIN, 'H'))
+ #
+ srcs = [config, FMAIN]
+ #
+ modlibs = module_libraries
+
+ for mod in dict.keys():
+ if modlibs.has_key(mod):
+ libs = libs + modlibs[mod]
+
+ libs = libs + global_libraries
+ #
+ # remove dups:
+ # XXXX Not well tested...
+ nskip = 0
+ newlibs = []
+ while libs:
+ l = libs[0]
+ del libs[0]
+ if l[:2] == '-L' and l in newlibs:
+ nskip = nskip + 1
+ continue
+ if (l[:2] == '-l' or l[-2:] == '.a') and l in libs:
+ nskip = nskip + 1
+ continue
+ newlibs.append(l)
+ libs = newlibs
+ if nskip and not quiet:
+ print 'Removed %d duplicate libraries'%nskip
+ #
+ sts = 0
+ #
+ cmd = CC + ' -c'
+ if cc_options:
+ cmd = cmd + ' ' + string.join(cc_options)
+ cmd = cmd + ' ' + string.join(defs)
+ cmd = cmd + ' ' + string.join(incs)
+ cmd = cmd + ' ' + string.join(srcs)
+ print cmd
+ #
+ if not noexec:
+ sts = os.system(cmd)
+ if sts:
+ print 'Exit status', sts, '-- turning on -n'
+ noexec = 1
+ #
+ for s in srcs:
+ s = os.path.basename(s)
+ if s[-2:] == '.c': s = s[:-2]
+ o = s + '.o'
+ objs.insert(0, o)
+ #
+ cmd = CC
+ cmd = cmd + ' ' + string.join(objs)
+ cmd = cmd + ' ' + string.join(libs)
+ if ld_options:
+ cmd = cmd + ' ' + string.join(ld_options)
+ cmd = cmd + ' -o ' + ofile
+ print cmd
+ #
+ if not noexec:
+ sts = os.system(cmd)
+ if sts:
+ print 'Exit status', sts
+ else:
+ print 'Done.'
+ #
+ if not quiet and not noexec and sts == 0:
+ print 'Note: consider this:'; print '\tstrip', ofile
+ #
+ sys.exit(sts)
+
+
+# Generate code for a given module
+def makecode(filename):
+ if filename[-2:] == '.o':
+ return None
+ try:
+ f = open(filename, 'r')
+ except IOError:
+ return None
+ if verbose: print 'Making code from', filename, '...'
+ text = f.read()
+ code = compile(text, filename, 'exec')
+ f.close()
+ return marshal.dumps(code)
+
+
+# Write the C source file containing the frozen Python code
+def writefrozen(filename, dict):
+ f = open(filename, 'w')
+ codelist = []
+ for mod in dict.keys():
+ codestring = makecode(dict[mod])
+ if codestring is not None:
+ codelist.append((mod, codestring))
+ write = sys.stdout.write
+ save_stdout = sys.stdout
+ try:
+ sys.stdout = f
+ for mod, codestring in codelist:
+ if verbose:
+ write('Writing initializer for %s\n'%mod)
+ print 'static unsigned char M_' + mod + '[' + \
+ str(len(codestring)) + '+1] = {'
+ for i in range(0, len(codestring), 16):
+ for c in codestring[i:i+16]:
+ print str(ord(c)) + ',',
+ print
+ print '};'
+ print 'struct frozen {'
+ print ' char *name;'
+ print ' unsigned char *code;'
+ print ' int size;'
+ print '} frozen_modules[] = {'
+ for mod, codestring in codelist:
+ print ' {"' + mod + '",',
+ print 'M_' + mod + ',',
+ print str(len(codestring)) + '},'
+ print ' {0, 0, 0} /* sentinel */'
+ print '};'
+ finally:
+ sys.stdout = save_stdout
+ f.close()
+
+
+# Determine the names and filenames of the modules imported by the
+# script, recursively. This is done by scanning for lines containing
+# import statements. (The scanning has only superficial knowledge of
+# Python syntax and no knowledge of semantics, so in theory the result
+# may be incorrect -- however this is quite unlikely if you don't
+# intentionally obscure your Python code.)
+
+# Compute the closure of scanfile() -- special first file because of script
+def closure(todo):
+ done = {}
+ while todo:
+ newtodo = {}
+ for modname in todo.keys():
+ if not done.has_key(modname):
+ filename = todo[modname]
+ if filename is None:
+ filename = findmodule(modname)
+ done[modname] = filename
+ if filename in ('<builtin>', '<unknown>'):
+ continue
+ modules = scanfile(filename)
+ for m in modules:
+ if not done.has_key(m):
+ newtodo[m] = None
+ todo = newtodo
+ return done
+
+# Scan a file looking for import statements
+importstr = '\(^\|:\)[ \t]*import[ \t]+\([a-zA-Z0-9_, \t]+\)'
+fromstr = '\(^\|:\)[ \t]*from[ \t]+\([a-zA-Z0-9_]+\)[ \t]+import[ \t]+'
+isimport = regex.compile(importstr)
+isfrom = regex.compile(fromstr)
+def scanfile(filename):
+ allmodules = {}
+ try:
+ f = open(filename, 'r')
+ except IOError, msg:
+ raise NoSuchFile, filename
+ while 1:
+ line = f.readline()
+ if not line: break # EOF
+ while line[-2:] == '\\\n': # Continuation line
+ line = line[:-2] + ' '
+ line = line + f.readline()
+ if isimport.search(line) >= 0:
+ rawmodules = isimport.group(2)
+ modules = string.splitfields(rawmodules, ',')
+ for i in range(len(modules)):
+ modules[i] = string.strip(modules[i])
+ elif isfrom.search(line) >= 0:
+ modules = [isfrom.group(2)]
+ else:
+ continue
+ for mod in modules:
+ allmodules[mod] = None
+ f.close()
+ return allmodules.keys()
+
+# Find the file containing a module, given its name; None if not found
+builtins = sys.builtin_module_names + ['sys']
+def findmodule(modname):
+ if modname in builtins: return '<builtin>'
+ for dirname in sys.path:
+ dlfullname = os.path.join(dirname, modname + 'module.o')
+ try:
+ f = open(dlfullname, 'r')
+ except IOError:
+ f = None
+ if f:
+ f.close()
+ return dlfullname
+ fullname = os.path.join(dirname, modname + '.py')
+ try:
+ f = open(fullname, 'r')
+ except IOError:
+ continue
+ f.close()
+ return fullname
+ if not quiet:
+ sys.stderr.write('Warning: module %s not found\n' % modname)
+ return '<unknown>'
+#
+# Parse a setup file. Returns two dictionaries, one containing variables
+# defined with their values and one containing module definitions
+#
+def parse_setup(fp):
+ modules = {}
+ variables = {}
+ for line in fp.readlines():
+ if '#' in line: # Strip comments
+ line = string.splitfields(line, '#')[0]
+ line = string.strip(line[:-1]) # Strip whitespace
+ if not line:
+ continue
+ words = string.split(line)
+ if '=' in words[0]:
+ #
+ # equal sign before first space. Definition
+ #
+ pos = string.index(line, '=')
+ name = line[:pos]
+ value = string.strip(line[pos+1:])
+ variables[name] = value
+ else:
+ modules[words[0]] = words[1:]
+ return modules, variables
+#
+# Parse a makefile. Returns a list of the variables defined.
+#
+def parse_makefile(fp):
+ variables = {}
+ for line in fp.readlines():
+ if '#' in line: # Strip comments
+ line = string.splitfields(line, '#')[0]
+ if not line:
+ continue
+ if line[0] in string.whitespace:
+ continue
+ line = string.strip(line[:-1]) # Strip whitespace
+ if not line:
+ continue
+ if '=' in string.splitfields(line, ':')[0]:
+ #
+ # equal sign before first colon. Definition
+ #
+ pos = string.index(line, '=')
+ name = line[:pos]
+ value = string.strip(line[pos+1:])
+ variables[name] = value
+ return variables
+
+#
+# Recursively add loader options from Setup files in extension
+# directories.
+#
+def add_extension_directory(name, isinstalldir):
+ if verbose:
+ print 'Adding extension directory', name
+ fp = open(name + '/Setup', 'r')
+ modules, variables = parse_setup(fp)
+ #
+ # Locate all new modules and remember the ld flags needed for them
+ #
+ for m in modules.keys():
+ if module_libraries.has_key(m):
+ continue
+ options = modules[m]
+ if isinstalldir:
+ ld_options = []
+ else:
+ ld_options = [name + '/lib.a']
+ for o in options:
+ # ld options are all capital except DUIC and l
+ if o[:-2] == '.a':
+ ld_options.append(o)
+ elif o[0] == '-':
+ if o[1] == 'l':
+ ld_options.append(o)
+ elif o[1] in string.uppercase and not o[1] in 'DUIC':
+ ld_options.append(o)
+ module_libraries[m] = ld_options
+ #
+ # See if we have to bother with base setups
+ #
+ if variables.has_key('BASESETUP'):
+ if isinstalldir:
+ raise 'installdir has base setup'
+ setupfiles = string.split(variables['BASESETUP'])
+ for s in setupfiles:
+ if s[-6:] <> '/Setup':
+ raise 'Incorrect BASESETUP', s
+ s = s[:-6]
+ if s[0] <> '/':
+ s = name + '/' + s
+ s = os.path.normpath(s)
+ add_extension_directory(s, 0)
+#
+# Main routine for this module: given a build directory, get all
+# information needed for the linker.
+#
+def parse(dir):
+ global include_path
+ global lib_path
+ global compiler
+
+ fp = open(dir + '/Makefile', 'r')
+ #
+ # First find the global libraries and the base python
+ #
+ vars = parse_makefile(fp)
+ if vars.has_key('CC'):
+ compiler = vars['CC']
+ if not vars.has_key('installdir'):
+ raise 'No $installdir in Makefile'
+ include_path = vars['installdir'] + '/include/Py'
+ lib_path = vars['installdir'] + '/lib/python/lib'
+ global_libraries.append('-L' + lib_path)
+ global_libraries.append('-lPython')
+ global_libraries.append('-lParser')
+ global_libraries.append('-lObjects')
+ global_libraries.append('-lModules')
+ for name in ('LIBS', 'LIBM', 'LIBC'):
+ if not vars.has_key(name):
+ raise 'Missing required def in Makefile', name
+ for lib in string.split(vars[name]):
+ global_libraries.append(lib)
+ #
+ # Next, parse the modules from the base python
+ #
+ add_extension_directory(lib_path, 1)
+ #
+ # Finally, parse the modules from the extension python
+ #
+ if dir <> lib_path:
+ add_extension_directory(dir, 0)
+
+# Call the main program
+main()
projects / thirdparty / Python / cpython.git / commitdiff
