PageRenderTime 36ms CodeModel.GetById 11ms app.highlight 19ms RepoModel.GetById 1ms app.codeStats 1ms

/Tools/freeze/checkextensions_win32.py

http://unladen-swallow.googlecode.com/
Python | 188 lines | 185 code | 0 blank | 3 comment | 3 complexity | 4ed39ef9a21361c198bd3b9f2c137764 MD5 | raw file
  1"""Extension management for Windows.
  2
  3Under Windows it is unlikely the .obj files are of use, as special compiler options
  4are needed (primarily to toggle the behavior of "public" symbols.
  5
  6I dont consider it worth parsing the MSVC makefiles for compiler options.  Even if
  7we get it just right, a specific freeze application may have specific compiler
  8options anyway (eg, to enable or disable specific functionality)
  9
 10So my basic stragtegy is:
 11
 12* Have some Windows INI files which "describe" one or more extension modules.
 13  (Freeze comes with a default one for all known modules - but you can specify
 14  your own).
 15* This description can include:
 16  - The MSVC .dsp file for the extension.  The .c source file names
 17    are extraced from there.
 18  - Specific compiler/linker options
 19  - Flag to indicate if Unicode compilation is expected.
 20
 21At the moment the name and location of this INI file is hardcoded,
 22but an obvious enhancement would be to provide command line options.
 23"""
 24
 25import os, sys
 26try:
 27    import win32api
 28except ImportError:
 29    win32api = None # User has already been warned
 30
 31class CExtension:
 32    """An abstraction of an extension implemented in C/C++
 33    """
 34    def __init__(self, name, sourceFiles):
 35        self.name = name
 36        # A list of strings defining additional compiler options.
 37        self.sourceFiles = sourceFiles
 38        # A list of special compiler options to be applied to
 39        # all source modules in this extension.
 40        self.compilerOptions = []
 41        # A list of .lib files the final .EXE will need.
 42        self.linkerLibs = []
 43
 44    def GetSourceFiles(self):
 45        return self.sourceFiles
 46
 47    def AddCompilerOption(self, option):
 48        self.compilerOptions.append(option)
 49    def GetCompilerOptions(self):
 50        return self.compilerOptions
 51
 52    def AddLinkerLib(self, lib):
 53        self.linkerLibs.append(lib)
 54    def GetLinkerLibs(self):
 55        return self.linkerLibs
 56
 57def checkextensions(unknown, extra_inis, prefix):
 58    # Create a table of frozen extensions
 59
 60    defaultMapName = os.path.join( os.path.split(sys.argv[0])[0], "extensions_win32.ini")
 61    if not os.path.isfile(defaultMapName):
 62        sys.stderr.write("WARNING: %s can not be found - standard extensions may not be found\n" % defaultMapName)
 63    else:
 64        # must go on end, so other inis can override.
 65        extra_inis.append(defaultMapName)
 66
 67    ret = []
 68    for mod in unknown:
 69        for ini in extra_inis:
 70#                       print "Looking for", mod, "in", win32api.GetFullPathName(ini),"...",
 71            defn = get_extension_defn( mod, ini, prefix )
 72            if defn is not None:
 73#                               print "Yay - found it!"
 74                ret.append( defn )
 75                break
 76#                       print "Nope!"
 77        else: # For not broken!
 78            sys.stderr.write("No definition of module %s in any specified map file.\n" % (mod))
 79
 80    return ret
 81
 82def get_extension_defn(moduleName, mapFileName, prefix):
 83    if win32api is None: return None
 84    os.environ['PYTHONPREFIX'] = prefix
 85    dsp = win32api.GetProfileVal(moduleName, "dsp", "", mapFileName)
 86    if dsp=="":
 87        return None
 88
 89    # We allow environment variables in the file name
 90    dsp = win32api.ExpandEnvironmentStrings(dsp)
 91    # If the path to the .DSP file is not absolute, assume it is relative
 92    # to the description file.
 93    if not os.path.isabs(dsp):
 94        dsp = os.path.join( os.path.split(mapFileName)[0], dsp)
 95    # Parse it to extract the source files.
 96    sourceFiles = parse_dsp(dsp)
 97    if sourceFiles is None:
 98        return None
 99
100    module = CExtension(moduleName, sourceFiles)
101    # Put the path to the DSP into the environment so entries can reference it.
102    os.environ['dsp_path'] = os.path.split(dsp)[0]
103    os.environ['ini_path'] = os.path.split(mapFileName)[0]
104
105    cl_options = win32api.GetProfileVal(moduleName, "cl", "", mapFileName)
106    if cl_options:
107        module.AddCompilerOption(win32api.ExpandEnvironmentStrings(cl_options))
108
109    exclude = win32api.GetProfileVal(moduleName, "exclude", "", mapFileName)
110    exclude = exclude.split()
111
112    if win32api.GetProfileVal(moduleName, "Unicode", 0, mapFileName):
113        module.AddCompilerOption('/D UNICODE /D _UNICODE')
114
115    libs = win32api.GetProfileVal(moduleName, "libs", "", mapFileName).split()
116    for lib in libs:
117        module.AddLinkerLib(win32api.ExpandEnvironmentStrings(lib))
118
119    for exc in exclude:
120        if exc in module.sourceFiles:
121            modules.sourceFiles.remove(exc)
122
123    return module
124
125# Given an MSVC DSP file, locate C source files it uses
126# returns a list of source files.
127def parse_dsp(dsp):
128#       print "Processing", dsp
129    # For now, only support
130    ret = []
131    dsp_path, dsp_name = os.path.split(dsp)
132    try:
133        lines = open(dsp, "r").readlines()
134    except IOError, msg:
135        sys.stderr.write("%s: %s\n" % (dsp, msg))
136        return None
137    for line in lines:
138        fields = line.strip().split("=", 2)
139        if fields[0]=="SOURCE":
140            if os.path.splitext(fields[1])[1].lower() in ['.cpp', '.c']:
141                ret.append( win32api.GetFullPathName(os.path.join(dsp_path, fields[1] ) ) )
142    return ret
143
144def write_extension_table(fname, modules):
145    fp = open(fname, "w")
146    try:
147        fp.write (ext_src_header)
148        # Write fn protos
149        for module in modules:
150            # bit of a hack for .pyd's as part of packages.
151            name = module.name.split('.')[-1]
152            fp.write('extern void init%s(void);\n' % (name) )
153        # Write the table
154        fp.write (ext_tab_header)
155        for module in modules:
156            name = module.name.split('.')[-1]
157            fp.write('\t{"%s", init%s},\n' % (name, name) )
158
159        fp.write (ext_tab_footer)
160        fp.write(ext_src_footer)
161    finally:
162        fp.close()
163
164
165ext_src_header = """\
166#include "Python.h"
167"""
168
169ext_tab_header = """\
170
171static struct _inittab extensions[] = {
172"""
173
174ext_tab_footer = """\
175        /* Sentinel */
176        {0, 0}
177};
178"""
179
180ext_src_footer = """\
181extern DL_IMPORT(int) PyImport_ExtendInittab(struct _inittab *newtab);
182
183int PyInitFrozenExtensions()
184{
185        return PyImport_ExtendInittab(extensions);
186}
187
188"""