fix: calculate autogen header locations every time.
#
# Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
# All rights reserved.
# This component and the accompanying materials are made available
# under the terms of the License "Eclipse Public License v1.0"
# which accompanies this distribution, and is available
# at the URL "http://www.eclipse.org/legal/epl-v10.html".
#
# Initial Contributors:
# Nokia Corporation - initial contribution.
#
# Contributors:
#
# Description:
# Creates CBR tool compatible cache files from SBSv2 .whatlog variant output
#
import sys
import os
from optparse import OptionParser
import xml.parsers.expat
import re
# Global dictionary of ComponentReleasable objects, keyed on bld.inf file
BuildReleasables = {}
# Provide a means to form "traditional" ABLD-like build platforms and variants from SBSv2 configurations
ConfigMatch = re.compile(r'^(?P<PLATFORM>\w+)_(?P<VARIANT>\w+)(\.((?P<PLATFORMADD>smp)|\w+))*')
WinscwTreeMatch = re.compile(r'[\\|\/]epoc32[\\|\/]release[\\|\/]winscw[\\|\/](?P<VARIANT>(urel|udeb))[\\|\/]', re.IGNORECASE)
WinDriveMatch = re.compile(r'[A-Za-z]:')
# $self->{abldcache}->{'<bld.inf location> export -what'} =
# $self->{abldcache}->{'<bld.inf location> <phase> <platform> <variant> -what'} =
# $self->{abldcache}->{'plats'} =
CacheGroupPrefix = "$self->{abldcache}->{\'"
CacheGroupSuffix = "\'} =\n"
CacheExportGroup = CacheGroupPrefix+"%s export -what"+CacheGroupSuffix
CacheBuildOutputGroup = CacheGroupPrefix+"%s %s %s %s -what"+CacheGroupSuffix
CachePlatsGroup = CacheGroupPrefix+"plats"+CacheGroupSuffix
CacheListOpen = "\t[\n"
CacheListItem = "\t\'%s\'"
CacheListItemPair = "\t[\'%s\', \'%s\']"
CacheListClose = "\t];\n\n"
class ComponentReleasable(object):
"""Wraps up a bld.inf file in terms of its packagable releasable output."""
# If EPOCROOT is set, provide a means to confirm that potentially publishable releasables live under EPOCROOT/epoc32
ReleaseTreeMatch = None
if os.environ.has_key("EPOCROOT"):
ReleaseTreeMatch = re.compile(r'\"*'+os.path.abspath(os.path.join(os.environ["EPOCROOT"],"epoc32")).replace('\\',r'\/').replace('\/',r'[\\|\/]+')+r'[\\|\/]+', re.IGNORECASE)
def __init__(self, aBldInfFile, aVerbose=False):
self.__BldInfFile = aBldInfFile
self.__Verbose = aVerbose
self.__Exports = {}
self.__BuildOutput = {}
self.__Platforms = {}
def __IsReleasableItem(self, aBuildItem):
if self.ReleaseTreeMatch and self.ReleaseTreeMatch.match(aBuildItem):
return True
if self.__Verbose:
print "Discarding: \'%s\' from \'%s\' as not in the release tree." % (aBuildItem, self.__BldInfFile)
return False
def __StoreBuildItem(self, aPlatform, aVariant, aBuildItem):
if not self.__BuildOutput.has_key(aPlatform):
self.__BuildOutput[aPlatform] = {}
if aPlatform != "ALL":
self.__Platforms[aPlatform.upper()] = 1
if not self.__BuildOutput[aPlatform].has_key(aVariant):
self.__BuildOutput[aPlatform][aVariant] = {}
if aBuildItem:
self.__BuildOutput[aPlatform][aVariant][aBuildItem] = 1
def AddExport(self, aDestination, aSource):
if not self.__IsReleasableItem(aDestination):
return
self.__Exports[aDestination] = aSource
def AddBuildOutput(self, aBuildItem, aPlatform="ALL", aVariant="ALL"):
if not self.__IsReleasableItem(aBuildItem):
return
if aPlatform != "ALL" and aVariant == "ALL":
self.__StoreBuildItem(aPlatform, "urel", aBuildItem)
self.__StoreBuildItem(aPlatform, "udeb", aBuildItem)
else:
self.__StoreBuildItem(aPlatform, aVariant, aBuildItem)
def Finalise(self):
# Re-visit the stored build items and, in the context of all build platforms having been processed for the
# component, copy platform-generic "ALL" output to the concrete build platform outputs
if self.__BuildOutput.has_key("ALL"):
allItems = self.__BuildOutput["ALL"]["ALL"].keys()
for platform in self.__BuildOutput.keys():
for variant in self.__BuildOutput[platform].keys():
for allItem in allItems:
self.__StoreBuildItem(platform, variant, allItem)
del self.__BuildOutput["ALL"]
def GetBldInf(self):
return self.__BldInfFile
def GetExports(self):
return self.__Exports
def GetBuildOutput(self):
return self.__BuildOutput
def GetPlatforms(self):
return self.__Platforms
def HasReleasables(self):
return (self.__BuildOutput or self.__Exports)
def error(aMessage):
sys.stderr.write("ERROR: sbsv2cache.py : %s\n" % aMessage)
sys.exit(1)
def processReleasableElement(aContext, aName, aValue, aVerbose):
bldinf = aContext["bldinf"]
mmp = aContext["mmp"]
config = aContext["config"]
platform = ""
variant = ""
configMatchResults = ConfigMatch.match(config)
if configMatchResults:
platform = configMatchResults.group('PLATFORM')
variant = configMatchResults.group('VARIANT')
if configMatchResults.group('PLATFORMADD'):
platform += configMatchResults.group('PLATFORMADD')
if not BuildReleasables.has_key(bldinf):
BuildReleasables[bldinf] = ComponentReleasable(bldinf, aVerbose)
componentReleasable = BuildReleasables[bldinf]
if aName == "export" :
componentReleasable.AddExport(aValue["destination"], aValue["source"])
elif aName == "member":
componentReleasable.AddExport(aValue.keys()[0], aContext["zipfile"])
elif aName == "build":
componentReleasable.AddBuildOutput(aValue.keys()[0], platform, variant)
elif aName == "resource" or aName == "bitmap":
item = aValue.keys()[0]
# Identify winscw urel/udeb specific resources, and store accordingly
winscwTreeMatchResult = WinscwTreeMatch.search(item)
if platform == "winscw" and winscwTreeMatchResult:
componentReleasable.AddBuildOutput(item, platform, winscwTreeMatchResult.group("VARIANT").lower())
else:
componentReleasable.AddBuildOutput(item, platform)
elif aName == "stringtable":
componentReleasable.AddBuildOutput(aValue.keys()[0])
def parseLog(aLog, aVerbose):
if not os.path.exists(aLog):
error("Log file %s does not exist." % aLog)
parser = xml.parsers.expat.ParserCreate()
parser.buffer_text = True
elementContext = {}
currentElement = []
def start_element(name, attributes):
if name == "whatlog" or name == "archive":
elementContext.update(attributes)
elif elementContext.has_key("bldinf"):
if name == "export":
# Exports are all attributes, so deal with them directly
processReleasableElement(elementContext, name, attributes, aVerbose)
else:
# Other elements wrap values, get these later
currentElement.append(name)
def end_element(name):
if name == "whatlog":
elementContext.clear()
elif name == "archive":
del elementContext["zipfile"]
def char_data(data):
if elementContext.has_key("bldinf") and currentElement:
processReleasableElement(elementContext, currentElement.pop(), {str(data):1}, aVerbose)
parser.StartElementHandler = start_element
parser.EndElementHandler = end_element
parser.CharacterDataHandler = char_data
try:
if aVerbose:
print "Parsing: " + aLog
parser.ParseFile(open(aLog, "r"))
except xml.parsers.expat.ExpatError, e:
error("Failure parsing log file \'%s\' (line %s)" % (aLog, e.lineno))
def normFileForCache(aFile):
normedFile = WinDriveMatch.sub("",aFile)
normedFile = normedFile.replace("/", "\\")
normedFile = normedFile.replace("\\", "\\\\")
normedFile = normedFile.replace("\\\\\\\\", "\\\\")
normedFile = normedFile.replace("\"", "")
return normedFile
def dumpCacheFileList(aCacheFileObject, aItems, aPairs=False):
numItems = len(aItems)
suffix = ",\n"
aCacheFileObject.write(CacheListOpen)
for item in aItems:
if aItems.index(item) == numItems-1:
suffix = "\n"
if aPairs:
aCacheFileObject.write((CacheListItemPair % (normFileForCache(item[0]), normFileForCache(item[1]))) + suffix)
else:
aCacheFileObject.write((CacheListItem % normFileForCache(item)) + suffix)
aCacheFileObject.write(CacheListClose)
def createCacheFile(aComponentReleasable, aOutputPath, aSourceExports, aVerbose):
if not aComponentReleasable.HasReleasables():
return
cacheFileDir = os.path.normpath(\
os.path.join(aOutputPath, \
WinDriveMatch.sub("",os.path.dirname(aComponentReleasable.GetBldInf())).lstrip(r'/').lstrip(r'\\')))
cacheFile = os.path.join(cacheFileDir, "cache")
bldInfLoc = WinDriveMatch.sub("",os.path.dirname(aComponentReleasable.GetBldInf())).replace("/", "\\")
if aVerbose:
print "Creating: " + cacheFile
if not os.path.exists(cacheFileDir):
os.makedirs(cacheFileDir)
try:
cacheFileObject = open(cacheFile, 'w')
exports = aComponentReleasable.GetExports()
if exports:
cacheFileObject.write(CacheExportGroup % bldInfLoc)
if aSourceExports:
dumpCacheFileList(cacheFileObject, exports.items(), True)
else:
dumpCacheFileList(cacheFileObject, exports.keys())
buildOutput = aComponentReleasable.GetBuildOutput()
if buildOutput:
for plat in buildOutput.keys():
# Most cache output is represented as if performed for the "abld target" phase, but tools platforms
# are presented as if performed by "abld build", and so must additionally replicate any exports
# performed for the component in their variant output
phase = "target"
additionalOutput = []
if plat == "tools" or plat == "tools2":
phase = "build"
if exports:
additionalOutput = exports.keys()
for variant in buildOutput[plat].keys():
cacheFileObject.write(CacheBuildOutputGroup % (bldInfLoc, phase, plat, variant))
dumpCacheFileList(cacheFileObject, buildOutput[plat][variant].keys() + additionalOutput)
cacheFileObject.write(CachePlatsGroup)
dumpCacheFileList(cacheFileObject, aComponentReleasable.GetPlatforms().keys())
cacheFileObject.close()
except IOError:
error("Failure creating cache file %s." % cacheFile)
def main():
parser = OptionParser(prog="sbsv2cache.py")
parser.add_option("-l", "--log", action="append", dest="logs", help="log file to parse for <whatlog/> wrapped content.")
parser.add_option("-o", "--outputpath", action="store", dest="outputpath", help="root location to generate cache files.")
parser.add_option("-s", "--sourceexports", action="store_true", default=False, dest="sourceexports", help="generate cache files where each element in the export array is a ['destination', 'source'] array rather than just a 'destination' element.")
parser.add_option("-v", "--verbose", action="store_true", default=False, dest="verbose", help="provide more information as things happen.")
(options, leftover_args) = parser.parse_args(sys.argv[1:])
if leftover_args or not options.logs or not options.outputpath:
parser.print_help()
sys.exit(1)
print "sbsv2cache: started"
# Parse build logs to populate the BuildReleasables dictionary
for log in options.logs:
parseLog(os.path.abspath(log), options.verbose)
# Finalise components in BuildReleasables and create cache files as we go
for component in BuildReleasables.keys():
BuildReleasables[component].Finalise()
createCacheFile(BuildReleasables[component], os.path.abspath(options.outputpath), options.sourceexports, options.verbose)
print "sbsv2cache: finished"
if __name__ == "__main__":
main()