# 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 "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:

# Tools to parse mbc files

# NOTE: There is unit etc test code for this in testMbcUtils.py

# Any changes to this file should be checked with "python testMbcUtils.py"

# Also note that the test code coverage is not 100%

#

import re

import types

import os

class InvalidInput(Exception):

    """Raised for invalid data in files"""

    def __init__(self, badInput):

        self.__badInput = badInput

    def __str__(self):

        return "InvalidInput(%s)" % self.__badInput

class Unimplemented(Exception):

    """Raised for features we don't cover"""

    def __init__(self, msg):

        self.__msg = msg

    def __str__(self):

        return "Unimplemented(%s)" % self.__msg

class InvalidArg(Exception):

    """Raised for invalid data in argument"""

    def __init__(self, badArg):

        self.__badArg = badArg

    def __str__(self):

        return "InvalidArg(%s)" % self.__badArg

class MissingFile(Exception):

    "Raised when we expect a file and it does not exist"

    def __init__(self, badFname):

        self.__badFname = badFname

    def __str__(self):

        return "MissingFile(%s)" % self.__badFname

class _MbcParser(object):

    """Parse an mbc file, given by name. Return as tuple of the given categories, coupled with the filename."""

    # __slots__ = ["__fname", "__result", "__state"]

    __nullState = -1

    __dirsSectionState = 1 # assumed to be same as tuple index

    __optionDirsSectionState = 2 # assumed to be same as tuple index

    __commandSectionState = 3 # assumed to be same as tuple index

    def __init__(self, fname):

        self.__fname = fname

        self.__dirname = os.path.dirname(fname)

        self.__result = None

        self.__state = _MbcParser.__nullState

        self.__executed = False

    def execute(self):

        "Call to generate the result"

        self.__reset(self.__fname) # initialize __result etc

        self.__openAndParse()

        self.__executed = True

    def __call__(self):

        if not self.__executed:

            self.execute()

        return self.__result

    def __reset(self, fname=None):

        self.__result = (fname,[],[],[])

    def __openAndParse(self):

        "Open file and then parse line-by-line"

        # note deliberately use old version to avoid 2.4 issue. Going foreard, "with" seems to be the correct approach

        # could perhaps write this better using a parser module, or more extensive use of re, but this is not seen as module specific

        inputFile = open(self.__fname)

        try:

            for line in inputFile:

                self.__parseLine(line)

        finally:

            inputFile.close()

    def __parseLine(self,line):

        # initially we want the bit of the line up to the first // or \n

        # TODO should be able to do in one re?

        lookforeoln = re.match(r"(.*)$", line) # lose any \n

        if lookforeoln:

            line = lookforeoln.group(1)

        lookforcomment = re.match(r"(.*)//.*", line)

        if lookforcomment:

            line = lookforcomment.group(1)

        line.strip() # remove spaces at start and end

        if not line:

            # skip blank line

            return;

        if line == "SECTION_DIRS":

            self.__state = _MbcParser.__dirsSectionState

        elif line == "SECTION_OPTIONALDIRS":

            self.__state = _MbcParser.__optionDirsSectionState

        elif line == "SECTION_COMMANDS":

            self.__state = _MbcParser.__commandSectionState

        else:

            # for dirs or optionDirs section we are after a single string to treat as directory. don't check here

            if ((self.__state == _MbcParser.__dirsSectionState) or

                (self.__state == _MbcParser.__optionDirsSectionState)):

                matchre = re.match(r'[_\-a-z0-9\\/\.]+$', line, re.IGNORECASE)

                if matchre:

                    # we have a match - add to the tuple

                    matchresult = line # no need to decode. whole thing is the line

                    if matchresult[0] != "\\":

                        # relative path - need to add folder name

                        matchresult = os.path.abspath(os.path.join(self.__dirname, matchresult))

                    self.__result[self.__state].append(matchresult)

                else:

                    raise InvalidInput (line)

            elif self.__state == _MbcParser.__commandSectionState:

                matchre = re.match(r'oneoff\s+([_\-a-z0-9\\/\.]+)\s+(.+)$', line, re.IGNORECASE)

                if matchre:

                    # append tuple of (directory, command). Comes as (group(1),group(2)) but have to

                    # convert relative directory we get to absolute if required

                    matchDir = matchre.group(1)

                    if matchDir[0] != "\\":

                        # relative path- need to add folder name

                        matchDir = os.path.abspath(os.path.join(self.__dirname, matchDir))

                    self.__result[self.__state].append((matchDir,matchre.group(2)))

                else:

                    raise InvalidInput (line)

class _MbcListHandle(object):

    """Handle a list or tuple of filenames, recursively list of tuples as produced by _MbcParser"""

    def __init__(self, fnameList):

        """Assume fnameList is a container. Always generate a list"""

        self.__fnameList = fnameList

        self.__result = []

        self.__executed = False

    def execute(self):

        for fname in self.__fnameList:

            parser = MbcParser(fname)

            parser.execute()

            self.__result.append(parser())

        self.__exectuted = True

    def __call__(self):

        if not self.__exectuted:

            self.execute()

        return self.__result

