BaseTools: Clean up source files

[mirror_edk2.git] / BaseTools / Source / Python / UPT / Xml / IniToXml.py

## @file\r
# This file is for converting package information data file to xml file.\r
#\r
# Copyright (c) 2011 - 2018, Intel Corporation. All rights reserved.<BR>\r
#\r
# This program and the accompanying materials are licensed and made available\r
# under the terms and conditions of the BSD License which accompanies this\r
# distribution. The full text of the license may be found at\r
# http://opensource.org/licenses/bsd-license.php\r
#\r
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
#\r
\r
'''\r
IniToXml\r
'''\r
\r
import os.path\r
import re\r
from time import strftime\r
from time import localtime\r
\r
import Logger.Log as Logger\r
from Logger.ToolError import UPT_INI_PARSE_ERROR\r
from Logger.ToolError import FILE_NOT_FOUND\r
from Library.Xml.XmlRoutines import CreateXmlElement\r
from Library.DataType import TAB_VALUE_SPLIT\r
from Library.DataType import TAB_EQUAL_SPLIT\r
from Library.DataType import TAB_SECTION_START\r
from Library.DataType import TAB_SECTION_END\r
from Logger import StringTable as ST\r
from Library.StringUtils import ConvertSpecialChar\r
from Library.ParserValidate import IsValidPath\r
from Library import GlobalData\r
\r
## log error:\r
#\r
# @param error: error\r
# @param File: File\r
# @param Line: Line\r
#\r
def IniParseError(Error, File, Line):\r
    Logger.Error("UPT", UPT_INI_PARSE_ERROR, File=File,\r
                 Line=Line, ExtraData=Error)\r
\r
## __ValidatePath\r
#\r
# @param Path: Path to be checked\r
#\r
def __ValidatePath(Path, Root):\r
    Path = Path.strip()\r
    if os.path.isabs(Path) or not IsValidPath(Path, Root):\r
        return False, ST.ERR_FILELIST_LOCATION % (Root, Path)\r
    return True, ''\r
\r
## ValidateMiscFile\r
#\r
# @param Filename: File to be checked\r
#\r
def ValidateMiscFile(Filename):\r
    Root = GlobalData.gWORKSPACE\r
    return __ValidatePath(Filename, Root)\r
\r
## ValidateToolsFile\r
#\r
# @param Filename: File to be checked\r
#\r
def ValidateToolsFile(Filename):\r
    Valid, Cause = False, ''\r
    if not Valid and 'EDK_TOOLS_PATH' in os.environ:\r
        Valid, Cause = __ValidatePath(Filename, os.environ['EDK_TOOLS_PATH'])\r
    if not Valid:\r
        Valid, Cause = __ValidatePath(Filename, GlobalData.gWORKSPACE)\r
    return Valid, Cause\r
\r
## ParseFileList\r
#\r
# @param Line: Line\r
# @param Map: Map\r
# @param CurrentKey: CurrentKey\r
# @param PathFunc: Path validate function\r
#\r
def ParseFileList(Line, Map, CurrentKey, PathFunc):\r
    FileList = ["", {}]\r
    TokenList = Line.split(TAB_VALUE_SPLIT)\r
    if len(TokenList) > 0:\r
        Path = TokenList[0].strip().replace('\\', '/')\r
        if not Path:\r
            return False, ST.ERR_WRONG_FILELIST_FORMAT\r
        Valid, Cause = PathFunc(Path)\r
        if not Valid:\r
            return Valid, Cause\r
        FileList[0] = TokenList[0].strip()\r
        for Token in TokenList[1:]:\r
            Attr = Token.split(TAB_EQUAL_SPLIT)\r
            if len(Attr) != 2 or not Attr[0].strip() or not Attr[1].strip():\r
                return False, ST.ERR_WRONG_FILELIST_FORMAT\r
\r
            Key = Attr[0].strip()\r
            Val = Attr[1].strip()\r
            if Key not in ['OS', 'Executable']:\r
                return False, ST.ERR_UNKNOWN_FILELIST_ATTR % Key\r
\r
            if Key == 'OS' and Val not in ["Win32", "Win64", "Linux32",\r
                                           "Linux64", "OS/X32", "OS/X64",\r
                                           "GenericWin", "GenericNix"]:\r
                return False, ST.ERR_FILELIST_ATTR % 'OS'\r
            elif Key == 'Executable' and Val not in ['true', 'false']:\r
                return False, ST.ERR_FILELIST_ATTR % 'Executable'\r
            FileList[1][Key] = Val\r
\r
        Map[CurrentKey].append(FileList)\r
    return True, ''\r
\r
## Create header XML file\r
#\r
# @param DistMap: DistMap\r
# @param Root: Root\r
#\r
def CreateHeaderXml(DistMap, Root):\r
    Element1 = CreateXmlElement('Name', DistMap['Name'],\r
                                [], [['BaseName', DistMap['BaseName']]])\r
    Element2 = CreateXmlElement('GUID', DistMap['GUID'],\r
                                [], [['Version', DistMap['Version']]])\r
    AttributeList = [['ReadOnly', DistMap['ReadOnly']],\r
                     ['RePackage', DistMap['RePackage']]]\r
    NodeList = [Element1,\r
                Element2,\r
                ['Vendor', DistMap['Vendor']],\r
                ['Date', DistMap['Date']],\r
                ['Copyright', DistMap['Copyright']],\r
                ['License', DistMap['License']],\r
                ['Abstract', DistMap['Abstract']],\r
                ['Description', DistMap['Description']],\r
                ['Signature', DistMap['Signature']],\r
                ['XmlSpecification', DistMap['XmlSpecification']],\r
                ]\r
    Root.appendChild(CreateXmlElement('DistributionHeader', '',\r
                                      NodeList, AttributeList))\r
\r
## Create tools XML file\r
#\r
# @param Map: Map\r
# @param Root: Root\r
# @param Tag: Tag\r
#\r
def CreateToolsXml(Map, Root, Tag):\r
    #\r
    # Check if all elements in this section are empty\r
    #\r
    for Key in Map:\r
        if len(Map[Key]) > 0:\r
            break\r
    else:\r
        return\r
\r
    NodeList = [['Name', Map['Name']],\r
                ['Copyright', Map['Copyright']],\r
                ['License', Map['License']],\r
                ['Abstract', Map['Abstract']],\r
                ['Description', Map['Description']],\r
               ]\r
    HeaderNode = CreateXmlElement('Header', '', NodeList, [])\r
    NodeList = [HeaderNode]\r
\r
    for File in Map['FileList']:\r
        AttrList = []\r
        for Key in File[1]:\r
            AttrList.append([Key, File[1][Key]])\r
        NodeList.append(CreateXmlElement('Filename', File[0], [], AttrList))\r
    Root.appendChild(CreateXmlElement(Tag, '', NodeList, []))\r
\r
## ValidateValues\r
#\r
# @param Key: Key\r
# @param Value: Value\r
# @param SectionName: SectionName\r
#\r
def ValidateValues(Key, Value, SectionName):\r
    if SectionName == 'DistributionHeader':\r
        Valid, Cause = ValidateRegValues(Key, Value)\r
        if not Valid:\r
            return Valid, Cause\r
        Valid = __ValidateDistHeader(Key, Value)\r
        if not Valid:\r
            return Valid, ST.ERR_VALUE_INVALID % (Key, SectionName)\r
    else:\r
        Valid = __ValidateOtherHeader(Key, Value)\r
        if not Valid:\r
            return Valid, ST.ERR_VALUE_INVALID % (Key, SectionName)\r
    return True, ''\r
\r
## ValidateRegValues\r
#\r
# @param Key: Key\r
# @param Value: Value\r
#\r
def ValidateRegValues(Key, Value):\r
    ValidateMap = {\r
        'ReadOnly'  :\r
            ('true|false', ST.ERR_BOOLEAN_VALUE % (Key, Value)),\r
        'RePackage' :\r
            ('true|false', ST.ERR_BOOLEAN_VALUE % (Key, Value)),\r
        'GUID'      :\r
            ('[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}'\r
            '-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}',\r
            ST.ERR_GUID_VALUE % Value),\r
        'Version'   :   ('[0-9]+(\.[0-9]+)?', ST.ERR_VERSION_VALUE % \\r
                         (Key, Value)),\r
        'XmlSpecification' : ('1\.1', ST.ERR_VERSION_XMLSPEC % Value)\r
    }\r
    if Key not in ValidateMap:\r
        return True, ''\r
    Elem = ValidateMap[Key]\r
    Match = re.compile(Elem[0]).match(Value)\r
    if Match and Match.start() == 0 and Match.end() == len(Value):\r
        return True, ''\r
    return False, Elem[1]\r
\r
## __ValidateDistHeaderName\r
#\r
# @param Name: Name\r
#\r
def __ValidateDistHeaderName(Name):\r
    if len(Name) < 1:\r
        return False\r
\r
    for Char in Name:\r
        if ord(Char) < 0x20 or ord(Char) >= 0x7f:\r
            return False\r
    return True\r
\r
## __ValidateDistHeaderBaseName\r
#\r
# @param BaseName: BaseName\r
#\r
def __ValidateDistHeaderBaseName(BaseName):\r
    if not BaseName:\r
        return False\r
#    if CheckLen and len(BaseName) < 2:\r
#        return False\r
    if not BaseName[0].isalnum() and BaseName[0] != '_':\r
        return False\r
    for Char in BaseName[1:]:\r
        if not Char.isalnum() and Char not in '-_':\r
            return False\r
    return True\r
\r
## __ValidateDistHeaderAbstract\r
#\r
# @param Abstract: Abstract\r
#\r
def __ValidateDistHeaderAbstract(Abstract):\r
    return '\t' not in Abstract and len(Abstract.splitlines()) == 1\r
\r
## __ValidateOtherHeaderAbstract\r
#\r
# @param Abstract: Abstract\r
#\r
def __ValidateOtherHeaderAbstract(Abstract):\r
    return __ValidateDistHeaderAbstract(Abstract)\r
\r
## __ValidateDistHeader\r
#\r
# @param Key: Key\r
# @param Value: Value\r
#\r
def __ValidateDistHeader(Key, Value):\r
    ValidateMap = {\r
        'Name'      : __ValidateDistHeaderName,\r
        'BaseName'  : __ValidateDistHeaderBaseName,\r
        'Abstract'  : __ValidateDistHeaderAbstract,\r
        'Vendor'    : __ValidateDistHeaderAbstract\r
    }\r
    return not (Value and Key in ValidateMap and not ValidateMap[Key](Value))\r
\r
## __ValidateOtherHeader\r
#\r
# @param Key: Key\r
# @param Value: Value\r
#\r
def __ValidateOtherHeader(Key, Value):\r
    ValidateMap = {\r
        'Name'      : __ValidateDistHeaderName,\r
        'Abstract'  : __ValidateOtherHeaderAbstract\r
    }\r
    return not (Value and Key in ValidateMap and not ValidateMap[Key](Value))\r
\r
## Convert ini file to xml file\r
#\r
# @param IniFile\r
#\r
def IniToXml(IniFile):\r
    if not os.path.exists(IniFile):\r
        Logger.Error("UPT", FILE_NOT_FOUND, ST.ERR_TEMPLATE_NOTFOUND % IniFile)\r
\r
    DistMap = {'ReadOnly' : '', 'RePackage' : '', 'Name' : '',\r
               'BaseName' : '', 'GUID' : '', 'Version' : '', 'Vendor' : '',\r
               'Date' : '', 'Copyright' : '', 'License' : '', 'Abstract' : '',\r
               'Description' : '', 'Signature' : '', 'XmlSpecification' : ''\r
                }\r
\r
    ToolsMap = {'Name' : '', 'Copyright' : '', 'License' : '',\r
                'Abstract' : '', 'Description' : '', 'FileList' : []}\r
    #\r
    # Only FileList is a list: [['file1', {}], ['file2', {}], ...]\r
    #\r
    MiscMap = {'Name' : '', 'Copyright' : '', 'License' : '',\r
               'Abstract' : '', 'Description' : '', 'FileList' : []}\r
\r
    SectionMap = {\r
                   'DistributionHeader' : DistMap,\r
                   'ToolsHeader' : ToolsMap,\r
                   'MiscellaneousFilesHeader' : MiscMap\r
                   }\r
