freeze/checkextensions_win32.py

   1 """Extension management for Windows.
   2
   3 Under Windows it is unlikely the .obj files are of use, as special compiler options
   4 are needed (primarily to toggle the behavior of "public" symbols.
   5
   6 I dont consider it worth parsing the MSVC makefiles for compiler options.  Even if
   7 we get it just right, a specific freeze application may have specific compiler
   8 options anyway (eg, to enable or disable specific functionality)
   9
  10 So 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
  21 At the moment the name and location of this INI file is hardcoded,
  22 but an obvious enhancement would be to provide command line options.
  23 """
  24
  25 import os, sys
  26 try:
  27     import win32api
  28 except ImportError:
  29     win32api = None # User has already been warned
  30
  31 class 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
  57 def 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
  82 def 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.
 127 def 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
 144 def 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
 165 ext_src_header = """\
 166 #include "Python.h"
 167 """
 168
 169 ext_tab_header = """\
 170
 171 static struct _inittab extensions[] = {
 172 """
 173
 174 ext_tab_footer = """\
 175         /* Sentinel */
 176         {0, 0}
 177 };
 178 """
 179
 180 ext_src_footer = """\
 181 extern DL_IMPORT(int) PyImport_ExtendInittab(struct _inittab *newtab);
 182
 183 int PyInitFrozenExtensions()
 184 {
 185         return PyImport_ExtendInittab(extensions);
 186 }
 187
 188 """