class MbcParser(object):

    """Given a list of or a filename, return equivalent structure with each filename replaced by tuple of content

    tuple elements are:

    0 - filename

    1 - main directories

    2 - optional directories

    3 - oneoff"""

    def __init__(self, fnameOrList):

        self.__fnameOrList = fnameOrList

        self.__result = None

        self.__executed = False

    def execute(self):

        fnameOrList = self.__fnameOrList

        if isinstance(fnameOrList, list) or isinstance(fnameOrList, tuple):

            parser = _MbcListHandle(fnameOrList)

            parser.execute()

            self.__result = parser()

        elif isinstance(fnameOrList, types.StringTypes):

            parser = _MbcParser(fnameOrList)

            parser.execute()

            self.__result = parser()

        else:

            raise InvalidArg(fnameOrList)

    def __call__(self):

        if not self.__executed:

            self.execute()

        return self.__result

class GetFolderList(object):

    """Given output of MbcParser(), produces list of tuples in the format:

    0 - Element is folder if True (only thing currently supported)

    1 - folder

    2 - comment to use in generated file including original filename

    If folder is optional, will only be added if exists - actually if nameToCheck exists in folder.

    If folder is not optional, and does not exist, this will raise an error.

    """

    def __init__(self, inputList, nameToCheck="bld.inf"):

        if isinstance(inputList, tuple):

            # single element "list" from MbcParser is not always a list!

            self.__list = [inputList]

        else:

            self.__list = inputList

        self.__nameToCheck = nameToCheck

        self.__result = []

        self.__exectuted = False

    def execute(self):

        self.__result = []

        self.__genResult()

        self.__executed = True

    def __genResult(self):

        "Process whole list"

        for listEle in self.__list:

            self.__processEle(listEle)

    def __processEle(self, listEle):

        "Process single element in input list"

        (fname, dirs, optDirs, commands) = listEle

        for dir in dirs:

            combinedFname = os.path.join(dir, self.__nameToCheck)

            exists = os.path.exists(combinedFname)

            if not exists:

                raise MissingFile(combinedFname)

            self.__result.append((True, dir, "From %s"%fname))

        for dir in optDirs:

            combinedFname = os.path.join(dir, self.__nameToCheck)

            exists = os.path.exists(combinedFname)

            if exists:

                self.__result.append((True, dir, "From %s"%fname))

            else:

                self.__result.append((True, None, """Skip "%s" from %s"""%(dir,fname)))

        if commands:

            raise Unimplemented("No support for oneoff - %s" % str(commands))

    def __call__(self):

        if not self.__exectuted:

            self.execute()

        return self.__result

## Minimal example configuration file as we have to produce

## See http://developer.symbian.com/wiki/x/rgD6Bg

##

##<SystemDefinition name="BLAH" schema="2.0.0">

##  <systemModel>

##    <layer name="NEW_CUSTOM_LAYER">

##      <collection name="Fake Collection">

##	<component name="examples">

##	  <unit bldFile="C:\Symbian\Carbide2\workspace\hello_whirled\group" />

##	  <unit bldFile="C:\Symbian\Carbide2\workspace\hello_abld\group" />

##	</component>

##      </collection>

##    </layer>

##  </systemModel>

##</SystemDefinition>

class ConfigFileGenerator(object):

    """Generate xml config file given output from GetFolderList

    Output corresponds to the example in source

    folderList is input from GetFolderList

    outputStream is either filename or assumed to be an open file or StringIO"""

    def __init__(self, folderList, outputStream):

        self.__folderList = folderList

        self.__streamParam = outputStream

        self.__streamIsLocal = False

        self.__stream = None

    def __initStream(self):

        "Work out stream to use. Open stream if required"

        if isinstance(self.__streamParam, basestring):

            # unicode or normal string

            self.__streamIsLocal = True

            self.__stream = open(self.__streamParam, "w")

        else:

            self.__streamIsLocal = False

            self.__stream = self.__streamParam

    def __closeStream(self):

        "If stream is local, close it"

        if self.__streamIsLocal:

            self.__stream.close()

        self.__stream = None # orphan if needs be

        self.__streamIsLocal = False

    def write(self):

        "Called will write output to stream"

        try:

            self.__initStream()

            self.__writeHeaderBit()

            self.__writeFolderList()

            self.__writeTailBit()

        except: # TODO not sure we need this - if we ommit is finally clause run?

            raise

        finally:

            self.__closeStream()

    def __writeHeaderBit(self):

        "Write bit of xml before the folder list"

        # these names all come from the original. Seems no need to vary

        # this code is 9.5 based

        print >> self.__stream, r"""<SystemDefinition name="BLAH" schema="2.0.0">"""

        print >> self.__stream, r"""  <systemModel>"""

        print >> self.__stream, r"""    <layer name="NEW_CUSTOM_LAYER">"""

        print >> self.__stream, r"""      <collection name="Fake Collection">"""

        print >> self.__stream, r"""        <component name="Fake Multimedia">"""

    def __writeTailBit(self):

        "write bit of xml after the folder list"

        print >> self.__stream, r"""        </component>"""

        print >> self.__stream, r"""      </collection>"""

        print >> self.__stream, r"""    </layer>"""

        print >> self.__stream, r"""  </systemModel>"""

        print >> self.__stream, r"""</SystemDefinition>"""

    def __writeFolderList(self):

        for ele in self.__folderList:

            str = self.__strForListEle(ele)

            if str:

                print >> self.__stream, "          %s" % str

    def __strForListEle(self, ele):

        (isFolder, folder, comment) = ele # break down tuple

        result = None

        if isFolder:

            if folder:

                result = r"""<unit bldFile="%s" /><!-- %s -->""" % (folder,comment)

            else:

                result = r"""<!-- %s -->""" % (comment)

        return result