\r
    PathValidator = {\r
                'ToolsHeader' : ValidateToolsFile,\r
                'MiscellaneousFilesHeader' : ValidateMiscFile\r
                }\r
\r
    ParsedSection = []\r
\r
    SectionName = ''\r
    CurrentKey = ''\r
    PreMap = None\r
    Map = None\r
    FileContent = ConvertSpecialChar(open(IniFile, 'rb').readlines())\r
    LastIndex = 0\r
    for Index in range(0, len(FileContent)):\r
        LastIndex = Index\r
        Line = FileContent[Index].strip()\r
        if Line == '' or Line.startswith(';'):\r
            continue\r
        if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END:\r
            CurrentKey = ''\r
            SectionName = Line[1:-1].strip()\r
            if SectionName not in SectionMap:\r
                IniParseError(ST.ERR_SECTION_NAME_INVALID % SectionName,\r
                      IniFile, Index+1)\r
\r
            if SectionName in ParsedSection:\r
                IniParseError(ST.ERR_SECTION_REDEFINE % SectionName,\r
                      IniFile, Index+1)\r
            else:\r
                ParsedSection.append(SectionName)\r
\r
            Map = SectionMap[SectionName]\r
            continue\r
        if not Map:\r
            IniParseError(ST.ERR_SECTION_NAME_NONE, IniFile, Index+1)\r
        TokenList = Line.split(TAB_EQUAL_SPLIT, 1)\r
        TempKey = TokenList[0].strip()\r
        #\r
        # Value spanned multiple or same keyword appears more than one time\r
        #\r
        if len(TokenList) < 2 or TempKey not in Map:\r
            if CurrentKey == '':\r
                IniParseError(ST.ERR_KEYWORD_INVALID % TempKey,\r
                              IniFile, Index+1)\r
            elif CurrentKey == 'FileList':\r
                #\r
                # Special for FileList\r
                #\r
                Valid, Cause = ParseFileList(Line, Map, CurrentKey,\r
                                             PathValidator[SectionName])\r
                if not Valid:\r
                    IniParseError(Cause, IniFile, Index+1)\r
\r
            else:\r
                #\r
                # Multiple lines for one key such as license\r
                # Or if string on the left side of '=' is not a keyword\r
                #\r
                Map[CurrentKey] = ''.join([Map[CurrentKey], '\n', Line])\r
                Valid, Cause = ValidateValues(CurrentKey,\r
                                              Map[CurrentKey], SectionName)\r
                if not Valid:\r
                    IniParseError(Cause, IniFile, Index+1)\r
            continue\r
\r
        if (TokenList[1].strip() == ''):\r
            IniParseError(ST.ERR_EMPTY_VALUE, IniFile, Index+1)\r
\r
        #\r
        # A keyword found\r
        #\r
        CurrentKey = TempKey\r
        if Map[CurrentKey]:\r
            IniParseError(ST.ERR_KEYWORD_REDEFINE % CurrentKey,\r
                          IniFile, Index+1)\r
\r
        if id(Map) != id(PreMap) and Map['Copyright']:\r
            PreMap = Map\r
            Copyright = Map['Copyright'].lower()\r
            Pos = Copyright.find('copyright')\r
            if Pos == -1:\r
                IniParseError(ST.ERR_COPYRIGHT_CONTENT, IniFile, Index)\r
            if not Copyright[Pos + len('copyright'):].lstrip(' ').startswith('('):\r
                IniParseError(ST.ERR_COPYRIGHT_CONTENT, IniFile, Index)\r
\r
        if CurrentKey == 'FileList':\r
            Valid, Cause = ParseFileList(TokenList[1], Map, CurrentKey,\r
                                         PathValidator[SectionName])\r
            if not Valid:\r
                IniParseError(Cause, IniFile, Index+1)\r
        else:\r
            Map[CurrentKey] = TokenList[1].strip()\r
            Valid, Cause = ValidateValues(CurrentKey,\r
                                          Map[CurrentKey], SectionName)\r
            if not Valid:\r
                IniParseError(Cause, IniFile, Index+1)\r
