sl@0: # Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
sl@0: # All rights reserved.
sl@0: # This component and the accompanying materials are made available
sl@0: # under the terms of "Eclipse Public License v1.0"
sl@0: # which accompanies this distribution, and is available
sl@0: # at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: #
sl@0: # Initial Contributors:
sl@0: # Nokia Corporation - initial contribution.
sl@0: #
sl@0: # Contributors:
sl@0: #
sl@0: # Description:
sl@0: # Tools to parse mbc files
sl@0: # NOTE: There is unit etc test code for this in testMbcUtils.py
sl@0: # Any changes to this file should be checked with "python testMbcUtils.py"
sl@0: # Also note that the test code coverage is not 100%
sl@0: #
sl@0: 
sl@0: import re
sl@0: import types
sl@0: import os
sl@0: 
sl@0: class InvalidInput(Exception):
sl@0:     """Raised for invalid data in files"""
sl@0: 
sl@0:     def __init__(self, badInput):
sl@0:         self.__badInput = badInput
sl@0: 
sl@0:     def __str__(self):
sl@0:         return "InvalidInput(%s)" % self.__badInput
sl@0: 
sl@0: class Unimplemented(Exception):
sl@0:     """Raised for features we don't cover"""
sl@0: 
sl@0:     def __init__(self, msg):
sl@0:         self.__msg = msg
sl@0: 
sl@0:     def __str__(self):
sl@0:         return "Unimplemented(%s)" % self.__msg
sl@0: 
sl@0: class InvalidArg(Exception):
sl@0:     """Raised for invalid data in argument"""
sl@0: 
sl@0:     def __init__(self, badArg):
sl@0:         self.__badArg = badArg
sl@0: 
sl@0:     def __str__(self):
sl@0:         return "InvalidArg(%s)" % self.__badArg
sl@0: 
sl@0: class MissingFile(Exception):
sl@0:     "Raised when we expect a file and it does not exist"
sl@0: 
sl@0:     def __init__(self, badFname):
sl@0:         self.__badFname = badFname
sl@0: 
sl@0:     def __str__(self):
sl@0:         return "MissingFile(%s)" % self.__badFname
sl@0: 
sl@0: class _MbcParser(object):
sl@0:     """Parse an mbc file, given by name. Return as tuple of the given categories, coupled with the filename."""
sl@0: 
sl@0:     # __slots__ = ["__fname", "__result", "__state"]
sl@0: 
sl@0:     __nullState = -1
sl@0:     __dirsSectionState = 1 # assumed to be same as tuple index
sl@0:     __optionDirsSectionState = 2 # assumed to be same as tuple index
sl@0:     __commandSectionState = 3 # assumed to be same as tuple index
sl@0: 
sl@0:     def __init__(self, fname):
sl@0:         self.__fname = fname
sl@0:         self.__dirname = os.path.dirname(fname)
sl@0:         self.__result = None
sl@0:         self.__state = _MbcParser.__nullState
sl@0:         self.__executed = False
sl@0: 
sl@0:     def execute(self):
sl@0:         "Call to generate the result"
sl@0:         self.__reset(self.__fname) # initialize __result etc
sl@0:         self.__openAndParse()
sl@0:         self.__executed = True
sl@0: 
sl@0:     def __call__(self):
sl@0:         if not self.__executed:
sl@0:             self.execute()
sl@0:         return self.__result
sl@0: 
sl@0:     def __reset(self, fname=None):
sl@0:         self.__result = (fname,[],[],[])
sl@0: 
sl@0:     def __openAndParse(self):
sl@0:         "Open file and then parse line-by-line"
sl@0:         # note deliberately use old version to avoid 2.4 issue. Going foreard, "with" seems to be the correct approach
sl@0:         # could perhaps write this better using a parser module, or more extensive use of re, but this is not seen as module specific
sl@0:         inputFile = open(self.__fname)
sl@0:         try:
sl@0:             for line in inputFile:
sl@0:                 self.__parseLine(line)
sl@0:         finally:
sl@0:             inputFile.close()
sl@0: 
sl@0:     def __parseLine(self,line):
sl@0:         # initially we want the bit of the line up to the first // or \n
sl@0:         # TODO should be able to do in one re?
sl@0:         lookforeoln = re.match(r"(.*)$", line) # lose any \n
sl@0:         if lookforeoln:
sl@0:             line = lookforeoln.group(1)
sl@0:         lookforcomment = re.match(r"(.*)//.*", line)
sl@0:         if lookforcomment:
sl@0:             line = lookforcomment.group(1)
sl@0:         line.strip() # remove spaces at start and end
sl@0:         if not line:
sl@0:             # skip blank line
sl@0:             return;
sl@0:         if line == "SECTION_DIRS":
sl@0:             self.__state = _MbcParser.__dirsSectionState
sl@0:         elif line == "SECTION_OPTIONALDIRS":
sl@0:             self.__state = _MbcParser.__optionDirsSectionState
sl@0:         elif line == "SECTION_COMMANDS":
sl@0:             self.__state = _MbcParser.__commandSectionState
sl@0:         else:
sl@0:             # for dirs or optionDirs section we are after a single string to treat as directory. don't check here
sl@0:             if ((self.__state == _MbcParser.__dirsSectionState) or
sl@0:                 (self.__state == _MbcParser.__optionDirsSectionState)):
sl@0:                 matchre = re.match(r'[_\-a-z0-9\\/\.]+$', line, re.IGNORECASE)
sl@0:                 if matchre:
sl@0:                     # we have a match - add to the tuple
sl@0:                     matchresult = line # no need to decode. whole thing is the line
sl@0:                     if matchresult[0] != "\\":
sl@0:                         # relative path - need to add folder name
sl@0:                         matchresult = os.path.abspath(os.path.join(self.__dirname, matchresult))
sl@0:                     self.__result[self.__state].append(matchresult)
sl@0:                 else:
sl@0:                     raise InvalidInput (line)
sl@0:             elif self.__state == _MbcParser.__commandSectionState:
sl@0:                 matchre = re.match(r'oneoff\s+([_\-a-z0-9\\/\.]+)\s+(.+)$', line, re.IGNORECASE)
sl@0:                 if matchre:
sl@0:                     # append tuple of (directory, command). Comes as (group(1),group(2)) but have to
sl@0:                     # convert relative directory we get to absolute if required
sl@0:                     matchDir = matchre.group(1)
sl@0:                     if matchDir[0] != "\\":
sl@0:                         # relative path- need to add folder name
sl@0:                         matchDir = os.path.abspath(os.path.join(self.__dirname, matchDir))
sl@0:                     self.__result[self.__state].append((matchDir,matchre.group(2)))
sl@0:                 else:
sl@0:                     raise InvalidInput (line)
sl@0: 
sl@0: class _MbcListHandle(object):
sl@0:     """Handle a list or tuple of filenames, recursively list of tuples as produced by _MbcParser"""
sl@0: 
sl@0:     def __init__(self, fnameList):
sl@0:         """Assume fnameList is a container. Always generate a list"""
sl@0:         self.__fnameList = fnameList
sl@0:         self.__result = []
sl@0:         self.__executed = False
sl@0: 
sl@0:     def execute(self):
sl@0:         for fname in self.__fnameList:
sl@0:             parser = MbcParser(fname)
sl@0:             parser.execute()
sl@0:             self.__result.append(parser())
sl@0:         self.__exectuted = True
sl@0: 
sl@0:     def __call__(self):
sl@0:         if not self.__exectuted:
sl@0:             self.execute()
sl@0:         return self.__result
sl@0: 
sl@0: class MbcParser(object):
sl@0:     """Given a list of or a filename, return equivalent structure with each filename replaced by tuple of content
sl@0: 
sl@0:     tuple elements are:
sl@0:     0 - filename
sl@0:     1 - main directories
sl@0:     2 - optional directories
sl@0:     3 - oneoff"""
sl@0: 
sl@0:     def __init__(self, fnameOrList):
sl@0:         self.__fnameOrList = fnameOrList
sl@0:         self.__result = None
sl@0:         self.__executed = False
sl@0: 
sl@0:     def execute(self):
sl@0:         fnameOrList = self.__fnameOrList
sl@0:         if isinstance(fnameOrList, list) or isinstance(fnameOrList, tuple):
sl@0:             parser = _MbcListHandle(fnameOrList)
sl@0:             parser.execute()
sl@0:             self.__result = parser()
sl@0:         elif isinstance(fnameOrList, types.StringTypes):
sl@0:             parser = _MbcParser(fnameOrList)
sl@0:             parser.execute()
sl@0:             self.__result = parser()
sl@0:         else:
sl@0:             raise InvalidArg(fnameOrList)
sl@0: 
sl@0:     def __call__(self):
sl@0:         if not self.__executed:
sl@0:             self.execute()
sl@0:         return self.__result
sl@0: 
sl@0: class GetFolderList(object):
sl@0:     """Given output of MbcParser(), produces list of tuples in the format:
sl@0: 
sl@0:     0 - Element is folder if True (only thing currently supported)
sl@0:     1 - folder
sl@0:     2 - comment to use in generated file including original filename
sl@0: 
sl@0:     If folder is optional, will only be added if exists - actually if nameToCheck exists in folder.
sl@0:     If folder is not optional, and does not exist, this will raise an error.
sl@0:     """
sl@0: 
sl@0:     def __init__(self, inputList, nameToCheck="bld.inf"):
sl@0:         if isinstance(inputList, tuple):
sl@0:             # single element "list" from MbcParser is not always a list!
sl@0:             self.__list = [inputList]
sl@0:         else:
sl@0:             self.__list = inputList
sl@0:         self.__nameToCheck = nameToCheck
sl@0:         self.__result = []
sl@0:         self.__exectuted = False
sl@0: 
sl@0:     def execute(self):
sl@0:         self.__result = []
sl@0:         self.__genResult()
sl@0:         self.__executed = True
sl@0: 
sl@0:     def __genResult(self):
sl@0:         "Process whole list"
sl@0:         for listEle in self.__list:
sl@0:             self.__processEle(listEle)
sl@0: 
sl@0:     def __processEle(self, listEle):
sl@0:         "Process single element in input list"
sl@0:         (fname, dirs, optDirs, commands) = listEle
sl@0:         for dir in dirs:
sl@0:             combinedFname = os.path.join(dir, self.__nameToCheck)
sl@0:             exists = os.path.exists(combinedFname)
sl@0:             if not exists:
sl@0:                 raise MissingFile(combinedFname)
sl@0:             self.__result.append((True, dir, "From %s"%fname))
sl@0:         for dir in optDirs:
sl@0:             combinedFname = os.path.join(dir, self.__nameToCheck)
sl@0:             exists = os.path.exists(combinedFname)
sl@0:             if exists:
sl@0:                 self.__result.append((True, dir, "From %s"%fname))
sl@0:             else:
sl@0:                 self.__result.append((True, None, """Skip "%s" from %s"""%(dir,fname)))
sl@0:         if commands:
sl@0:             raise Unimplemented("No support for oneoff - %s" % str(commands))
sl@0: 
sl@0:     def __call__(self):
sl@0:         if not self.__exectuted:
sl@0:             self.execute()
sl@0:         return self.__result
sl@0: 
sl@0: ## Minimal example configuration file as we have to produce
sl@0: ## See http://developer.symbian.com/wiki/x/rgD6Bg
sl@0: ##
sl@0: ##<SystemDefinition name="BLAH" schema="2.0.0">
sl@0: ##  <systemModel>
sl@0: ##    <layer name="NEW_CUSTOM_LAYER">
sl@0: ##      <collection name="Fake Collection">
sl@0: ##	<component name="examples">
sl@0: ##	  <unit bldFile="C:\Symbian\Carbide2\workspace\hello_whirled\group" />
sl@0: ##	  <unit bldFile="C:\Symbian\Carbide2\workspace\hello_abld\group" />
sl@0: ##	</component>
sl@0: ##      </collection>
sl@0: ##    </layer>
sl@0: ##  </systemModel>
sl@0: ##</SystemDefinition>
sl@0: 
sl@0: 
sl@0: class ConfigFileGenerator(object):
sl@0:     """Generate xml config file given output from GetFolderList
sl@0: 
sl@0:     Output corresponds to the example in source
sl@0:     folderList is input from GetFolderList
sl@0:     outputStream is either filename or assumed to be an open file or StringIO"""
sl@0: 
sl@0:     def __init__(self, folderList, outputStream):
sl@0:         self.__folderList = folderList
sl@0:         self.__streamParam = outputStream
sl@0:         self.__streamIsLocal = False
sl@0:         self.__stream = None
sl@0: 
sl@0:     def __initStream(self):
sl@0:         "Work out stream to use. Open stream if required"
sl@0: 
sl@0:         if isinstance(self.__streamParam, basestring):
sl@0:             # unicode or normal string
sl@0:             self.__streamIsLocal = True
sl@0:             self.__stream = open(self.__streamParam, "w")
sl@0:         else:
sl@0:             self.__streamIsLocal = False
sl@0:             self.__stream = self.__streamParam
sl@0: 
sl@0:     def __closeStream(self):
sl@0:         "If stream is local, close it"
sl@0: 
sl@0:         if self.__streamIsLocal:
sl@0:             self.__stream.close()
sl@0: 
sl@0:         self.__stream = None # orphan if needs be
sl@0:         self.__streamIsLocal = False
sl@0: 
sl@0:     def write(self):
sl@0:         "Called will write output to stream"
sl@0: 
sl@0:         try:
sl@0:             self.__initStream()
sl@0:             self.__writeHeaderBit()
sl@0:             self.__writeFolderList()
sl@0:             self.__writeTailBit()
sl@0:         except: # TODO not sure we need this - if we ommit is finally clause run?
sl@0:             raise
sl@0:         finally:
sl@0:             self.__closeStream()
sl@0: 
sl@0:     def __writeHeaderBit(self):
sl@0:         "Write bit of xml before the folder list"
sl@0:         # these names all come from the original. Seems no need to vary
sl@0:         # this code is 9.5 based
sl@0:         print >> self.__stream, r"""<SystemDefinition name="BLAH" schema="2.0.0">"""
sl@0:         print >> self.__stream, r"""  <systemModel>"""
sl@0:         print >> self.__stream, r"""    <layer name="NEW_CUSTOM_LAYER">"""
sl@0:         print >> self.__stream, r"""      <collection name="Fake Collection">"""
sl@0:         print >> self.__stream, r"""        <component name="Fake Multimedia">"""
sl@0: 
sl@0:     def __writeTailBit(self):
sl@0:         "write bit of xml after the folder list"
sl@0:         print >> self.__stream, r"""        </component>"""
sl@0:         print >> self.__stream, r"""      </collection>"""
sl@0:         print >> self.__stream, r"""    </layer>"""
sl@0:         print >> self.__stream, r"""  </systemModel>"""
sl@0:         print >> self.__stream, r"""</SystemDefinition>"""
sl@0: 
sl@0:     def __writeFolderList(self):
sl@0:         for ele in self.__folderList:
sl@0:             str = self.__strForListEle(ele)
sl@0:             if str:
sl@0:                 print >> self.__stream, "          %s" % str
sl@0: 
sl@0:     def __strForListEle(self, ele):
sl@0:         (isFolder, folder, comment) = ele # break down tuple
sl@0:         result = None
sl@0:         if isFolder:
sl@0:             if folder:
sl@0:                 result = r"""<unit bldFile="%s" /><!-- %s -->""" % (folder,comment)
sl@0:             else:
sl@0:                 result = r"""<!-- %s -->""" % (comment)
sl@0:         return result
sl@0: