Tools/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 behaviour 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, string, 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):
  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" % mapFileName)
  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 )
  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):
  83         if win32api is None: return None
  84         dsp = win32api.GetProfileVal(moduleName, "dsp", "", mapFileName)
  85         if dsp=="":
  86                 return None
  87
  88         # We allow environment variables in the file name
  89         dsp = win32api.ExpandEnvironmentStrings(dsp)
  90         # If the path to the .DSP file is not absolute, assume it is relative
  91         # to the description file.
  92         if not os.path.isabs(dsp):
  93                 dsp = os.path.join( os.path.split(mapFileName)[0], dsp)
  94         # Parse it to extract the source files.
  95         sourceFiles = parse_dsp(dsp)
  96         if sourceFiles is None:
  97                 return None
  98
  99         module = CExtension(moduleName, sourceFiles)
 100         # Put the path to the DSP into the environment so entries can reference it.
 101         os.environ['dsp_path'] = os.path.split(dsp)[0]
 102         os.environ['ini_path'] = os.path.split(mapFileName)[0]
 103
 104         cl_options = win32api.GetProfileVal(moduleName, "cl", "", mapFileName)
 105         if cl_options:
 106                 module.AddCompilerOption(win32api.ExpandEnvironmentStrings(cl_options))
 107
 108         exclude = win32api.GetProfileVal(moduleName, "exclude", "", mapFileName)
 109         exclude = string.split(exclude)
 110
 111         if win32api.GetProfileVal(moduleName, "Unicode", 0, mapFileName):
 112                 module.AddCompilerOption('/D UNICODE /D _UNICODE')
 113
 114         libs = string.split(win32api.GetProfileVal(moduleName, "libs", "", mapFileName))
 115         for lib in libs:
 116                 module.AddLinkerLib(win32api.ExpandEnvironmentStrings(lib))
 117
 118         for exc in exclude:
 119                 if exc in module.sourceFiles:
 120                         modules.sourceFiles.remove(exc)
 121
 122         return module
 123
 124 # Given an MSVC DSP file, locate C source files it uses
 125 # returns a list of source files.
 126 def parse_dsp(dsp):
 127 #       print "Processing", dsp
 128         # For now, only support
 129         ret = []
 130         dsp_path, dsp_name = os.path.split(dsp)
 131         try:
 132                 lines = open(dsp, "r").readlines()
 133         except IOError, msg:
 134                 sys.stderr.write("%s: %s\n" % (dsp, msg))
 135                 return None
 136         for line in lines:
 137                 fields = string.split(string.strip(line), "=", 2)
 138                 if fields[0]=="SOURCE":
 139                         if string.lower(os.path.splitext(fields[1])[1]) in ['.cpp', '.c']:
 140                                 ret.append( win32api.GetFullPathName(os.path.join(dsp_path, fields[1] ) ) )
 141         return ret
 142
 143 def write_extension_table(fname, modules):
 144         fp = open(fname, "w")
 145         try:
 146                 fp.write (ext_src_header)
 147                 # Write fn protos
 148                 for module in modules:
 149                         # bit of a hack for .pyd's as part of packages.
 150                         name = string.split(module.name,'.')[-1]
 151                         fp.write('extern void init%s(void);\n' % (name) )
 152                 # Write the table
 153                 fp.write (ext_tab_header)
 154                 for module in modules:
 155                         name = string.split(module.name,'.')[-1]
 156                         fp.write('\t{"%s", init%s},\n' % (name, name) )
 157
 158                 fp.write (ext_tab_footer)
 159                 fp.write(ext_src_footer)
 160         finally:
 161                 fp.close()
 162
 163
 164 ext_src_header = """\
 165 #include "Python.h"
 166 """
 167
 168 ext_tab_header = """\
 169
 170 static struct _inittab extensions[] = {
 171 """
 172
 173 ext_tab_footer = """\
 174         /* Sentinel */
 175         {0, 0}
 176 };
 177 """
 178
 179 ext_src_footer = """\
 180 extern int PyImport_ExtendInittab(struct _inittab *newtab);
 181
 182 int PyInitFrozenExtensions()
 183 {
 184         return PyImport_ExtendInittab(extensions);
 185 }
 186
 187 """
 188
 189