home *** CD-ROM | disk | FTP | other *** search
/ Chip 2004 July / CMCD0704.ISO / Software / Shareware / Comunicatii / jyte / jyte.exe / regsetup.py < prev    next >
Text File  |  2002-10-23  |  23KB  |  628 lines
  1. # A tool to setup the Python registry.
  2.  
  3. error = "Registry Setup Error"
  4.  
  5. import sys # at least we can count on this!
  6.  
  7. def FileExists(fname):
  8.     """Check if a file exists.  Returns true or false.
  9.     """
  10.     import os
  11.     try:
  12.         os.stat(fname)
  13.         return 1
  14.     except os.error, details:
  15.         return 0
  16.  
  17. def IsPackageDir(path, packageName, knownFileName):
  18.     """Given a path, a ni package name, and possibly a known file name in
  19.            the root of the package, see if this path is good.
  20.       """
  21.     import os
  22.     if knownFileName is None:
  23.         knownFileName = "."
  24.     return FileExists(os.path.join(os.path.join(path, packageName),knownFileName))
  25.  
  26. def IsDebug():
  27.         """Return "_d" if we're running a debug version.
  28.         
  29.         This is to be used within DLL names when locating them.
  30.         """
  31.         import parser # This comes as a .pyd with most versions.
  32.         if parser.__file__[-6:] == '_d.pyd':
  33.                 return '_d'
  34.         return ''
  35.  
  36. def FindPackagePath(packageName, knownFileName, searchPaths):
  37.     """Find a package.
  38.  
  39.            Given a ni style package name, check the package is registered.
  40.  
  41.            First place looked is the registry for an existing entry.  Then
  42.            the searchPaths are searched.
  43.       """
  44.     import regutil, os
  45.     pathLook = regutil.GetRegisteredNamedPath(packageName)
  46.     if pathLook and IsPackageDir(pathLook, packageName, knownFileName):
  47.         return pathLook, None # The currently registered one is good.
  48.     # Search down the search paths.
  49.     for pathLook in searchPaths:
  50.         if IsPackageDir(pathLook, packageName, knownFileName):
  51.             # Found it
  52.             ret = os.path.abspath(pathLook)
  53.             return ret, ret
  54.     raise error, "The package %s can not be located" % packageName
  55.  
  56. def FindHelpPath(helpFile, helpDesc, searchPaths):
  57.     # See if the current registry entry is OK
  58.     import os, win32api, win32con
  59.     try:
  60.         key = win32api.RegOpenKey(win32con.HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\Help", 0, win32con.KEY_ALL_ACCESS)
  61.         try:
  62.             try:
  63.                 path = win32api.RegQueryValueEx(key, helpDesc)[0]
  64.                 if FileExists(os.path.join(path, helpFile)):
  65.                     return os.path.abspath(path)
  66.             except win32api.error:
  67.                 pass # no registry entry.
  68.         finally:
  69.             key.Close()
  70.     except win32api.error:
  71.         pass
  72.     for pathLook in searchPaths:
  73.         if FileExists(os.path.join(pathLook, helpFile)):
  74.             return os.path.abspath(pathLook)
  75.         pathLook = os.path.join(pathLook, "Help")
  76.         if FileExists(os.path.join( pathLook, helpFile)):
  77.             return os.path.abspath(pathLook)
  78.     raise error, "The help file %s can not be located" % helpFile
  79.  
  80. def FindAppPath(appName, knownFileName, searchPaths):
  81.     """Find an application.
  82.  
  83.          First place looked is the registry for an existing entry.  Then
  84.          the searchPaths are searched.
  85.       """
  86.     # Look in the first path.
  87.     import regutil, string, os
  88.     regPath = regutil.GetRegisteredNamedPath(appName)
  89.     if regPath:
  90.         pathLook = string.split(regPath,";")[0]
  91.     if regPath and FileExists(os.path.join(pathLook, knownFileName)):
  92.         return None # The currently registered one is good.
  93.     # Search down the search paths.
  94.     for pathLook in searchPaths:
  95.         if FileExists(os.path.join(pathLook, knownFileName)):
  96.             # Found it
  97.             return os.path.abspath(pathLook)
  98.     raise error, "The file %s can not be located for application %s" % (knownFileName, appName)
  99.  
  100. def FindRegisteredModule(moduleName, possibleRealNames, searchPaths):
  101.     """Find a registered module.
  102.  
  103.          First place looked is the registry for an existing entry.  Then
  104.          the searchPaths are searched.
  105.          
  106.        Returns the full path to the .exe or None if the current registered entry is OK.
  107.       """
  108.     import win32api, regutil, string
  109.     try:
  110.         fname = win32api.RegQueryValue(regutil.GetRootKey(), \
  111.                        regutil.BuildDefaultPythonKey() + "\\Modules\\%s" % moduleName)
  112.  
  113.         if FileExists(fname):
  114.             return None # Nothing extra needed
  115.  
  116.     except win32api.error:
  117.         pass
  118.     return LocateFileName(possibleRealNames, searchPaths)
  119.  
  120. def FindPythonExe(exeAlias, possibleRealNames, searchPaths):
  121.     """Find an exe.
  122.  
  123.        Returns the full path to the .exe, and a boolean indicating if the current 
  124.        registered entry is OK.  We don't trust the already registered version even
  125.        if it exists - it may be wrong (ie, for a different Python version)
  126.     """
  127.     import win32api, regutil, string, os, sys
  128.     if possibleRealNames is None:
  129.         possibleRealNames = exeAlias
  130.     # Look first in Python's home.
  131.     found = os.path.join(sys.prefix,  possibleRealNames)
  132.     if not FileExists(found): # for developers
  133.         found = os.path.join(sys.prefix,  "PCBuild", possibleRealNames)
  134.     if not FileExists(found):
  135.         found = LocateFileName(possibleRealNames, searchPaths)
  136.  
  137.     registered_ok = 0
  138.     try:
  139.         registered = win32api.RegQueryValue(regutil.GetRootKey(), regutil.GetAppPathsKey() + "\\" + exeAlias)
  140.         registered_ok = found==registered
  141.     except win32api.error:
  142.         pass
  143.     return found, registered_ok
  144.  
  145. def QuotedFileName(fname):
  146.     """Given a filename, return a quoted version if necessary
  147.       """
  148.     import regutil, string
  149.     try:
  150.         string.index(fname, " ") # Other chars forcing quote?
  151.         return '"%s"' % fname
  152.     except ValueError:
  153.         # No space in name.
  154.         return fname
  155.  
  156. def LocateFileName(fileNamesString, searchPaths):
  157.     """Locate a file name, anywhere on the search path.
  158.  
  159.        If the file can not be located, prompt the user to find it for us
  160.        (using a common OpenFile dialog)
  161.  
  162.        Raises KeyboardInterrupt if the user cancels.
  163.     """
  164.     import regutil, string, os
  165.     fileNames = string.split(fileNamesString,";")
  166.     for path in searchPaths:
  167.         for fileName in fileNames:
  168.             try:
  169.                 retPath = os.path.join(path, fileName)
  170.                 os.stat(retPath)
  171.                 break
  172.             except os.error:
  173.                 retPath = None
  174.         if retPath:
  175.             break
  176.     else:
  177.         fileName = fileNames[0]
  178.         try:
  179.             import win32ui, win32con
  180.         except ImportError:
  181.             raise error, "Need to locate the file %s, but the win32ui module is not available\nPlease run the program again, passing as a parameter the path to this file." % fileName
  182.         # Display a common dialog to locate the file.
  183.         flags=win32con.OFN_FILEMUSTEXIST
  184.         ext = os.path.splitext(fileName)[1]
  185.         filter = "Files of requested type (*%s)|*%s||" % (ext,ext)
  186.         dlg = win32ui.CreateFileDialog(1,None,fileName,flags,filter,None)
  187.         dlg.SetOFNTitle("Locate " + fileName)
  188.         if dlg.DoModal() <> win32con.IDOK:
  189.             raise KeyboardInterrupt, "User cancelled the process"
  190.         retPath = dlg.GetPathName()
  191.     return os.path.abspath(retPath)
  192.  
  193. def LocatePath(fileName, searchPaths):
  194.     """Like LocateFileName, but returns a directory only.
  195.     """
  196.     import os
  197.     return os.path.abspath(os.path.split(LocateFileName(fileName, searchPaths))[0])
  198.  
  199. def LocateOptionalPath(fileName, searchPaths):
  200.     """Like LocatePath, but returns None if the user cancels.
  201.     """
  202.     try:
  203.         return LocatePath(fileName, searchPaths)
  204.     except KeyboardInterrupt:
  205.         return None
  206.  
  207.  
  208. def LocateOptionalFileName(fileName, searchPaths = None):
  209.     """Like LocateFileName, but returns None if the user cancels.
  210.     """
  211.     try:
  212.         return LocateFileName(fileName, searchPaths)
  213.     except KeyboardInterrupt:
  214.         return None
  215.  
  216. def LocatePythonCore(searchPaths):
  217.     """Locate and validate the core Python directories.  Returns a list
  218.          of paths that should be used as the core (ie, un-named) portion of
  219.          the Python path.
  220.     """
  221.     import string, os, regutil
  222.     currentPath = regutil.GetRegisteredNamedPath(None)
  223.     if currentPath:
  224.         presearchPaths = string.split(currentPath, ";")
  225.     else:
  226.         presearchPaths = [os.path.abspath(".")]
  227.     libPath = None
  228.     for path in presearchPaths:
  229.         if FileExists(os.path.join(path, "os.py")):
  230.             libPath = path
  231.             break
  232.     if libPath is None and searchPaths is not None:
  233.         libPath = LocatePath("os.py", searchPaths)
  234.     if libPath is None:
  235.         raise error, "The core Python library could not be located."
  236.  
  237.     corePath = None
  238.     suffix = IsDebug()
  239.     for path in presearchPaths:
  240.         if FileExists(os.path.join(path, "parser%s.pyd" % suffix)):
  241.             corePath = path
  242.             break
  243.     if corePath is None and searchPaths is not None:
  244.         corePath = LocatePath("parser%s.pyd" % suffix, searchPaths)
  245.     if corePath is None:
  246.         raise error, "The core Python path could not be located."
  247.  
  248.     installPath = os.path.abspath(os.path.join(libPath, ".."))
  249.     return installPath, [libPath, corePath]
  250.  
  251. def FindRegisterPackage(packageName, knownFile, searchPaths, registryAppName = None):
  252.     """Find and Register a package.
  253.  
  254.        Assumes the core registry setup correctly.
  255.  
  256.        In addition, if the location located by the package is already
  257.            in the **core** path, then an entry is registered, but no path.
  258.        (no other paths are checked, as the application whose path was used
  259.        may later be uninstalled.  This should not happen with the core)
  260.     """
  261.     import regutil, string
  262.     if not packageName: raise error, "A package name must be supplied"
  263.     corePaths = string.split(regutil.GetRegisteredNamedPath(None),";")
  264.     if not searchPaths: searchPaths = corePaths
  265.     registryAppName = registryAppName or packageName
  266.     try:
  267.         pathLook, pathAdd = FindPackagePath(packageName, knownFile, searchPaths)
  268.         if pathAdd is not None:
  269.             if pathAdd in corePaths:
  270.                 pathAdd = ""
  271.             regutil.RegisterNamedPath(registryAppName, pathAdd)
  272.         return pathLook
  273.     except error, details:
  274.         print "*** The %s package could not be registered - %s" % (packageName, details)
  275.         print "*** Please ensure you have passed the correct paths on the command line."
  276.         print "*** - For packages, you should pass a path to the packages parent directory,"
  277.         print "*** - and not the package directory itself..."
  278.  
  279.  
  280. def FindRegisterApp(appName, knownFiles, searchPaths):
  281.     """Find and Register a package.
  282.  
  283.        Assumes the core registry setup correctly.
  284.  
  285.     """
  286.     import regutil, string
  287.     if type(knownFiles)==type(''):
  288.         knownFiles = [knownFiles]
  289.     paths=[]
  290.     try:
  291.         for knownFile in knownFiles:
  292.             pathLook = FindAppPath(appName, knownFile, searchPaths)
  293.             if pathLook:
  294.                 paths.append(pathLook)
  295.     except error, details:
  296.         print "*** ", details
  297.         return
  298.  
  299.     regutil.RegisterNamedPath(appName, string.join(paths,";"))
  300.  
  301. def FindRegisterModule(modName, actualFileNames, searchPaths):
  302.     """Find and Register a module.
  303.  
  304.        Assumes the core registry setup correctly.
  305.     """
  306.     import regutil
  307.     try:
  308.         fname = FindRegisteredModule(modName, actualFileNames, searchPaths)
  309.         if fname is not None:
  310.             regutil.RegisterModule(modName, fname)
  311.     except error, details:
  312.         print "*** ", details
  313.  
  314. def FindRegisterPythonExe(exeAlias, searchPaths, actualFileNames = None):
  315.     """Find and Register a Python exe (not necessarily *the* python.exe)
  316.  
  317.        Assumes the core registry setup correctly.
  318.     """
  319.     import regutil, string
  320.     fname, ok = FindPythonExe(exeAlias, actualFileNames, searchPaths)
  321.     if not ok:
  322.         regutil.RegisterPythonExe(fname, exeAlias)
  323.     return fname
  324.  
  325.  
  326. def FindRegisterHelpFile(helpFile, searchPaths, helpDesc = None ):
  327.     import regutil
  328.     
  329.     try:
  330.         pathLook = FindHelpPath(helpFile, helpDesc, searchPaths)
  331.     except error, details:
  332.         print "*** ", details
  333.         return
  334. #    print "%s found at %s" % (helpFile, pathLook)
  335.     regutil.RegisterHelpFile(helpFile, pathLook, helpDesc)
  336.     
  337. def SetupCore(searchPaths):
  338.     """Setup the core Python information in the registry.
  339.  
  340.        This function makes no assumptions about the current state of sys.path.
  341.  
  342.        After this function has completed, you should have access to the standard
  343.        Python library, and the standard Win32 extensions
  344.     """
  345.  
  346.     import sys    
  347.     for path in searchPaths:
  348.         sys.path.append(path)
  349.  
  350.     import string, os
  351.     import regutil, win32api,win32con
  352.     
  353.     installPath, corePaths = LocatePythonCore(searchPaths)
  354.     # Register the core Pythonpath.
  355.     print corePaths
  356.     regutil.RegisterNamedPath(None, string.join(corePaths,";"))
  357.  
  358.     # Register the install path.
  359.     hKey = win32api.RegCreateKey(regutil.GetRootKey() , regutil.BuildDefaultPythonKey())
  360.     try:
  361.         # Core Paths.
  362.         win32api.RegSetValue(hKey, "InstallPath", win32con.REG_SZ, installPath)
  363.     finally:
  364.         win32api.RegCloseKey(hKey)
  365.     # The core DLL.
  366. #    regutil.RegisterCoreDLL()
  367.  
  368.     # Register the win32 extensions, as some of them are pretty much core!
  369.     # Why doesnt win32con.__file__ give me a path? (ahh - because only the .pyc exists?)
  370.  
  371.     # Register the win32 core paths.
  372.     win32paths = os.path.abspath( os.path.split(win32api.__file__)[0]) + ";" + \
  373.                  os.path.abspath( os.path.split(LocateFileName("win32con.py;win32con.pyc", sys.path ) )[0] )
  374.  
  375.     suffix = IsDebug()
  376.     ver_str = hex(sys.hexversion)[2] + hex(sys.hexversion)[4]
  377.     # pywintypes now has a .py stub
  378.     FindRegisterModule("pywintypes", "pywintypes%s%s.dll" % (ver_str, suffix), [".", win32api.GetSystemDirectory()])
  379.     regutil.RegisterNamedPath("win32",win32paths)
  380.  
  381.  
  382. def RegisterShellInfo(searchPaths):
  383.     """Registers key parts of the Python installation with the Windows Shell.
  384.  
  385.        Assumes a valid, minimal Python installation exists
  386.        (ie, SetupCore() has been previously successfully run)
  387.     """
  388.     import regutil, win32con
  389.     suffix = IsDebug()
  390.     # Set up a pointer to the .exe's
  391.     exePath = FindRegisterPythonExe("Python%s.exe" % suffix, searchPaths)
  392.     regutil.SetRegistryDefaultValue(".py", "Python.File", win32con.HKEY_CLASSES_ROOT)
  393.     regutil.RegisterShellCommand("Open", QuotedFileName(exePath)+" \"%1\" %*", "&Run")
  394.     regutil.SetRegistryDefaultValue("Python.File\\DefaultIcon", "%s,0" % exePath, win32con.HKEY_CLASSES_ROOT)
  395.     
  396.     FindRegisterHelpFile("Python.hlp", searchPaths, "Main Python Documentation")
  397.     FindRegisterHelpFile("ActivePython.chm", searchPaths, "Main Python Documentation")
  398.  
  399.     # We consider the win32 core, as it contains all the win32 api type
  400.     # stuff we need.
  401. #    FindRegisterApp("win32", ["win32con.pyc", "win32api%s.pyd" % suffix], searchPaths)
  402.  
  403. def RegisterPythonwin(searchPaths):
  404.     """Knows how to register Pythonwin components
  405.     """
  406.     import regutil
  407.     suffix = IsDebug()
  408. #    FindRegisterApp("Pythonwin", "docview.py", searchPaths)
  409.  
  410.     FindRegisterHelpFile("PyWin32.chm", searchPaths, "Pythonwin Reference")
  411.     
  412.     FindRegisterPythonExe("pythonwin%s.exe" % suffix, searchPaths, "Pythonwin%s.exe" % suffix)
  413.  
  414.     fnamePythonwin = regutil.GetRegisteredExe("Pythonwin%s.exe" % suffix)
  415.     fnamePython = regutil.GetRegisteredExe("Python%s.exe" % suffix)
  416.  
  417.     regutil.RegisterShellCommand("Edit", QuotedFileName(fnamePythonwin)+" /edit \"%1\"")
  418.     regutil.RegisterDDECommand("Edit", "Pythonwin", "System", '[self.OpenDocumentFile(r"%1")]')
  419.  
  420.     FindRegisterPackage("pywin", "__init__.py", searchPaths, "Pythonwin")
  421. #    FindRegisterModule("win32ui", "win32ui%s.pyd" % suffix, searchPaths)
  422. #    FindRegisterModule("win32uiole", "win32uiole%s.pyd" % suffix, searchPaths)
  423.     
  424.     regutil.RegisterFileExtensions(defPyIcon=fnamePythonwin+",0", 
  425.                                    defPycIcon = fnamePythonwin+",5",
  426.                                    runCommand = QuotedFileName(fnamePython)+" \"%1\" %*")
  427.  
  428. def UnregisterPythonwin():
  429.     """Knows how to unregister Pythonwin components
  430.     """
  431.     import regutil
  432.     regutil.UnregisterNamedPath("Pythonwin")
  433.     regutil.UnregisterHelpFile("Pythonwin.hlp")
  434.     regutil.UnregisterHelpFile("PyWin32.chm")
  435.  
  436.     suffix = IsDebug()
  437.     regutil.UnregisterPythonExe("pythonwin%s.exe" % suffix)
  438.     
  439.     #regutil.UnregisterShellCommand("Edit")
  440.  
  441.     regutil.UnregisterModule("win32ui")
  442.     regutil.UnregisterModule("win32uiole")
  443.     
  444.  
  445. def RegisterWin32com(searchPaths):
  446.     """Knows how to register win32com components
  447.     """
  448.     import win32api
  449. #    import ni,win32dbg;win32dbg.brk()
  450.     corePath = FindRegisterPackage("win32com", "olectl.py", searchPaths)
  451.     if corePath:
  452.         FindRegisterHelpFile("PyWin32.chm", searchPaths + [corePath+"\\win32com"], "Python COM Reference")
  453.         suffix = IsDebug()
  454.         ver_str = hex(sys.hexversion)[2] + hex(sys.hexversion)[4]
  455.         # pythoncom now has a .py stub
  456.         FindRegisterModule("pythoncom", "pythoncom%s%s.dll" % (ver_str, suffix), [win32api.GetSystemDirectory(), '.'])
  457.  
  458. usage = """\
  459. regsetup.py - Setup/maintain the registry for Python apps.
  460.  
  461. Run without options, (but possibly search paths) to repair a totally broken
  462. python registry setup.  This should allow other options to work.
  463.  
  464. Usage:   %s [options ...] paths ...
  465. -p packageName  -- Find and register a package.  Looks in the paths for
  466.                    a sub-directory with the name of the package, and
  467.                    adds a path entry for the package.
  468. -a appName      -- Unconditionally add an application name to the path.
  469.                    A new path entry is create with the app name, and the
  470.                    paths specified are added to the registry.
  471. -c              -- Add the specified paths to the core Pythonpath.
  472.                    If a path appears on the core path, and a package also 
  473.                    needs that same path, the package will not bother 
  474.                    registering it.  Therefore, By adding paths to the 
  475.                    core path, you can avoid packages re-registering the same path.  
  476. -m filename     -- Find and register the specific file name as a module.
  477.                    Do not include a path on the filename!
  478. --shell         -- Register everything with the Win95/NT shell.
  479. --pythonwin     -- Find and register all Pythonwin components.
  480. --unpythonwin   -- Unregister Pythonwin
  481. --win32com      -- Find and register all win32com components
  482. --upackage name -- Unregister the package
  483. --uapp name     -- Unregister the app (identical to --upackage)
  484. --umodule name  -- Unregister the module
  485.  
  486. --description   -- Print a description of the usage.
  487. --examples      -- Print examples of usage.
  488. """ % sys.argv[0]
  489.  
  490. description="""\
  491. If no options are processed, the program attempts to validate and set 
  492. the standard Python path to the point where the standard library is
  493. available.  This can be handy if you move Python to a new drive/sub-directory,
  494. in which case most of the options would fail (as they need at least string.py,
  495. os.py etc to function.)
  496. Running without options should repair Python well enough to run with 
  497. the other options.
  498.  
  499. paths are search paths that the program will use to seek out a file.
  500. For example, when registering the core Python, you may wish to
  501. provide paths to non-standard places to look for the Python help files,
  502. library files, etc.  When registering win32com, you should pass paths
  503. specific to win32com.
  504.  
  505. See also the "regcheck.py" utility which will check and dump the contents
  506. of the registry.
  507. """
  508.  
  509. examples="""\
  510. Examples:
  511. "regsetup c:\\wierd\\spot\\1 c:\\wierd\\spot\\2"
  512. Attempts to setup the core Python.  Looks in some standard places,
  513. as well as the 2 wierd spots to locate the core Python files (eg, Python.exe,
  514. python14.dll, the standard library and Win32 Extensions.
  515.  
  516. "regsetup --win32com"
  517. Attempts to register win32com.  No options are passed, so this is only
  518. likely to succeed if win32com is already successfully registered, or the
  519. win32com directory is current.  If neither of these are true, you should pass
  520. the path to the win32com directory.
  521.  
  522. "regsetup -a myappname . .\subdir"
  523. Registers a new Pythonpath entry named myappname, with "C:\\I\\AM\\HERE" and
  524. "C:\\I\\AM\\HERE\subdir" added to the path (ie, all args are converted to
  525. absolute paths)
  526.  
  527. "regsetup -c c:\\my\\python\\files"
  528. Unconditionally add "c:\\my\\python\\files" to the 'core' Python path.
  529.  
  530. "regsetup -m some.pyd \\windows\\system"
  531. Register the module some.pyd in \\windows\\system as a registered
  532. module.  This will allow some.pyd to be imported, even though the
  533. windows system directory is not (usually!) on the Python Path.
  534.  
  535. "regsetup --umodule some"
  536. Unregister the module "some".  This means normal import rules then apply
  537. for that module.
  538. """
  539.  
  540. if __name__=='__main__':
  541.     if len(sys.argv)>1 and sys.argv[1] in ['/?','-?','-help','-h']:
  542.         print usage
  543.     elif len(sys.argv)==1 or not sys.argv[1][0] in ['/','-']:
  544.         # No args, or useful args.
  545.         searchPath = sys.path[:]
  546.         for arg in sys.argv[1:]:
  547.             searchPath.append(arg)
  548.         # Good chance we are being run from the "regsetup.py" directory.
  549.         # Typically this will be "\somewhere\win32\Scripts" and the 
  550.         # "somewhere" and "..\Lib" should also be searched.
  551.         searchPath.append("..\\Build")
  552.         searchPath.append("..\\Lib")
  553.         searchPath.append("..")
  554.         searchPath.append("..\\..")
  555.  
  556.                 # for developers:
  557.                 # also search somewhere\lib, ..\build, and ..\..\build
  558.         searchPath.append("..\\..\\lib")
  559.         searchPath.append("..\\build")
  560.         searchPath.append("..\\..\\pcbuild")
  561.  
  562.         print "Attempting to setup/repair the Python core"
  563.         
  564.         SetupCore(searchPath)
  565.         RegisterShellInfo(searchPath)    
  566.         # Check the registry.
  567.         print "Registration complete - checking the registry..."
  568.         import regcheck
  569.         regcheck.CheckRegistry()
  570.     else:
  571.         searchPaths = []
  572.         import getopt, string
  573.         opts, args = getopt.getopt(sys.argv[1:], 'p:a:m:c', 
  574.             ['pythonwin','unpythonwin','win32com','shell','upackage=','uapp=','umodule=','description','examples'])
  575.         for arg in args:
  576.             searchPaths.append(arg)
  577.         for o,a in opts:
  578.             if o=='--description':
  579.                 print description
  580.             if o=='--examples':
  581.                 print examples
  582.             if o=='--shell':
  583.                 print "Registering the Python core."
  584.                 RegisterShellInfo(searchPaths)
  585.             if o=='--pythonwin':
  586.                 print "Registering Pythonwin"
  587.                 RegisterPythonwin(searchPaths)
  588.             if o=='--win32com':
  589.                 print "Registering win32com"
  590.                 RegisterWin32com(searchPaths)
  591.             if o=='--unpythonwin':
  592.                 print "Unregistering Pythonwin"
  593.                 UnregisterPythonwin()
  594.             if o=='-m':
  595.                 import os
  596.                 print "Registering module",a
  597.                 FindRegisterModule(os.path.splitext(a)[0],a, searchPaths)
  598.             if o=='--umodule':
  599.                 import os, regutil
  600.                 print "Unregistering module",a
  601.                 regutil.UnregisterModule(os.path.splitext(a)[0])
  602.             if o=='-p':
  603.                 print "Registering package", a
  604.                 FindRegisterPackage(a,None,searchPaths)
  605.             if o in ['--upackage', '--uapp']:
  606.                 import regutil
  607.                 print "Unregistering application/package", a
  608.                 regutil.UnregisterNamedPath(a)
  609.             if o=='-a':
  610.                 import regutil
  611.                 path = string.join(searchPaths,";")
  612.                 print "Registering application", a,"to path",path
  613.                 regutil.RegisterNamedPath(a,path)
  614.             if o=='-c':
  615.                 if not len(searchPaths):
  616.                     raise error, "-c option must provide at least one additional path"
  617.                 import win32api, regutil
  618.                 currentPaths = string.split(regutil.GetRegisteredNamedPath(None),";")
  619.                 oldLen = len(currentPaths)
  620.                 for newPath in searchPaths:
  621.                     if newPath not in currentPaths:
  622.                         currentPaths.append(newPath)
  623.                 if len(currentPaths)<>oldLen:
  624.                     print "Registering %d new core paths" % (len(currentPaths)-oldLen)
  625.                     regutil.RegisterNamedPath(None,string.join(currentPaths,";"))
  626.                 else:
  627.                     print "All specified paths are already registered."
  628.