Python EmergeDebug.die方法代码示例

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
    def make( self ):
        """implements the make step for cmake projects"""

        self.enterBuildDir()
        utils.prependPath(self.rootdir, self.envPath)

        if self.subinfo.options.cmake.openIDE:
            if compiler.isMSVC2008():
                command = "start %s" % self.__slnFileName()
            elif compiler.isMSVC2010():
                command = "start vcexpress %s" % self.__slnFileName()
        elif self.subinfo.options.cmake.useIDE:
            if compiler.isMSVC2008():
                command = "vcbuild /M1 %s \"%s|WIN32\"" % (self.__slnFileName(), self.buildType())
            elif compiler.isMSVC2015():
                command = "msbuild /maxcpucount %s /t:ALL_BUILD /p:Configuration=\"%s\"" % (self.__slnFileName(), self.buildType())
            elif compiler.isMSVC2010():
                EmergeDebug.die("has to be implemented");
        elif self.subinfo.options.cmake.useCTest:
            # first make clean
            self.system( self.makeProgramm + " clean", "make clean" )
            command = "ctest -M " + "Nightly" + " -T Start -T Update -T Configure -T Build -T Submit"
        else:
            command = ' '.join([self.makeProgramm, self.makeOptions()])


        return self.system( command, "make" )

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
def PackagerFactory(parent, packagerType):
    """provides multi packager type api
    return PackagerBase derived instance for recent settings"""
    EmergeDebug.debug("PackagerFactory called", 2)
    packagers = []

    if packagerType:
        for packagerClass in packagerType:
            if not issubclass(packagerClass, PackagerBase):
                EmergeDebug.die("PackagerFactory: unsupported packager %s" % packagerClass)
            else:
                packager = packagerClass()
                init(packager, parent)
                packagers.append(packager)
    else:
        # automatic detection
        packager = InnoSetupPackager()
        init(packager, parent)

        if packager.configFile() != None:
            packagers.append(packager)

        # default packager
        if len(packagers) == 0:
            packager = KDEWinPackager()
            init(packager, parent)
            packagers.append(packager)
    return packagers

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
 def __makeFileGenerator(self):
     """return cmake related make file generator"""
     if self.supportsNinja and emergeSettings.getboolean("Compile","UseNinja", False):
         return "Ninja"
     if compiler.isMSVC2015():
         if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
             return "Visual Studio 14 2015" + " Win64" if compiler.isX64() else ""
         else:
             return "NMake Makefiles"
     if compiler.isMSVC2010():
         if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
             return "Visual Studio 10"
         else:
             return "NMake Makefiles"
     elif compiler.isMSVC2008():
         if self.subinfo.options.cmake.useIDE or self.subinfo.options.cmake.openIDE:
             return "Visual Studio 9 2008"
         else:
             return "NMake Makefiles"
     elif compiler.isMSVC() or compiler.isIntel():
         return "NMake Makefiles"
     elif compiler.isMinGW():
         return "MinGW Makefiles"
     else:
         EmergeDebug.die("unknown %s compiler" % self.compiler())

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
def SourceFactory(settings):
    """ return sourceBase derived instance for recent settings"""
    EmergeDebug.trace("SourceFactory called", 1)
    source = None

    if settings.hasTarget():
        if settings.hasMultipleTargets():
            url = settings.targetAt(0)
        else:
            url = settings.target()
        source = ArchiveSource(settings)

    ## \todo move settings access into info class
    if settings.hasSvnTarget():
        url = settings.svnTarget()
        sourceType = utils.getVCSType( url )
        if sourceType == "svn":
            source = SvnSource(settings)
        elif sourceType == "hg":
            source = HgSource(settings)
        elif sourceType == "git":
            source = GitSource(settings)

    if source == None:
        EmergeDebug.die("none or unsupported source system set")
    if not source.subinfo:
        source.subinfo = settings
    source.url = url
    return source

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
    def inner(*args, **argv):
        logdir = emergeSettings.get( "General", "EMERGE_LOG_DIR", "" )

        if logdir == "":
            return fn(*args, **argv)

        if os.path.isfile(logdir):
            EmergeDebug.die("EMERGE_LOG_DIR %s is a file" % logdir)

        if not os.path.exists(logdir):
            try:
                os.mkdir(logdir)
            except OSError:
                EmergeDebug.die("EMERGE_LOG_DIR %s can not be created" % logdir)

        logfile = ""
        for a in args:
            logfile += "%s-" % a
        logfile = logfile[:-1]#drop last -
        logfile = "%s.log" % logfile.replace("/","_").replace("\\","_")

        logfile = os.path.join(logdir, logfile)
        f = open(logfile, "at")
        try:
            old_out = sys.stdout
            old_err = sys.stderr
            sys.stdout = f
            sys.stderr = f
            return fn(*args, **argv)
        finally:
            sys.stdout = old_out
            sys.stderr = old_err
            f.close()

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
def embedManifest(executable, manifest):
    '''
       Embed a manifest to an executable using either the free
       kdewin manifest if it exists in dev-utils/bin
       or the one provided by the Microsoft Platform SDK if it
       is installed'
    '''
    if not os.path.isfile(executable) or not os.path.isfile(manifest):
        # We die here because this is a problem with the portage files
        EmergeDebug.die("embedManifest %s or %s do not exist" % (executable, manifest))
    EmergeDebug.debug("embedding ressource manifest %s into %s" % \
          (manifest, executable), 2)
    mtExe = None
    mtExe = os.path.join(EmergeStandardDirs.emergeRoot(), "dev-utils", "bin", "mt.exe")

    if(not os.path.isfile(mtExe)):
        # If there is no free manifest tool installed on the system
        # try to fallback on the manifest tool provided by visual studio
        sdkdir = regQuery("HKLM\SOFTWARE\Microsoft\Microsoft SDKs\Windows",
            "CurrentInstallFolder")
        if not sdkdir:
            EmergeDebug.debug("embedManifest could not find the Registry Key"
                  " for the Windows SDK", 2)
        else:
            mtExe = r'%s' % os.path.join(sdkdir, "Bin", "mt.exe")
            if not os.path.isfile(os.path.normpath(mtExe)):
                EmergeDebug.debug("embedManifest could not find a mt.exe in\n\t %s" % \
                      os.path.dirname(mtExe), 2)
    if os.path.isfile(mtExe):
        return system([mtExe, "-nologo", "-manifest", manifest,
            "-outputresource:%s;1" % executable])
    else:
        return system(["mt", "-nologo", "-manifest", manifest,
            "-outputresource:%s;1" % executable])

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
 def isInstalled(self):
     if not self._isInstalled:
         self._isInstalled = self.__isInstalled()
         if not self._isInstalled:
             EmergeDebug.die("could not find installed nsis package, "
                        "you can install it using emerge nsis or"
                        "download and install it from "
                        "http://sourceforge.net/projects/nsis/")

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
    def unpack(self):
        if not CMakePackageBase.unpack(self):
            return False
        # Check whether compiler is mingw or not...
        if self.compiler() != "mingw" and self.compiler() != "mingw4":
            EmergeDebug.die("This package is currently only compiled with mingw.")

        return True

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
def getSimpleCompilerName():
    if isMinGW():
        return "mingw64"
    elif isMSVC():
        return "msvc"
    elif isIntel():
        return "intel"
    else:
        EmergeDebug.die("Unknown Compiler %s" % _compiler())

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
def getCompilerName():
    if isMinGW():
        return "mingw-w64"
    elif isMSVC():
        return _compiler()
    elif isIntel():
        return "intel-%s-%s" % (os.getenv("TARGET_ARCH"), os.getenv("TARGET_VS"))
    else:
        EmergeDebug.die("Unknown Compiler %s" % _compiler())

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
def getDirname( category, package ):
    """ return absolute pathname for a given category and package """
    subpackage, package = getSubPackage( category, package )
    if category and package:
        if subpackage:
            return os.path.join( rootDirForPackage( category, subpackage ), category, subpackage, package )
        else:
            return os.path.join( rootDirForPackage( category, package ), category, package )
    else:
        EmergeDebug.die("broken category or package %s/%s" % (category, package))

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
def rootDirForCategory( category ):
    """this function should return the portage directory where it finds the first occurance of the category

throws exception if not found
"""
    # this function should return the portage directory where it finds the
    # first occurance of a category or the default value
    for i in rootDirectories():
        if category and os.path.exists( os.path.join( i, category ) ):
            return i
    EmergeDebug.die("can't find category %s" % category)

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
    def checkoutDir( self, dummyIndex=0 ):
        EmergeDebug.trace("VersionSystemSourceBase checkoutDir", 2)
        if self.subinfo.hasSvnTarget():
            sourcedir = os.path.join(  EmergeStandardDirs.gitDir(), self.package )
        else:
            EmergeDebug.die("svnTarget property not set for this target")

        if self.subinfo.targetSourceSuffix() != None:
            sourcedir = "%s-%s" % (sourcedir, self.subinfo.targetSourceSuffix())

        return os.path.abspath(sourcedir)

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
 def __init__( self ):
     BuildSystemBase.__init__(self, "qmake")
     self.platform = ""
     if compiler.isMSVC():
         self.platform = "win32-%s" % self.compiler()
     elif compiler.isMinGW():
         self.platform = "win32-g++"
     elif compiler.isIntel():
         self.platform = "win32-icc"
     else:
         EmergeDebug.die("QMakeBuildSystem: unsupported compiler platform %s" % self.compiler())

# 需要导入模块: import EmergeDebug [as 别名]
# 或者: from EmergeDebug import die [as 别名]
 def __init__( self, parent=None ):
     self.parent = self
     if parent:
         self.parent = parent
     self.output = False
     self.outFile = None
     self.graphVizInstallPath = None
     if not self.isInstalled():
         utils.system("emerge.bat graphviz")
         if not self.isInstalled():
             EmergeDebug.die("could not find installed graphviz package, you may download and install it from http://www.graphviz.org/Download.php")