\r
    if id(Map) != id(PreMap) and Map['Copyright'] and 'copyright' not in Map['Copyright'].lower():\r
        IniParseError(ST.ERR_COPYRIGHT_CONTENT, IniFile, LastIndex)\r
\r
    #\r
    # Check mandatory keys\r
    #\r
    CheckMdtKeys(DistMap, IniFile, LastIndex,\r
                 (('ToolsHeader', ToolsMap), ('MiscellaneousFilesHeader', MiscMap))\r
                 )\r
\r
    return CreateXml(DistMap, ToolsMap, MiscMap, IniFile)\r
\r
\r
## CheckMdtKeys\r
#\r
# @param MdtDistKeys: All mandatory keys\r
# @param DistMap: Dist content\r
# @param IniFile: Ini file\r
# @param LastIndex: Last index of Ini file\r
# @param Maps: Tools and Misc section name and map. (('section_name', map),*)\r
#\r
def CheckMdtKeys(DistMap, IniFile, LastIndex, Maps):\r
    MdtDistKeys = ['Name', 'GUID', 'Version', 'Vendor', 'Copyright', 'License', 'Abstract', 'XmlSpecification']\r
    for Key in MdtDistKeys:\r
        if Key not in DistMap or DistMap[Key] == '':\r
            IniParseError(ST.ERR_KEYWORD_MANDATORY % Key, IniFile, LastIndex+1)\r
\r
    if '.' not in DistMap['Version']:\r
        DistMap['Version'] = DistMap['Version'] + '.0'\r
\r
    DistMap['Date'] = str(strftime("%Y-%m-%dT%H:%M:%S", localtime()))\r
\r
    #\r
    # Check Tools Surface Area according to UPT Spec\r
    # <Tools> {0,}\r
    #     <Header> ... </Header> {0,1}\r
    #     <Filename> ... </Filename> {1,}\r
    # </Tools>\r
    # <Header>\r
    #    <Name> xs:normalizedString </Name> {1}\r
    #    <Copyright> xs:string </Copyright> {0,1}\r
    #    <License> xs:string </License> {0,1}\r
    #    <Abstract> xs:normalizedString </Abstract> {0,1}\r
    #    <Description> xs:string </Description> {0,1}\r
    # </Header>\r
    #\r
    for Item in Maps:\r
        Map = Item[1]\r
        NonEmptyKey = 0\r
        for Key in Map:\r
            if Map[Key]:\r
                NonEmptyKey += 1\r
\r
        if NonEmptyKey > 0 and not Map['FileList']:\r
            IniParseError(ST.ERR_KEYWORD_MANDATORY % (Item[0] + '.FileList'), IniFile, LastIndex+1)\r
\r
        if NonEmptyKey > 0 and not Map['Name']:\r
            IniParseError(ST.ERR_KEYWORD_MANDATORY % (Item[0] + '.Name'), IniFile, LastIndex+1)\r
\r
## CreateXml\r
#\r
# @param DistMap:  Dist Content\r
# @param ToolsMap: Tools Content\r
# @param MiscMap:  Misc Content\r
# @param IniFile:  Ini File\r
#\r
def CreateXml(DistMap, ToolsMap, MiscMap, IniFile):\r
    Attrs = [['xmlns', 'http://www.uefi.org/2011/1.1'],\r
             ['xmlns:xsi', 'http:/www.w3.org/2001/XMLSchema-instance'],\r
            ]\r
    Root = CreateXmlElement('DistributionPackage', '', [], Attrs)\r
    CreateHeaderXml(DistMap, Root)\r
    CreateToolsXml(ToolsMap, Root, 'Tools')\r
    CreateToolsXml(MiscMap, Root, 'MiscellaneousFiles')\r
\r
    FileAndExt = IniFile.rsplit('.', 1)\r
    if len(FileAndExt) > 1:\r
        FileName = FileAndExt[0] + '.xml'\r
    else:\r
        FileName = IniFile + '.xml'\r
    File = open(FileName, 'w')\r
\r
    try:\r
        File.write(Root.toprettyxml(indent = '  '))\r
    finally:\r
        File.close()\r
    return FileName\r
\r