## @file\r
# This file is for installed package information database operations\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
##\r
# Import Modules\r
#\r
-from os import getenv\r
-from os import environ\r
from os.path import dirname\r
\r
import Logger.Log as Logger\r
from Logger import StringTable as ST\r
from Library.Parsing import GetWorkspacePackage\r
from Library.Parsing import GetWorkspaceModule\r
+from Library.Misc import GetRelativePath\r
+from Library import GlobalData\r
from PomAdapter.InfPomAlignment import InfPomAlignment\r
from Logger.ToolError import FatalError\r
from Logger.ToolError import EDK1_INF_ERROR\r
DEPEX_CHECK_PACKAGE_NOT_FOUND, DEPEX_CHECK_DP_NOT_FOUND) = (0, 1, 2, 3)\r
\r
\r
-## IpiDb\r
+## DependencyRules\r
#\r
-# This class represents the installed package information database\r
-# Add/Remove/Get installed distribution package information here.\r
-# \r
+# This class represents the dependency rule check mechanism\r
# \r
# @param object: Inherited from object class\r
#\r
self.IpiDb = Datab\r
self.WsPkgList = GetWorkspacePackage()\r
self.WsModuleList = GetWorkspaceModule()\r
-\r
- ## Check whether a module exists in current workspace.\r
+ self.PkgsToBeDepend = []\r
+ \r
+ ## Check whether a module exists by checking the Guid+Version+Name+Path combination\r
#\r
# @param Guid: Guid of a module\r
# @param Version: Version of a module\r
+ # @param Name: Name of a module\r
+ # @param Path: Path of a module\r
+ # @return: True if module existed, else False\r
#\r
- def CheckModuleExists(self, Guid, Version, Name, Path, ReturnCode=DEPEX_CHECK_SUCCESS):\r
- if ReturnCode:\r
- pass\r
+ def CheckModuleExists(self, Guid, Version, Name, Path):\r
Logger.Verbose(ST.MSG_CHECK_MODULE_EXIST)\r
ModuleList = self.IpiDb.GetModInPackage(Guid, Version, Name, Path)\r
ModuleList.extend(self.IpiDb.GetStandaloneModule(Guid, Version, Name, Path))\r
else:\r
return False\r
\r
- ## Check whether a module depex satisfied by current workspace or dist.\r
+ ## Check whether a module depex satisfied.\r
#\r
# @param ModuleObj: A module object\r
- # @param DpObj: A depex object\r
+ # @param DpObj: A distribution object\r
+ # @return: True if module depex satisfied\r
+ # False else\r
#\r
- def CheckModuleDepexSatisfied(self, ModuleObj, DpObj=None, \\r
- ReturnCode=DEPEX_CHECK_SUCCESS):\r
- if ReturnCode:\r
- pass\r
+ def CheckModuleDepexSatisfied(self, ModuleObj, DpObj=None):\r
Logger.Verbose(ST.MSG_CHECK_MODULE_DEPEX_START)\r
Result = True\r
Dep = None\r
Dep.GetVersion()))\r
return Result\r
\r
- ## Check whether a package exists in current workspace.\r
+ ## Check whether a package exists in a package list specified by PkgsToBeDepend.\r
#\r
# @param Guid: Guid of a package\r
# @param Version: Version of a package\r
+ # @return: True if package exist\r
+ # False else\r
#\r
def CheckPackageExists(self, Guid, Version):\r
Logger.Verbose(ST.MSG_CHECK_PACKAGE_START)\r
- for (PkgName, PkgGuid, PkgVer, PkgPath) in self.WsPkgList:\r
- if PkgName or PkgPath:\r
- pass\r
+ Found = False\r
+ for (PkgGuid, PkgVer) in self.PkgsToBeDepend:\r
if (PkgGuid == Guid):\r
#\r
# if version is not empty and not equal, then not match\r
#\r
if Version and (PkgVer != Version):\r
- return False\r
+ Found = False\r
+ break\r
else:\r
- return True\r
+ Found = True\r
+ break\r
else:\r
- return False\r
- \r
+ Found = False\r
+\r
Logger.Verbose(ST.MSG_CHECK_PACKAGE_FINISH)\r
+ return Found\r
\r
- ## Check whether a package depex satisfied by current workspace.\r
+ ## Check whether a package depex satisfied.\r
#\r
# @param PkgObj: A package object\r
- # @param DpObj: A package depex object\r
+ # @param DpObj: A distribution object\r
+ # @return: True if package depex satisified\r
+ # False else\r
#\r
- def CheckPackageDepexSatisfied(self, PkgObj, DpObj=None, \\r
- ReturnCode=DEPEX_CHECK_SUCCESS):\r
- \r
+ def CheckPackageDepexSatisfied(self, PkgObj, DpObj=None):\r
ModuleDict = PkgObj.GetModuleDict()\r
for ModKey in ModuleDict.keys():\r
ModObj = ModuleDict[ModKey]\r
- if self.CheckModuleDepexSatisfied(ModObj, DpObj, ReturnCode):\r
+ if self.CheckModuleDepexSatisfied(ModObj, DpObj):\r
continue\r
else:\r
return False\r
return True\r
\r
- ## Check whether a DP exists in current workspace.\r
+ ## Check whether a DP exists.\r
#\r
- # @param Guid: Guid of a module\r
- # @param Version: Version of a module\r
- #\r
- def CheckDpExists(self, Guid, Version, ReturnCode=DEPEX_CHECK_SUCCESS):\r
- if ReturnCode:\r
- pass\r
+ # @param Guid: Guid of a Distribution\r
+ # @param Version: Version of a Distribution\r
+ # @return: True if Distribution exist\r
+ # False else\r
+ def CheckDpExists(self, Guid, Version):\r
Logger.Verbose(ST.MSG_CHECK_DP_START)\r
DpList = self.IpiDb.GetDp(Guid, Version)\r
if len(DpList) > 0:\r
- return True\r
+ Found = True\r
else:\r
- return False\r
- \r
- Logger.Verbose(ST.MSG_CHECK_DP_FINISH) \r
- \r
+ Found = False\r
+\r
+ Logger.Verbose(ST.MSG_CHECK_DP_FINISH)\r
+ return Found\r
+\r
+ ## Check whether a DP depex satisfied by current workspace for Install\r
+ #\r
+ # @param DpObj: A distribution object\r
+ # @return: True if distribution depex satisfied\r
+ # False else\r
+ #\r
+ def CheckInstallDpDepexSatisfied(self, DpObj):\r
+ self.PkgsToBeDepend = [(PkgInfo[1], PkgInfo[2]) for PkgInfo in self.WsPkgList]\r
+ return self.CheckDpDepexSatisfied(DpObj)\r
+\r
+ ## Check whether a DP depex satisfied by current workspace \r
+ # (excluding the original distribution's packages to be replaced) for Replace\r
+ #\r
+ # @param DpObj: A distribution object\r
+ # @param OrigDpGuid: The original distribution's Guid\r
+ # @param OrigDpVersion: The original distribution's Version\r
+ #\r
+ def ReplaceCheckNewDpDepex(self, DpObj, OrigDpGuid, OrigDpVersion):\r
+ self.PkgsToBeDepend = [(PkgInfo[1], PkgInfo[2]) for PkgInfo in self.WsPkgList]\r
+ OrigDpPackageList = self.IpiDb.GetPackageListFromDp(OrigDpGuid, OrigDpVersion)\r
+ for OrigPkgInfo in OrigDpPackageList:\r
+ Guid, Version = OrigPkgInfo[0], OrigPkgInfo[1]\r
+ if (Guid, Version) in self.PkgsToBeDepend:\r
+ self.PkgsToBeDepend.remove((Guid, Version))\r
+ return self.CheckDpDepexSatisfied(DpObj)\r
+\r
## Check whether a DP depex satisfied by current workspace.\r
#\r
- # @param DpObj: Depex object\r
- # @param ReturnCode: ReturnCode\r
+ # @param DpObj: A distribution object\r
#\r
- def CheckDpDepexSatisfied(self, DpObj, ReturnCode=DEPEX_CHECK_SUCCESS):\r
- \r
+ def CheckDpDepexSatisfied(self, DpObj):\r
for PkgKey in DpObj.PackageSurfaceArea.keys():\r
PkgObj = DpObj.PackageSurfaceArea[PkgKey]\r
- if self.CheckPackageDepexSatisfied(PkgObj, DpObj, ReturnCode):\r
+ if self.CheckPackageDepexSatisfied(PkgObj, DpObj):\r
continue\r
else:\r
return False\r
\r
for ModKey in DpObj.ModuleSurfaceArea.keys():\r
ModObj = DpObj.ModuleSurfaceArea[ModKey]\r
- if self.CheckModuleDepexSatisfied(ModObj, DpObj, ReturnCode):\r
+ if self.CheckModuleDepexSatisfied(ModObj, DpObj):\r
continue\r
else:\r
return False\r
\r
return True\r
\r
- ## Check whether a DP depex satisfied by current workspace. Return False \r
- # if Can not remove (there is dependency), True else\r
+ ## Check whether a DP could be removed from current workspace. \r
#\r
# @param DpGuid: File's guid\r
# @param DpVersion: File's version\r
- # @param ReturnCode: ReturnCode\r
- # \r
- def CheckDpDepexForRemove(self, DpGuid, DpVersion, \\r
- ReturnCode=DEPEX_CHECK_SUCCESS):\r
- if ReturnCode:\r
- pass\r
+ # @retval Removable: True if distribution could be removed, False Else\r
+ # @retval DependModuleList: the list of modules that make distribution can not be removed\r
+ #\r
+ def CheckDpDepexForRemove(self, DpGuid, DpVersion):\r
Removable = True\r
DependModuleList = []\r
WsModuleList = self.WsModuleList\r
# List of item (PkgGuid, PkgVersion, InstallPath)\r
DpPackageList = self.IpiDb.GetPackageListFromDp(DpGuid, DpVersion) \r
DpPackagePathList = []\r
- WorkSP = environ["WORKSPACE"]\r
+ WorkSP = GlobalData.gWORKSPACE\r
for (PkgName, PkgGuid, PkgVersion, DecFile) in self.WsPkgList:\r
if PkgName:\r
pass\r
DecPath = dirname(DecFile)\r
if DecPath.find(WorkSP) > -1:\r
- InstallPath = DecPath[DecPath.find(WorkSP) + len(WorkSP) + 1:]\r
- DecFileRelaPath = \\r
- DecFile[DecFile.find(WorkSP) + len(WorkSP) + 1:]\r
+ InstallPath = GetRelativePath(DecPath,WorkSP)\r
+ DecFileRelaPath = GetRelativePath(DecFile,WorkSP)\r
else:\r
InstallPath = DecPath\r
DecFileRelaPath = DecFile\r
# check modules to see if has dependency on package of current DP\r
#\r
for Module in WsModuleList:\r
- if (CheckModuleDependFromInf(Module, DpPackagePathList)):\r
+ if (not VerifyRemoveModuleDep(Module, DpPackagePathList)):\r
Removable = False\r
DependModuleList.append(Module)\r
return (Removable, DependModuleList)\r
\r
\r
+ ## Check whether a DP could be replaced by a distribution containing NewDpPkgList\r
+ # from current workspace.\r
+ #\r
+ # @param OrigDpGuid: original Dp's Guid\r
+ # @param OrigDpVersion: original Dp's version\r
+ # @param NewDpPkgList: a list of package information (Guid, Version) in new Dp\r
+ # @retval Replaceable: True if distribution could be replaced, False Else\r
+ # @retval DependModuleList: the list of modules that make distribution can not be replaced\r
+ # \r
+ def CheckDpDepexForReplace(self, OrigDpGuid, OrigDpVersion, NewDpPkgList):\r
+ Replaceable = True\r
+ DependModuleList = []\r
+ WsModuleList = self.WsModuleList\r
+ #\r
+ # remove modules that included in current DP\r
+ # List of item (FilePath)\r
+ DpModuleList = self.IpiDb.GetDpModuleList(OrigDpGuid, OrigDpVersion) \r
+ for Module in DpModuleList:\r
+ if Module in WsModuleList:\r
+ WsModuleList.remove(Module)\r
+ else:\r
+ Logger.Warn("UPT\n",\r
+ ST.ERR_MODULE_NOT_INSTALLED % Module)\r
+ \r
+ OtherPkgList = NewDpPkgList\r
+ #\r
+ # get packages in current Dp and find the install path\r
+ # List of item (PkgGuid, PkgVersion, InstallPath)\r
+ DpPackageList = self.IpiDb.GetPackageListFromDp(OrigDpGuid, OrigDpVersion) \r
+ DpPackagePathList = []\r
+ WorkSP = GlobalData.gWORKSPACE\r
+ for (PkgName, PkgGuid, PkgVersion, DecFile) in self.WsPkgList:\r
+ if PkgName:\r
+ pass\r
+ DecPath = dirname(DecFile)\r
+ if DecPath.find(WorkSP) > -1:\r
+ InstallPath = GetRelativePath(DecPath,WorkSP)\r
+ DecFileRelaPath = GetRelativePath(DecFile,WorkSP)\r
+ else:\r
+ InstallPath = DecPath\r
+ DecFileRelaPath = DecFile\r
+ \r
+ if (PkgGuid, PkgVersion, InstallPath) in DpPackageList:\r
+ DpPackagePathList.append(DecFileRelaPath)\r
+ DpPackageList.remove((PkgGuid, PkgVersion, InstallPath))\r
+ else:\r
+ OtherPkgList.append((PkgGuid, PkgVersion))\r
+\r
+ #\r
+ # the left items in DpPackageList are the packages that installed but not found anymore\r
+ #\r
+ for (PkgGuid, PkgVersion, InstallPath) in DpPackageList:\r
+ Logger.Warn("UPT",\r
+ ST.WARN_INSTALLED_PACKAGE_NOT_FOUND%(PkgGuid, PkgVersion, InstallPath))\r
+ \r
+ #\r
+ # check modules to see if it can be satisfied by package not belong to removed DP\r
+ #\r
+ for Module in WsModuleList:\r
+ if (not VerifyReplaceModuleDep(Module, DpPackagePathList, OtherPkgList)):\r
+ Replaceable = False\r
+ DependModuleList.append(Module)\r
+ return (Replaceable, DependModuleList)\r
+\r
+ \r
## check whether module depends on packages in DpPackagePathList, return True \r
# if found, False else\r
#\r
# @param Path: a module path\r
# @param DpPackagePathList: a list of Package Paths\r
+# @retval: False: module depends on package in DpPackagePathList\r
+# True: module doesn't depend on package in DpPackagePathList\r
#\r
-def CheckModuleDependFromInf(Path, DpPackagePathList):\r
- \r
- # \r
- # use InfParser to parse inf, then get the information for now,\r
- # later on, may consider only parse to get the package dependency info \r
- # (Need to take care how to deal wit Macros)\r
- #\r
- WorkSP = getenv('WORKSPACE')\r
+def VerifyRemoveModuleDep(Path, DpPackagePathList):\r
+ WorkSP = GlobalData.gWORKSPACE\r
\r
try:\r
PomAli = InfPomAlignment(Path, WorkSP, Skip=True)\r
for Item in PomAli.GetPackageDependencyList():\r
if Item.GetPackageFilePath() in DpPackagePathList:\r
Logger.Info(ST.MSG_MODULE_DEPEND_ON % (Path, Item.GetPackageFilePath()))\r
- return True\r
+ return False\r
else:\r
- return False\r
+ return True\r
except FatalError, ErrCode:\r
if ErrCode.message == EDK1_INF_ERROR:\r
Logger.Warn("UPT",\r
ST.WRN_EDK1_INF_FOUND%Path)\r
- return False\r
+ return True\r
else:\r
- return False\r
- \r
+ return True\r
+\r
+## check whether module depends on packages in DpPackagePathList and can not be satisfied by OtherPkgList\r
+#\r
+# @param Path: a module path\r
+# @param DpPackagePathList: a list of Package Paths\r
+# @param OtherPkgList: a list of Package Information (Guid, Version)\r
+# @retval: False: module depends on package in DpPackagePathList and can not be satisfied by OtherPkgList\r
+# True: either module doesn't depend on DpPackagePathList or module depends on DpPackagePathList \r
+# but can be satisfied by OtherPkgList\r
+#\r
+def VerifyReplaceModuleDep(Path, DpPackagePathList, OtherPkgList):\r
+ WorkSP = GlobalData.gWORKSPACE\r
+ \r
+ try:\r
+ PomAli = InfPomAlignment(Path, WorkSP, Skip=True)\r
+\r
+ for Item in PomAli.GetPackageDependencyList():\r
+ if Item.GetPackageFilePath() in DpPackagePathList:\r
+ Guid, Version = Item.GetGuid(), Item.GetVersion()\r
+ if (Guid, Version) not in OtherPkgList:\r
+ Logger.Info(ST.MSG_MODULE_DEPEND_ON % (Path, Item.GetPackageFilePath()))\r
+ return False\r
+ else:\r
+ return True\r
+ except FatalError, ErrCode:\r
+ if ErrCode.message == EDK1_INF_ERROR:\r
+ Logger.Warn("UPT",\r
+ ST.WRN_EDK1_INF_FOUND%Path)\r
+ return True\r
+ else:\r
+ return True\r
+ \r
\r
\r
## @file\r
# This file is used to define a class object to describe a distribution package\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
#\r
def GetDistributionFileList(self):\r
MetaDataFileList = []\r
+ SkipModulesUniList = []\r
\r
for Guid, Version, Path in self.PackageSurfaceArea:\r
Package = self.PackageSurfaceArea[Guid, Version, Path]\r
SearchPath = os.path.normpath(os.path.join(os.path.dirname(FullPath), IncludePath))\r
AddPath = os.path.normpath(os.path.join(PackagePath, IncludePath))\r
self.FileList += GetNonMetaDataFiles(SearchPath, ['CVS', '.svn'], False, AddPath)\r
- \r
+ #\r
+ # Add the miscellaneous files on DEC file\r
+ #\r
+ for MiscFileObj in Package.GetMiscFileList():\r
+ for FileObj in MiscFileObj.GetFileList():\r
+ MiscFileFullPath = os.path.normpath(os.path.join(os.path.dirname(FullPath), FileObj.GetURI()))\r
+ if MiscFileFullPath not in self.FileList:\r
+ self.FileList.append(MiscFileFullPath)\r
+ \r
Module = None\r
ModuleDict = Package.GetModuleDict()\r
for Guid, Version, Name, Path in ModuleDict:\r
FullPath = Module.GetFullPath()\r
PkgRelPath = os.path.normpath(os.path.join(PackagePath, ModulePath))\r
MetaDataFileList.append(Path)\r
- self.FileList += GetNonMetaDataFiles(os.path.dirname(FullPath), ['CVS', '.svn'], False, PkgRelPath)\r
- \r
+ SkipList = ['CVS', '.svn']\r
+ NonMetaDataFileList = []\r
+ if Module.UniFileClassObject:\r
+ for UniFile in Module.UniFileClassObject.IncFileList:\r
+ OriPath = os.path.normpath(os.path.dirname(FullPath))\r
+ UniFilePath = os.path.normpath(os.path.join(PkgRelPath, UniFile.Path[len(OriPath) + 1:]))\r
+ if UniFilePath not in SkipModulesUniList:\r
+ SkipModulesUniList.append(UniFilePath)\r
+ for IncludeFile in Module.UniFileClassObject.IncludePathList:\r
+ if IncludeFile not in SkipModulesUniList:\r
+ SkipModulesUniList.append(IncludeFile)\r
+ NonMetaDataFileList = GetNonMetaDataFiles(os.path.dirname(FullPath), SkipList, False, PkgRelPath)\r
+ for NonMetaDataFile in NonMetaDataFileList:\r
+ if NonMetaDataFile not in self.FileList:\r
+ self.FileList.append(NonMetaDataFile)\r
for Guid, Version, Name, Path in self.ModuleSurfaceArea:\r
Module = self.ModuleSurfaceArea[Guid, Version, Name, Path]\r
ModulePath = Module.GetModulePath()\r
FullPath = Module.GetFullPath()\r
MetaDataFileList.append(Path)\r
- self.FileList += GetNonMetaDataFiles(os.path.dirname(FullPath), ['CVS', '.svn'], False, ModulePath)\r
- \r
+ SkipList = ['CVS', '.svn']\r
+ NonMetaDataFileList = []\r
+ if Module.UniFileClassObject:\r
+ for UniFile in Module.UniFileClassObject.IncFileList:\r
+ OriPath = os.path.normpath(os.path.dirname(FullPath))\r
+ UniFilePath = os.path.normpath(os.path.join(ModulePath, UniFile.Path[len(OriPath) + 1:]))\r
+ if UniFilePath not in SkipModulesUniList:\r
+ SkipModulesUniList.append(UniFilePath)\r
+ NonMetaDataFileList = GetNonMetaDataFiles(os.path.dirname(FullPath), SkipList, False, ModulePath)\r
+ for NonMetaDataFile in NonMetaDataFileList:\r
+ if NonMetaDataFile not in self.FileList:\r
+ self.FileList.append(NonMetaDataFile)\r
+ \r
+ for SkipModuleUni in SkipModulesUniList:\r
+ if SkipModuleUni in self.FileList:\r
+ self.FileList.remove(SkipModuleUni)\r
+\r
return self.FileList, MetaDataFileList\r
\r
\r
--- /dev/null
+## @file\r
+# This file hooks file and directory creation and removal\r
+#\r
+# Copyright (c) 2014, 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
+File hook\r
+'''\r
+\r
+import os\r
+import stat\r
+import time\r
+import zipfile\r
+from time import sleep\r
+from Library import GlobalData\r
+\r
+__built_in_remove__ = os.remove\r
+__built_in_mkdir__ = os.mkdir\r
+__built_in_rmdir__ = os.rmdir\r
+__built_in_chmod__ = os.chmod\r
+__built_in_open__ = open\r
+\r
+_RMFILE = 0\r
+_MKFILE = 1\r
+_RMDIR = 2\r
+_MKDIR = 3\r
+_CHMOD = 4\r
+\r
+gBACKUPFILE = 'file.backup'\r
+gEXCEPTION_LIST = ['Conf'+os.sep+'DistributionPackageDatabase.db', '.tmp', gBACKUPFILE]\r
+\r
+class _PathInfo:\r
+ def __init__(self, action, path, mode=-1):\r
+ self.action = action\r
+ self.path = path\r
+ self.mode = mode\r
+\r
+class RecoverMgr:\r
+ def __init__(self, workspace):\r
+ self.rlist = []\r
+ self.zip = None\r
+ self.workspace = os.path.normpath(workspace)\r
+ self.backupfile = gBACKUPFILE\r
+ self.zipfile = os.path.join(self.workspace, gBACKUPFILE)\r
+\r
+ def _createzip(self):\r
+ if self.zip:\r
+ return\r
+ self.zip = zipfile.ZipFile(self.zipfile, 'w', zipfile.ZIP_DEFLATED)\r
+\r
+ def _save(self, tmp, path):\r
+ if not self._tryhook(path):\r
+ return\r
+ self.rlist.append(_PathInfo(tmp, path))\r
+\r
+ def bkrmfile(self, path):\r
+ arc = self._tryhook(path)\r
+ if arc and os.path.isfile(path):\r
+ self._createzip()\r
+ self.zip.write(path, arc.encode('utf_8'))\r
+ sta = os.stat(path)\r
+ oldmode = stat.S_IMODE(sta.st_mode)\r
+ self.rlist.append(_PathInfo(_CHMOD, path, oldmode))\r
+ self.rlist.append(_PathInfo(_RMFILE, path))\r
+ __built_in_remove__(path)\r
+\r
+ def bkmkfile(self, path, mode, bufsize):\r
+ if not os.path.exists(path):\r
+ self._save(_MKFILE, path)\r
+ return __built_in_open__(path, mode, bufsize)\r
+\r
+ def bkrmdir(self, path):\r
+ if os.path.exists(path):\r
+ sta = os.stat(path)\r
+ oldmode = stat.S_IMODE(sta.st_mode)\r
+ self.rlist.append(_PathInfo(_CHMOD, path, oldmode))\r
+ self._save(_RMDIR, path)\r
+ __built_in_rmdir__(path)\r
+\r
+ def bkmkdir(self, path, mode):\r
+ if not os.path.exists(path):\r
+ self._save(_MKDIR, path)\r
+ __built_in_mkdir__(path, mode)\r
+\r
+ def bkchmod(self, path, mode):\r
+ if self._tryhook(path) and os.path.exists(path):\r
+ sta = os.stat(path)\r
+ oldmode = stat.S_IMODE(sta.st_mode)\r
+ self.rlist.append(_PathInfo(_CHMOD, path, oldmode))\r
+ __built_in_chmod__(path, mode)\r
+\r
+ def rollback(self):\r
+ if self.zip:\r
+ self.zip.close()\r
+ self.zip = None\r
+ index = len(self.rlist) - 1\r
+ while index >= 0:\r
+ item = self.rlist[index]\r
+ exist = os.path.exists(item.path)\r
+ if item.action == _MKFILE and exist:\r
+ #if not os.access(item.path, os.W_OK):\r
+ # os.chmod(item.path, S_IWUSR)\r
+ __built_in_remove__(item.path)\r
+ elif item.action == _RMFILE and not exist:\r
+ if not self.zip:\r
+ self.zip = zipfile.ZipFile(self.zipfile, 'r', zipfile.ZIP_DEFLATED)\r
+ arcname = os.path.normpath(item.path)\r
+ arcname = arcname[len(self.workspace)+1:].encode('utf_8')\r
+ if os.sep != "/" and os.sep in arcname:\r
+ arcname = arcname.replace(os.sep, '/')\r
+ mtime = self.zip.getinfo(arcname).date_time\r
+ content = self.zip.read(arcname)\r
+ filep = __built_in_open__(item.path, "wb")\r
+ filep.write(content)\r
+ filep.close()\r
+ intime = time.mktime(mtime + (0, 0, 0))\r
+ os.utime(item.path, (intime, intime))\r
+ elif item.action == _MKDIR and exist:\r
+ while True:\r
+ try:\r
+ __built_in_rmdir__(item.path)\r
+ break\r
+ except IOError:\r
+ # Sleep a short time and try again\r
+ # The anti-virus software may delay the file removal in this directory\r
+ sleep(0.1)\r
+ elif item.action == _RMDIR and not exist:\r
+ __built_in_mkdir__(item.path)\r
+ elif item.action == _CHMOD and exist:\r
+ try:\r
+ __built_in_chmod__(item.path, item.mode)\r
+ except EnvironmentError:\r
+ pass\r
+ index -= 1\r
+ self.commit()\r
+\r
+ def commit(self):\r
+ if self.zip:\r
+ self.zip.close()\r
+ __built_in_remove__(self.zipfile)\r
+\r
+ # Check if path needs to be hooked\r
+ def _tryhook(self, path):\r
+ path = os.path.normpath(path)\r
+ works = self.workspace if str(self.workspace).endswith(os.sep) else (self.workspace + os.sep)\r
+ if not path.startswith(works):\r
+ return ''\r
+ for exceptdir in gEXCEPTION_LIST:\r
+ full = os.path.join(self.workspace, exceptdir)\r
+ if full == path or path.startswith(full + os.sep) or os.path.split(full)[0] == path:\r
+ return ''\r
+ return path[len(self.workspace)+1:]\r
+\r
+def _hookrm(path):\r
+ if GlobalData.gRECOVERMGR:\r
+ GlobalData.gRECOVERMGR.bkrmfile(path)\r
+ else:\r
+ __built_in_remove__(path)\r
+\r
+def _hookmkdir(path, mode=0777):\r
+ if GlobalData.gRECOVERMGR:\r
+ GlobalData.gRECOVERMGR.bkmkdir(path, mode)\r
+ else:\r
+ __built_in_mkdir__(path, mode)\r
+\r
+def _hookrmdir(path):\r
+ if GlobalData.gRECOVERMGR:\r
+ GlobalData.gRECOVERMGR.bkrmdir(path)\r
+ else:\r
+ __built_in_rmdir__(path)\r
+\r
+def _hookmkfile(path, mode='r', bufsize=-1):\r
+ if GlobalData.gRECOVERMGR:\r
+ return GlobalData.gRECOVERMGR.bkmkfile(path, mode, bufsize)\r
+ return __built_in_open__(path, mode, bufsize)\r
+\r
+def _hookchmod(path, mode):\r
+ if GlobalData.gRECOVERMGR:\r
+ GlobalData.gRECOVERMGR.bkchmod(path, mode)\r
+ else:\r
+ __built_in_chmod__(path, mode)\r
+\r
+def SetRecoverMgr(mgr):\r
+ GlobalData.gRECOVERMGR = mgr\r
+\r
+os.remove = _hookrm\r
+os.mkdir = _hookmkdir\r
+os.rmdir = _hookrmdir\r
+os.chmod = _hookchmod\r
+__FileHookOpen__ = _hookmkfile\r
## @file\r
# This file is for installed package information database operations\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Logger import StringTable as ST\r
from Logger.ToolError import UPT_ALREADY_RUNNING_ERROR\r
from Logger.ToolError import UPT_DB_UPDATE_ERROR\r
+import platform as pf\r
\r
## IpiDb\r
#\r
#\r
#\r
class IpiDatabase(object):\r
- def __init__(self, DbPath):\r
+ def __init__(self, DbPath, Workspace):\r
Dir = os.path.dirname(DbPath)\r
if not os.path.isdir(Dir):\r
os.mkdir(Dir)\r
self.ModDepexTable = 'ModDepexInfo'\r
self.DpFileListTable = 'DpFileListInfo'\r
self.DummyTable = 'Dummy'\r
+ self.Workspace = os.path.normpath(Workspace)\r
\r
## Initialize build database\r
#\r
\r
Logger.Verbose(ST.MSG_INIT_IPI_FINISH)\r
\r
+ def RollBack(self):\r
+ self.Conn.rollback()\r
+\r
+ def Commit(self):\r
+ self.Conn.commit()\r
+\r
## Add a distribution install information from DpObj\r
#\r
# @param DpObj:\r
self._AddDp(DpObj.Header.GetGuid(), DpObj.Header.GetVersion(), \\r
NewDpPkgFileName, DpPkgFileName, RePackage)\r
\r
- self.Conn.commit()\r
except sqlite3.IntegrityError, DetailMsg:\r
Logger.Error("UPT",\r
UPT_DB_UPDATE_ERROR,\r
# @param Path: A Md5Sum\r
#\r
def _AddDpFilePathList(self, DpGuid, DpVersion, Path, Md5Sum):\r
- \r
+ Path = os.path.normpath(Path)\r
+ if pf.system() == 'Windows':\r
+ if Path.startswith(self.Workspace):\r
+ Path = Path[len(self.Workspace):]\r
+ else:\r
+ if Path.startswith(self.Workspace + os.sep):\r
+ Path = Path[len(self.Workspace)+1:]\r
SqlCommand = """insert into %s values('%s', '%s', '%s', '%s')""" % \\r
(self.DpFileListTable, Path, DpGuid, DpVersion, Md5Sum)\r
\r
\r
if PkgVersion == None or len(PkgVersion.strip()) == 0:\r
PkgVersion = 'N/A'\r
+ \r
+ if os.name == 'posix':\r
+ Path = Path.replace('\\', os.sep)\r
+ else:\r
+ Path = Path.replace('/', os.sep)\r
\r
#\r
# Add module from package information to DB.\r
\r
if DepexVersion == None or len(DepexVersion.strip()) == 0:\r
DepexVersion = 'N/A'\r
+ \r
+ if os.name == 'posix':\r
+ Path = Path.replace('\\', os.sep)\r
+ else:\r
+ Path = Path.replace('/', os.sep)\r
\r
#\r
# Add module depex information to DB.\r
(self.DpTable, DpGuid, DpVersion)\r
self.Cur.execute(SqlCommand)\r
\r
- self.Conn.commit()\r
+ #self.Conn.commit()\r
\r
## Get a list of distribution install information.\r
#\r
for Result in self.Cur:\r
Path = Result[0]\r
Md5Sum = Result[3]\r
- PathList.append((Path, Md5Sum))\r
+ PathList.append((os.path.join(self.Workspace, Path), Md5Sum))\r
\r
return PathList\r
\r
self.Cur.execute(SqlCommand)\r
for ModuleInfo in self.Cur:\r
FilePath = ModuleInfo[0]\r
- ModList.append(FilePath)\r
+ ModList.append(os.path.join(self.Workspace, FilePath))\r
\r
return ModList \r
\r
ModuleVersion = '%s' and InstallPath ='%s'\r
""" % (self.ModDepexTable, Guid, Version, Path)\r
self.Cur.execute(SqlCommand)\r
- self.Conn.commit()\r
+\r
\r
DepexList = []\r
for DepInfo in self.Cur:\r
DepexList.append((DepexGuid, DepexVersion))\r
\r
return DepexList\r
- \r
+ \r
+ ## Inventory the distribution installed to current workspace\r
+ #\r
+ # Inventory the distribution installed to current workspace\r
+ # \r
+ def InventoryDistInstalled(self):\r
+ SqlCommand = """select * from %s """ % (self.DpTable)\r
+ self.Cur.execute(SqlCommand)\r
+ \r
+ DpInfoList = []\r
+ for Result in self.Cur:\r
+ DpGuid = Result[0]\r
+ DpVersion = Result[1]\r
+ DpAliasName = Result[3]\r
+ DpFileName = Result[4] \r
+ DpInfoList.append((DpGuid, DpVersion, DpFileName, DpAliasName))\r
+ \r
+ return DpInfoList \r
+\r
## Close entire database\r
#\r
# Close the connection and cursor\r
#\r
# PackageFile class represents the zip file of a distribution package.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Logger import StringTable as ST\r
from Library.Misc import CreateDirectory\r
from Library.Misc import RemoveDirectory\r
-\r
+from Core.FileHook import __FileHookOpen__\r
\r
\r
class PackageFile:\r
## Extract the file\r
# \r
# @param Which: the source path \r
- # @param To: the destination path \r
+ # @param ToDest: the destination path \r
#\r
def Extract(self, Which, ToDest):\r
Which = os.path.normpath(Which)\r
Logger.Warn("PackagingTool", \\r
ST.WRN_FILE_NOT_OVERWRITTEN % ToDest)\r
return\r
- ToFile = open(ToDest, "wb")\r
+ else:\r
+ ToFile = __FileHookOpen__(ToDest, 'wb')\r
except BaseException, Xstr:\r
Logger.Error("PackagingTool", FILE_OPEN_FAILURE, \r
ExtraData="%s (%s)" % (ToDest, str(Xstr)))\r
#\r
def PackData(self, Data, ArcName):\r
try:\r
+ if os.path.splitext(ArcName)[1].lower() == '.pkg':\r
+ Data = Data.encode('utf_8')\r
self._ZipFile.writestr(ArcName, Data)\r
except BaseException, Xstr:\r
Logger.Error("PackagingTool", FILE_COMPRESS_FAILURE,\r
#\r
# This file contained the logical of transfer package object to DEC files.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
'''\r
GenDEC\r
'''\r
-\r
+import os\r
+import stat\r
+import codecs\r
+import md5\r
+from Core.FileHook import __FileHookOpen__\r
from Library.Parsing import GenSection\r
from Library.CommentGenerating import GenHeaderCommentSection\r
from Library.CommentGenerating import GenGenericCommentF\r
from Library.Misc import GuidStringToGuidStructureString\r
from Library.Misc import SaveFileOnChange\r
from Library.Misc import ConvertPath\r
+from Library.Misc import GetLocalValue\r
from Library.DataType import TAB_SPACE_SPLIT\r
from Library.DataType import TAB_COMMA_SPLIT\r
+from Library.DataType import END_OF_LINE\r
from Library.DataType import TAB_ARCH_COMMON\r
+from Library.DataType import TAB_VALUE_SPLIT\r
+from Library.DataType import TAB_COMMENT_SPLIT\r
+from Library.DataType import TAB_PCD_VALIDRANGE\r
+from Library.DataType import TAB_PCD_VALIDLIST\r
+from Library.DataType import TAB_PCD_EXPRESSION\r
from Library.DataType import TAB_DEC_DEFINES_DEC_SPECIFICATION\r
from Library.DataType import TAB_DEC_DEFINES_PACKAGE_NAME\r
from Library.DataType import TAB_DEC_DEFINES_PACKAGE_GUID\r
from Library.DataType import TAB_DEC_DEFINES_PACKAGE_VERSION\r
-\r
+from Library.DataType import TAB_DEC_DEFINES_PKG_UNI_FILE\r
+from Library.DataType import TAB_DEC_PACKAGE_ABSTRACT\r
+from Library.DataType import TAB_DEC_PACKAGE_DESCRIPTION\r
+from Library.DataType import TAB_DEC_BINARY_ABSTRACT\r
+from Library.DataType import TAB_DEC_BINARY_DESCRIPTION\r
+from Library.DataType import TAB_LANGUAGE_EN_X\r
+from Library.DataType import TAB_BINARY_HEADER_USERID\r
+from Library.DataType import TAB_BINARY_HEADER_IDENTIFIER\r
+from Library.DataType import TAB_COMMENT_EDK1_SPLIT\r
+from Library.DataType import TAB_ENCODING_UTF16LE\r
+from Library.DataType import TAB_CAPHEX_START\r
+from Library.DataType import TAB_HEX_START\r
+from Library.DataType import TAB_UNDERLINE_SPLIT\r
+from Library.DataType import TAB_STR_TOKENERR\r
+from Library.DataType import TAB_STR_TOKENCNAME\r
+from Library.DataType import TAB_PCD_ERROR_SECTION_COMMENT\r
+from Library.DataType import TAB_PCD_ERROR\r
+from Library.DataType import TAB_SECTION_START\r
+from Library.DataType import TAB_SECTION_END\r
+from Library.DataType import TAB_SPLIT\r
+from Library.UniClassObject import FormatUniEntry\r
\r
def GenPcd(Package, Content):\r
#\r
HelpTextList = Pcd.GetHelpTextList()\r
HelpStr = _GetHelpStr(HelpTextList)\r
CommentStr = GenGenericCommentF(HelpStr, 2)\r
-\r
+ \r
+ PromptList = Pcd.GetPromptList()\r
+ PromptStr = _GetHelpStr(PromptList)\r
+ CommentStr += GenGenericCommentF(PromptStr.strip(), 1, True)\r
+ \r
PcdErrList = Pcd.GetPcdErrorsList()\r
- if PcdErrList:\r
- CommentStr += GenPcdErrComment(PcdErrList[0])\r
+ for PcdErr in PcdErrList:\r
+ CommentStr += GenPcdErrComment(PcdErr)\r
Statement = CommentStr\r
-\r
+ \r
CName = Pcd.GetCName()\r
TokenSpaceGuidCName = Pcd.GetTokenSpaceGuidCName()\r
DefaultValue = Pcd.GetDefaultValue()\r
NewSectionDict[SortedArch] = [Statement] \r
\r
for ValidUsage in ValidUsageDict:\r
- Content += GenSection(ValidUsage, ValidUsageDict[ValidUsage])\r
+ Content += GenSection(ValidUsage, ValidUsageDict[ValidUsage], True, True)\r
\r
return Content\r
\r
+def GenPcdErrorMsgSection(Package, Content):\r
+ if not Package.PcdErrorCommentDict:\r
+ return Content\r
+ \r
+ #\r
+ # Generate '# [Error.<TokenSpcCName>]' section\r
+ #\r
+ Content += END_OF_LINE + END_OF_LINE\r
+ SectionComment = TAB_COMMENT_SPLIT + END_OF_LINE\r
+ SectionComment += TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT + TAB_PCD_ERROR_SECTION_COMMENT + END_OF_LINE\r
+ SectionComment += TAB_COMMENT_SPLIT + END_OF_LINE\r
+ TokenSpcCNameList = []\r
+ \r
+ #\r
+ # Get TokenSpcCName list in PcdErrorCommentDict in Package object\r
+ #\r
+ for (TokenSpcCName, ErrorNumber) in Package.PcdErrorCommentDict:\r
+ if TokenSpcCName not in TokenSpcCNameList:\r
+ TokenSpcCNameList.append(TokenSpcCName)\r
+ \r
+ for TokenSpcCNameItem in TokenSpcCNameList:\r
+ SectionName = TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT + TAB_SECTION_START + TAB_PCD_ERROR + \\r
+ TAB_SPLIT + TokenSpcCNameItem + TAB_SECTION_END + END_OF_LINE\r
+ Content += SectionComment\r
+ Content += SectionName\r
+ for (TokenSpcCName, ErrorNumber) in Package.PcdErrorCommentDict:\r
+ if TokenSpcCNameItem == TokenSpcCName:\r
+ PcdErrorMsg = GetLocalValue(Package.PcdErrorCommentDict[(TokenSpcCName, ErrorNumber)])\r
+ SectionItem = TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT + TAB_SPACE_SPLIT + \\r
+ ErrorNumber + TAB_SPACE_SPLIT + TAB_VALUE_SPLIT + TAB_SPACE_SPLIT + \\r
+ PcdErrorMsg + END_OF_LINE\r
+ Content += SectionItem\r
+ \r
+ Content += TAB_COMMENT_SPLIT\r
+ return Content\r
+ \r
def GenGuidProtocolPpi(Package, Content):\r
#\r
# generate [Guids] section\r
#\r
NewSectionDict = {}\r
+\r
+ LeftOffset = 46\r
+ # Get the line offset need\r
+ # If the real one < the min one, use the min one\r
+ # else use the real one\r
+ for Guid in Package.GetGuidList():\r
+ if len(Guid.GetCName()) > LeftOffset:\r
+ LeftOffset = len(Guid.GetCName())\r
+\r
+ # Generate\r
for Guid in Package.GetGuidList():\r
#\r
# Generate generic comment\r
Statement = CommentStr\r
CName = Guid.GetCName()\r
Value = GuidStringToGuidStructureString(Guid.GetGuid())\r
- Statement += CName + ' = ' + Value\r
+ Statement += CName.ljust(LeftOffset) + ' = ' + Value\r
#\r
# generate tail comment\r
#\r
else:\r
NewSectionDict[SortedArch] = [Statement] \r
\r
- Content += GenSection('Guids', NewSectionDict) \r
+ Content += GenSection('Guids', NewSectionDict, True, True)\r
\r
#\r
# generate [Protocols] section\r
#\r
NewSectionDict = {}\r
+ LeftOffset = 46\r
+ # Get the line offset need\r
+ # If the real one < the min one, use the min one\r
+ # else use the real one\r
+ for Protocol in Package.GetProtocolList():\r
+ if len(Protocol.GetCName()) > LeftOffset:\r
+ LeftOffset = len(Protocol.GetCName())\r
+\r
for Protocol in Package.GetProtocolList():\r
#\r
# Generate generic comment\r
Statement = CommentStr \r
CName = Protocol.GetCName()\r
Value = GuidStringToGuidStructureString(Protocol.GetGuid())\r
- Statement += CName + ' = ' + Value\r
+ Statement += CName.ljust(LeftOffset) + ' = ' + Value\r
\r
#\r
# generate tail comment\r
else:\r
NewSectionDict[SortedArch] = [Statement] \r
\r
- Content += GenSection('Protocols', NewSectionDict) \r
+ Content += GenSection('Protocols', NewSectionDict, True, True) \r
\r
#\r
# generate [Ppis] section\r
#\r
NewSectionDict = {}\r
+ LeftOffset = 46\r
+ # Get the line offset need\r
+ # If the real one < the min one, use the min one\r
+ # else use the real one\r
+ for Ppi in Package.GetPpiList():\r
+ if len(Ppi.GetCName()) > LeftOffset:\r
+ LeftOffset = len(Ppi.GetCName())\r
+\r
for Ppi in Package.GetPpiList():\r
#\r
# Generate generic comment\r
Statement = CommentStr\r
CName = Ppi.GetCName()\r
Value = GuidStringToGuidStructureString(Ppi.GetGuid())\r
- Statement += CName + ' = ' + Value\r
+ Statement += CName.ljust(LeftOffset) + ' = ' + Value\r
\r
#\r
# generate tail comment\r
else:\r
NewSectionDict[SortedArch] = [Statement] \r
\r
- Content += GenSection('Ppis', NewSectionDict)\r
+ Content += GenSection('Ppis', NewSectionDict, True, True)\r
\r
return Content\r
\r
#\r
# @param Package: A Package \r
#\r
-def PackageToDec(Package):\r
+def PackageToDec(Package, DistHeader = None):\r
#\r
# Init global information for the file\r
#\r
ContainerFile = Package.GetFullPath()\r
\r
Content = ''\r
+ \r
#\r
- # generate header comment section\r
+ # Generate file header \r
#\r
- Content += GenHeaderCommentSection(Package.GetAbstract(), \\r
- Package.GetDescription(), \\r
- Package.GetCopyright(), \\r
- Package.GetLicense())\r
- \r
+ PackageAbstract = GetLocalValue(Package.GetAbstract())\r
+ PackageDescription = GetLocalValue(Package.GetDescription())\r
+ PackageCopyright = ''\r
+ PackageLicense = ''\r
+ for (Lang, Copyright) in Package.GetCopyright():\r
+ if Lang:\r
+ pass\r
+ PackageCopyright = Copyright\r
+ for (Lang, License) in Package.GetLicense():\r
+ if Lang:\r
+ pass\r
+ PackageLicense = License\r
+ if not PackageAbstract and DistHeader:\r
+ PackageAbstract = GetLocalValue(DistHeader.GetAbstract())\r
+ if not PackageDescription and DistHeader:\r
+ PackageDescription = GetLocalValue(DistHeader.GetDescription())\r
+ if not PackageCopyright and DistHeader:\r
+ for (Lang, Copyright) in DistHeader.GetCopyright():\r
+ PackageCopyright = Copyright\r
+ if not PackageLicense and DistHeader:\r
+ for (Lang, License) in DistHeader.GetLicense():\r
+ PackageLicense = License\r
+ \r
+ #\r
+ # Generate header comment section of DEC file\r
+ #\r
+ Content += GenHeaderCommentSection(PackageAbstract, \\r
+ PackageDescription, \\r
+ PackageCopyright, \\r
+ PackageLicense)\r
+\r
+ #\r
+ # Generate Binary header \r
+ #\r
+ for UserExtension in Package.GetUserExtensionList():\r
+ if UserExtension.GetUserID() == TAB_BINARY_HEADER_USERID \\r
+ and UserExtension.GetIdentifier() == TAB_BINARY_HEADER_IDENTIFIER:\r
+ PackageBinaryAbstract = GetLocalValue(UserExtension.GetBinaryAbstract())\r
+ PackageBinaryDescription = GetLocalValue(UserExtension.GetBinaryDescription())\r
+ PackageBinaryCopyright = ''\r
+ PackageBinaryLicense = ''\r
+ for (Lang, Copyright) in UserExtension.GetBinaryCopyright():\r
+ PackageBinaryCopyright = Copyright\r
+ for (Lang, License) in UserExtension.GetBinaryLicense():\r
+ PackageBinaryLicense = License \r
+ if PackageBinaryAbstract and PackageBinaryDescription and \\r
+ PackageBinaryCopyright and PackageBinaryLicense:\r
+ Content += GenHeaderCommentSection(PackageBinaryAbstract, \r
+ PackageBinaryDescription, \r
+ PackageBinaryCopyright, \r
+ PackageBinaryLicense,\r
+ True)\r
+\r
+ #\r
+ # Generate PACKAGE_UNI_FILE for the Package\r
+ #\r
+ FileHeader = GenHeaderCommentSection(PackageAbstract, PackageDescription, PackageCopyright, PackageLicense, False, \\r
+ TAB_COMMENT_EDK1_SPLIT)\r
+ GenPackageUNIEncodeFile(Package, FileHeader)\r
+\r
#\r
# for each section, maintain a dict, sorted arch will be its key, \r
#statement list will be its data\r
#\r
# generate [Defines] section \r
#\r
+ LeftOffset = 31\r
NewSectionDict = {TAB_ARCH_COMMON : []}\r
SpecialItemList = []\r
\r
- Statement = '%s = %s' % (TAB_DEC_DEFINES_DEC_SPECIFICATION, '0x00010017')\r
+ Statement = (u'%s ' % TAB_DEC_DEFINES_DEC_SPECIFICATION).ljust(LeftOffset) + u'= %s' % '0x00010017'\r
SpecialItemList.append(Statement)\r
\r
BaseName = Package.GetBaseName()\r
if BaseName.startswith('.') or BaseName.startswith('-'):\r
BaseName = '_' + BaseName\r
- Statement = '%s = %s' % (TAB_DEC_DEFINES_PACKAGE_NAME, BaseName)\r
+ Statement = (u'%s ' % TAB_DEC_DEFINES_PACKAGE_NAME).ljust(LeftOffset) + u'= %s' % BaseName\r
SpecialItemList.append(Statement)\r
- Statement = '%s = %s' % (TAB_DEC_DEFINES_PACKAGE_VERSION, Package.GetVersion())\r
+\r
+ Statement = (u'%s ' % TAB_DEC_DEFINES_PACKAGE_VERSION).ljust(LeftOffset) + u'= %s' % Package.GetVersion()\r
SpecialItemList.append(Statement)\r
- Statement = '%s = %s' % (TAB_DEC_DEFINES_PACKAGE_GUID, Package.GetGuid())\r
- SpecialItemList.append(Statement) \r
+\r
+ Statement = (u'%s ' % TAB_DEC_DEFINES_PACKAGE_GUID).ljust(LeftOffset) + u'= %s' % Package.GetGuid()\r
+ SpecialItemList.append(Statement)\r
+\r
+ if Package.UNIFlag:\r
+ Statement = (u'%s ' % TAB_DEC_DEFINES_PKG_UNI_FILE).ljust(LeftOffset) + u'= %s' % Package.GetBaseName() + '.uni'\r
+ SpecialItemList.append(Statement) \r
+\r
for SortedArch in NewSectionDict:\r
NewSectionDict[SortedArch] = \\r
NewSectionDict[SortedArch] + SpecialItemList\r
else:\r
NewSectionDict[SortedArch] = [ConvertPath(Statement)]\r
\r
- Content += GenSection('Includes', NewSectionDict) \r
+ Content += GenSection('Includes', NewSectionDict)\r
\r
+ #\r
+ # generate [guids][protocols][ppis] sections\r
+ #\r
Content = GenGuidProtocolPpi(Package, Content)\r
\r
#\r
HelpTextList = LibraryClass.GetHelpTextList()\r
HelpStr = _GetHelpStr(HelpTextList)\r
if HelpStr:\r
- HelpStr = '@libraryclass ' + HelpStr\r
- CommentStr = GenGenericCommentF(HelpStr, 2)\r
+ HelpStr = '@libraryclass' + HelpStr\r
+ CommentStr = GenGenericCommentF(HelpStr, 2, False, True)\r
\r
Statement = CommentStr\r
Name = LibraryClass.GetLibraryClass()\r
else:\r
NewSectionDict[SortedArch] = [Statement] \r
\r
- Content += GenSection('LibraryClasses', NewSectionDict)\r
+ Content += GenSection('LibraryClasses', NewSectionDict, True, True)\r
\r
- Content = GenPcd(Package, Content)\r
+ #\r
+ # Generate '# [Error.<TokenSpcCName>]' section\r
+ #\r
+ Content = GenPcdErrorMsgSection(Package, Content)\r
\r
+ Content = GenPcd(Package, Content)\r
+\r
#\r
# generate [UserExtensions] section\r
#\r
NewSectionDict = {}\r
for UserExtension in Package.GetUserExtensionList():\r
+ if UserExtension.GetUserID() == TAB_BINARY_HEADER_USERID and \\r
+ UserExtension.GetIdentifier() == TAB_BINARY_HEADER_IDENTIFIER:\r
+ continue\r
Statement = UserExtension.GetStatement()\r
if not Statement:\r
continue\r
+ else:\r
+ LineList = Statement.split('\n')\r
+ NewStatement = ""\r
+ for Line in LineList:\r
+ NewStatement += " %s\n" % Line\r
\r
SectionList = []\r
SectionName = 'UserExtensions'\r
SectionList.append(SectionName + '.' + Arch)\r
SectionName = ', '.join(SectionList)\r
SectionName = ''.join(['[', SectionName, ']\n'])\r
- Content += '\n\n' + SectionName + Statement\r
+ Content += '\n' + SectionName + NewStatement\r
\r
SaveFileOnChange(ContainerFile, Content, False)\r
+ if DistHeader.ReadOnly:\r
+ os.chmod(ContainerFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH)\r
+ else:\r
+ os.chmod(ContainerFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH|stat.S_IWUSR|stat.S_IWGRP|stat.S_IWOTH)\r
return ContainerFile\r
\r
+## GenPackageUNIEncodeFile\r
+# GenPackageUNIEncodeFile, default is a UCS-2LE encode file\r
+#\r
+def GenPackageUNIEncodeFile(PackageObject, UniFileHeader = '', Encoding=TAB_ENCODING_UTF16LE):\r
+ GenUNIFlag = False\r
+ OnlyLANGUAGE_EN_X = True\r
+ BinaryAbstract = []\r
+ BinaryDescription = []\r
+ #\r
+ # If more than one language code is used for any element that would be present in the PACKAGE_UNI_FILE, \r
+ # then the PACKAGE_UNI_FILE must be created.\r
+ #\r
+ for (Key, Value) in PackageObject.GetAbstract() + PackageObject.GetDescription():\r
+ if Key == TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+ \r
+ for UserExtension in PackageObject.GetUserExtensionList():\r
+ if UserExtension.GetUserID() == TAB_BINARY_HEADER_USERID \\r
+ and UserExtension.GetIdentifier() == TAB_BINARY_HEADER_IDENTIFIER:\r
+ for (Key, Value) in UserExtension.GetBinaryAbstract():\r
+ if Key == TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+ BinaryAbstract.append((Key, Value))\r
+\r
+ for (Key, Value) in UserExtension.GetBinaryDescription():\r
+ if Key == TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+ BinaryDescription.append((Key, Value))\r
+\r
+ for Pcd in PackageObject.GetPcdList():\r
+ for TxtObj in Pcd.GetPromptList() + Pcd.GetHelpTextList():\r
+ if TxtObj.GetLang() == TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+ \r
+ for PcdError in Pcd.GetPcdErrorsList():\r
+ if PcdError.GetErrorNumber().startswith('0x') or PcdError.GetErrorNumber().startswith('0X'):\r
+ for (Key, Value) in PcdError.GetErrorMessageList():\r
+ if Key == TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+ if not GenUNIFlag:\r
+ return\r
+ elif OnlyLANGUAGE_EN_X:\r
+ return\r
+ else:\r
+ PackageObject.UNIFlag = True\r
+ \r
+ if not os.path.exists(os.path.dirname(PackageObject.GetFullPath())):\r
+ os.makedirs(os.path.dirname(PackageObject.GetFullPath()))\r
+ ContainerFile = os.path.normpath(os.path.join(os.path.dirname(PackageObject.GetFullPath()), \r
+ (PackageObject.GetBaseName() + '.uni')))\r
+ \r
+ Content = UniFileHeader + os.linesep\r
+ Content += os.linesep\r
+ \r
+ Content += FormatUniEntry('#string ' + TAB_DEC_PACKAGE_ABSTRACT, PackageObject.GetAbstract(), ContainerFile) \\r
+ + os.linesep\r
+ \r
+ Content += FormatUniEntry('#string ' + TAB_DEC_PACKAGE_DESCRIPTION, PackageObject.GetDescription(), ContainerFile) \\r
+ + os.linesep\r
+ \r
+ Content += FormatUniEntry('#string ' + TAB_DEC_BINARY_ABSTRACT, BinaryAbstract, ContainerFile) \\r
+ + os.linesep\r
+ \r
+ Content += FormatUniEntry('#string ' + TAB_DEC_BINARY_DESCRIPTION, BinaryDescription, ContainerFile) \\r
+ + os.linesep\r
+ \r
+ PromptGenList = []\r
+ HelpTextGenList = [] \r
+ for Pcd in PackageObject.GetPcdList():\r
+ # Generate Prompt for each Pcd\r
+ PcdPromptStrName = '#string ' + 'STR_' + Pcd.GetTokenSpaceGuidCName() + '_' + Pcd.GetCName() + '_PROMPT '\r
+ TokenValueList = []\r
+ for TxtObj in Pcd.GetPromptList():\r
+ Lang = TxtObj.GetLang()\r
+ PromptStr = TxtObj.GetString()\r
+ #\r
+ # Avoid generating the same PROMPT entry more than one time. \r
+ #\r
+ if (PcdPromptStrName, Lang) not in PromptGenList:\r
+ TokenValueList.append((Lang, PromptStr))\r
+ PromptGenList.append((PcdPromptStrName, Lang))\r
+ PromptString = FormatUniEntry(PcdPromptStrName, TokenValueList, ContainerFile) + os.linesep\r
+ if PromptString not in Content:\r
+ Content += PromptString\r
+ \r
+ # Generate Help String for each Pcd\r
+ PcdHelpStrName = '#string ' + 'STR_' + Pcd.GetTokenSpaceGuidCName() + '_' + Pcd.GetCName() + '_HELP '\r
+ TokenValueList = []\r
+ for TxtObj in Pcd.GetHelpTextList():\r
+ Lang = TxtObj.GetLang()\r
+ HelpStr = TxtObj.GetString()\r
+ #\r
+ # Avoid generating the same HELP entry more than one time. \r
+ #\r
+ if (PcdHelpStrName, Lang) not in HelpTextGenList:\r
+ TokenValueList.append((Lang, HelpStr))\r
+ HelpTextGenList.append((PcdHelpStrName, Lang))\r
+ HelpTextString = FormatUniEntry(PcdHelpStrName, TokenValueList, ContainerFile) + os.linesep\r
+ if HelpTextString not in Content:\r
+ Content += HelpTextString\r
+ \r
+ # Generate PcdError for each Pcd if ErrorNo exist.\r
+ for PcdError in Pcd.GetPcdErrorsList():\r
+ ErrorNo = PcdError.GetErrorNumber()\r
+ if ErrorNo.startswith(TAB_HEX_START) or ErrorNo.startswith(TAB_CAPHEX_START):\r
+ PcdErrStrName = '#string ' + TAB_STR_TOKENCNAME + TAB_UNDERLINE_SPLIT + Pcd.GetTokenSpaceGuidCName() \\r
+ + TAB_UNDERLINE_SPLIT + TAB_STR_TOKENERR \\r
+ + TAB_UNDERLINE_SPLIT + ErrorNo[2:]\r
+ PcdErrString = FormatUniEntry(PcdErrStrName, PcdError.GetErrorMessageList(), ContainerFile) + os.linesep\r
+ if PcdErrString not in Content:\r
+ Content += PcdErrString\r
+ \r
+ File = codecs.open(ContainerFile, 'w', Encoding)\r
+ File.write(u'\uFEFF' + Content)\r
+ File.stream.close()\r
+ Md5Sigature = md5.new(__FileHookOpen__(str(ContainerFile), 'rb').read())\r
+ Md5Sum = Md5Sigature.hexdigest()\r
+ if (ContainerFile, Md5Sum) not in PackageObject.FileList:\r
+ PackageObject.FileList.append((ContainerFile, Md5Sum))\r
+\r
+ return ContainerFile\r
+ \r
## GenPcdErrComment\r
#\r
# @param PcdErrObject: PcdErrorObject\r
# @retval CommentStr: Generated comment lines, with prefix "#"\r
# \r
def GenPcdErrComment (PcdErrObject):\r
- EndOfLine = "\n" \r
+ CommentStr = '' \r
+ ErrorCode = PcdErrObject.GetErrorNumber()\r
ValidValueRange = PcdErrObject.GetValidValueRange()\r
if ValidValueRange:\r
- CommentStr = "# @ValidRange " + ValidValueRange + EndOfLine\r
+ CommentStr = TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT + TAB_PCD_VALIDRANGE + TAB_SPACE_SPLIT \r
+ if ErrorCode:\r
+ CommentStr += ErrorCode + TAB_SPACE_SPLIT + TAB_VALUE_SPLIT + TAB_SPACE_SPLIT\r
+ CommentStr += ValidValueRange + END_OF_LINE\r
\r
ValidValue = PcdErrObject.GetValidValue()\r
if ValidValue:\r
ValidValueList = \\r
[Value for Value in ValidValue.split(TAB_SPACE_SPLIT) if Value]\r
- CommentStr = \\r
- "# @ValidList " + TAB_COMMA_SPLIT.join(ValidValueList) + EndOfLine\r
+ CommentStr = TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT + TAB_PCD_VALIDLIST + TAB_SPACE_SPLIT\r
+ if ErrorCode:\r
+ CommentStr += ErrorCode + TAB_SPACE_SPLIT + TAB_VALUE_SPLIT + TAB_SPACE_SPLIT\r
+ CommentStr += TAB_COMMA_SPLIT.join(ValidValueList) + END_OF_LINE\r
\r
Expression = PcdErrObject.GetExpression()\r
if Expression:\r
- CommentStr = "# @Expression " + Expression + EndOfLine\r
+ CommentStr = TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT + TAB_PCD_EXPRESSION + TAB_SPACE_SPLIT\r
+ if ErrorCode:\r
+ CommentStr += ErrorCode + TAB_SPACE_SPLIT + TAB_VALUE_SPLIT + TAB_SPACE_SPLIT\r
+ CommentStr += Expression + END_OF_LINE\r
\r
return CommentStr\r
\r
#\r
# This file contained the logical of transfer package object to INF files.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
'''\r
GenInf\r
'''\r
-from os import getenv\r
+import os\r
+import stat\r
+import codecs\r
+import md5\r
+from Core.FileHook import __FileHookOpen__\r
from Library.String import GetSplitValueList\r
from Library.Parsing import GenSection\r
from Library.Parsing import GetWorkspacePackage\r
-from Library.Parsing import ConvertArchForInstall \r
+from Library.Parsing import ConvertArchForInstall\r
from Library.Misc import SaveFileOnChange\r
from Library.Misc import IsAllModuleList\r
from Library.Misc import Sdict\r
from Library.Misc import ConvertPath\r
from Library.Misc import ConvertSpec\r
+from Library.Misc import GetRelativePath\r
+from Library.Misc import GetLocalValue\r
from Library.CommentGenerating import GenHeaderCommentSection\r
from Library.CommentGenerating import GenGenericCommentF\r
from Library.CommentGenerating import _GetHelpStr\r
import Logger.Log as Logger\r
from Library import DataType as DT\r
from GenMetaFile import GenMetaFileMisc\r
+from Library.UniClassObject import FormatUniEntry\r
+\r
\r
## Transfer Module Object to Inf files\r
#\r
# Transfer all contents of a standard Module Object to an Inf file \r
# @param ModuleObject: A Module Object \r
#\r
-def ModuleToInf(ModuleObject):\r
- if not GlobalData.gWSPKG_LIST: \r
+def ModuleToInf(ModuleObject, PackageObject=None, DistHeader=None):\r
+ if not GlobalData.gWSPKG_LIST:\r
GlobalData.gWSPKG_LIST = GetWorkspacePackage()\r
- \r
#\r
# Init global information for the file\r
#\r
ContainerFile = ModuleObject.GetFullPath()\r
+\r
Content = ''\r
#\r
- # generate header comment section\r
+ # Generate file header, If any Abstract, Description, Copyright or License XML elements are missing, \r
+ # should 1) use the Abstract, Description, Copyright or License from the PackageSurfaceArea.Header elements \r
+ # that the module belongs to, or 2) if this is a stand-alone module that is not included in a PackageSurfaceArea, \r
+ # use the abstract, description, copyright or license from the DistributionPackage.Header elements.\r
+ #\r
+ ModuleAbstract = GetLocalValue(ModuleObject.GetAbstract())\r
+ if not ModuleAbstract and PackageObject:\r
+ ModuleAbstract = GetLocalValue(PackageObject.GetAbstract())\r
+ if not ModuleAbstract and DistHeader:\r
+ ModuleAbstract = GetLocalValue(DistHeader.GetAbstract())\r
+ ModuleDescription = GetLocalValue(ModuleObject.GetDescription())\r
+ if not ModuleDescription and PackageObject:\r
+ ModuleDescription = GetLocalValue(PackageObject.GetDescription())\r
+ if not ModuleDescription and DistHeader:\r
+ ModuleDescription = GetLocalValue(DistHeader.GetDescription())\r
+ ModuleCopyright = ''\r
+ for (Lang, Copyright) in ModuleObject.GetCopyright():\r
+ if Lang:\r
+ pass\r
+ ModuleCopyright = Copyright\r
+ if not ModuleCopyright and PackageObject:\r
+ for (Lang, Copyright) in PackageObject.GetCopyright():\r
+ if Lang:\r
+ pass\r
+ ModuleCopyright = Copyright\r
+ if not ModuleCopyright and DistHeader:\r
+ for (Lang, Copyright) in DistHeader.GetCopyright():\r
+ if Lang:\r
+ pass\r
+ ModuleCopyright = Copyright\r
+ ModuleLicense = ''\r
+ for (Lang, License) in ModuleObject.GetLicense():\r
+ if Lang:\r
+ pass\r
+ ModuleLicense = License\r
+ if not ModuleLicense and PackageObject:\r
+ for (Lang, License) in PackageObject.GetLicense():\r
+ if Lang:\r
+ pass\r
+ ModuleLicense = License\r
+ if not ModuleLicense and DistHeader:\r
+ for (Lang, License) in DistHeader.GetLicense():\r
+ if Lang:\r
+ pass\r
+ ModuleLicense = License\r
+\r
+ #\r
+ # Generate header comment section of INF file\r
# \r
- Content += GenHeaderCommentSection(ModuleObject.GetAbstract(), \r
- ModuleObject.GetDescription(), \r
- ModuleObject.GetCopyright(), \r
- ModuleObject.GetLicense())\r
- \r
+ Content += GenHeaderCommentSection(ModuleAbstract,\r
+ ModuleDescription,\r
+ ModuleCopyright,\r
+ ModuleLicense)\r
+\r
+ #\r
+ # Generate Binary Header \r
+ # \r
+ for UserExtension in ModuleObject.GetUserExtensionList():\r
+ if UserExtension.GetUserID() == DT.TAB_BINARY_HEADER_USERID \\r
+ and UserExtension.GetIdentifier() == DT.TAB_BINARY_HEADER_IDENTIFIER:\r
+ ModuleBinaryAbstract = GetLocalValue(UserExtension.GetBinaryAbstract())\r
+ ModuleBinaryDescription = GetLocalValue(UserExtension.GetBinaryDescription())\r
+ ModuleBinaryCopyright = ''\r
+ ModuleBinaryLicense = ''\r
+ for (Lang, Copyright) in UserExtension.GetBinaryCopyright():\r
+ ModuleBinaryCopyright = Copyright\r
+ for (Lang, License) in UserExtension.GetBinaryLicense():\r
+ ModuleBinaryLicense = License\r
+ if ModuleBinaryAbstract and ModuleBinaryDescription and \\r
+ ModuleBinaryCopyright and ModuleBinaryLicense:\r
+ Content += GenHeaderCommentSection(ModuleBinaryAbstract,\r
+ ModuleBinaryDescription,\r
+ ModuleBinaryCopyright,\r
+ ModuleBinaryLicense,\r
+ True)\r
+\r
+ #\r
+ # Generate MODULE_UNI_FILE for module\r
+ #\r
+ FileHeader = GenHeaderCommentSection(ModuleAbstract, ModuleDescription, ModuleCopyright, ModuleLicense, False, \\r
+ DT.TAB_COMMENT_EDK1_SPLIT)\r
+ GenModuleUNIEncodeFile(ModuleObject, FileHeader)\r
+\r
#\r
# Judge whether the INF file is an AsBuild INF.\r
#\r
GlobalData.gIS_BINARY_INF = True\r
else:\r
GlobalData.gIS_BINARY_INF = False\r
- \r
#\r
# for each section, maintain a dict, sorted arch will be its key, \r
# statement list will be its data\r
# { 'Arch1 Arch2 Arch3': [statement1, statement2],\r
# 'Arch1' : [statement1, statement3] \r
# }\r
- #\r
- \r
#\r
# Gen section contents\r
#\r
Content += GenPackages(ModuleObject)\r
Content += GenPcdSections(ModuleObject)\r
Content += GenSources(ModuleObject)\r
- Content += GenProtocolPPiSections(ModuleObject.GetProtocolList(), True) \r
- Content += GenProtocolPPiSections(ModuleObject.GetPpiList(), False) \r
- Content += GenGuidSections(ModuleObject.GetGuidList()) \r
+ Content += GenProtocolPPiSections(ModuleObject.GetProtocolList(), True)\r
+ Content += GenProtocolPPiSections(ModuleObject.GetPpiList(), False)\r
+ Content += GenGuidSections(ModuleObject.GetGuidList())\r
Content += GenBinaries(ModuleObject)\r
Content += GenDepex(ModuleObject)\r
- Content += GenUserExtensions(ModuleObject) \r
-\r
+ Content += GenUserExtensions(ModuleObject)\r
if ModuleObject.GetEventList() or ModuleObject.GetBootModeList() or ModuleObject.GetHobList():\r
- Content += '\n\n'\r
+ Content += '\n'\r
#\r
# generate [Event], [BootMode], [Hob] section\r
#\r
- Content += GenSpecialSections(ModuleObject.GetEventList(), 'Event') \r
+ Content += GenSpecialSections(ModuleObject.GetEventList(), 'Event')\r
Content += GenSpecialSections(ModuleObject.GetBootModeList(), 'BootMode')\r
Content += GenSpecialSections(ModuleObject.GetHobList(), 'Hob')\r
-\r
SaveFileOnChange(ContainerFile, Content, False)\r
+ if DistHeader.ReadOnly:\r
+ os.chmod(ContainerFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH)\r
+ else:\r
+ os.chmod(ContainerFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH|stat.S_IWUSR|stat.S_IWGRP|stat.S_IWOTH)\r
return ContainerFile\r
\r
+## GenModuleUNIEncodeFile\r
+# GenModuleUNIEncodeFile, default is a UCS-2LE encode file\r
+#\r
+def GenModuleUNIEncodeFile(ModuleObject, UniFileHeader='', Encoding=DT.TAB_ENCODING_UTF16LE):\r
+ GenUNIFlag = False\r
+ OnlyLANGUAGE_EN_X = True\r
+ BinaryAbstract = []\r
+ BinaryDescription = []\r
+ #\r
+ # If more than one language code is used for any element that would be present in the MODULE_UNI_FILE, \r
+ # then the MODULE_UNI_FILE must be created.\r
+ #\r
+ for (Key, Value) in ModuleObject.GetAbstract() + ModuleObject.GetDescription():\r
+ if Key == DT.TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+\r
+ for UserExtension in ModuleObject.GetUserExtensionList():\r
+ if UserExtension.GetUserID() == DT.TAB_BINARY_HEADER_USERID \\r
+ and UserExtension.GetIdentifier() == DT.TAB_BINARY_HEADER_IDENTIFIER:\r
+ for (Key, Value) in UserExtension.GetBinaryAbstract():\r
+ if Key == DT.TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+ BinaryAbstract.append((Key, Value))\r
+ for (Key, Value) in UserExtension.GetBinaryDescription():\r
+ if Key == DT.TAB_LANGUAGE_EN_X:\r
+ GenUNIFlag = True\r
+ else:\r
+ OnlyLANGUAGE_EN_X = False\r
+ BinaryDescription.append((Key, Value))\r
+\r
+\r
+ if not GenUNIFlag:\r
+ return\r
+ elif OnlyLANGUAGE_EN_X:\r
+ return\r
+ else:\r
+ ModuleObject.UNIFlag = True\r
+ ContainerFile = os.path.normpath(os.path.join(os.path.dirname(ModuleObject.GetFullPath()),\r
+ (ModuleObject.GetBaseName() + '.uni')))\r
+ if not os.path.exists(os.path.dirname(ModuleObject.GetFullPath())):\r
+ os.makedirs(os.path.dirname(ModuleObject.GetFullPath()))\r
+\r
+ Content = UniFileHeader + os.linesep\r
+ Content += DT.END_OF_LINE\r
+\r
+ Content += FormatUniEntry('#string ' + DT.TAB_INF_ABSTRACT, ModuleObject.GetAbstract(), ContainerFile) + os.linesep\r
+\r
+ Content += FormatUniEntry('#string ' + DT.TAB_INF_DESCRIPTION, ModuleObject.GetDescription(), ContainerFile) \\r
+ + os.linesep\r
+\r
+ BinaryAbstractString = FormatUniEntry('#string ' + DT.TAB_INF_BINARY_ABSTRACT, BinaryAbstract, ContainerFile)\r
+ if BinaryAbstractString:\r
+ Content += BinaryAbstractString + os.linesep\r
+\r
+ BinaryDescriptionString = FormatUniEntry('#string ' + DT.TAB_INF_BINARY_DESCRIPTION, BinaryDescription, \\r
+ ContainerFile)\r
+ if BinaryDescriptionString:\r
+ Content += BinaryDescriptionString + os.linesep\r
+\r
+ if not os.path.exists(ContainerFile):\r
+ File = codecs.open(ContainerFile, 'wb', Encoding)\r
+ File.write(u'\uFEFF' + Content)\r
+ File.stream.close()\r
+ Md5Sigature = md5.new(__FileHookOpen__(str(ContainerFile), 'rb').read())\r
+ Md5Sum = Md5Sigature.hexdigest()\r
+ if (ContainerFile, Md5Sum) not in ModuleObject.FileList:\r
+ ModuleObject.FileList.append((ContainerFile, Md5Sum))\r
+\r
+ return ContainerFile\r
def GenDefines(ModuleObject):\r
#\r
# generate [Defines] section\r
#\r
- Content = '' \r
- NewSectionDict = {} \r
+ Content = ''\r
+ NewSectionDict = {}\r
for UserExtension in ModuleObject.GetUserExtensionList():\r
DefinesDict = UserExtension.GetDefinesDict()\r
if not DefinesDict:\r
continue\r
- \r
for Statement in DefinesDict:\r
SortedArch = DT.TAB_ARCH_COMMON\r
if Statement.strip().startswith(DT.TAB_INF_DEFINES_CUSTOM_MAKEFILE):\r
if SortedArch in NewSectionDict:\r
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]\r
else:\r
- NewSectionDict[SortedArch] = [Statement] \r
-\r
+ NewSectionDict[SortedArch] = [Statement]\r
SpecialStatementList = []\r
- \r
#\r
# Add INF_VERSION statement firstly\r
#\r
- Statement = 'INF_VERSION = 0x00010017'\r
+ \r
+ LeftOffset = 31\r
+ # TAB_INF_DEFINES_INF_VERSION\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_INF_VERSION).ljust(LeftOffset) + u'= %s' % '0x00010017'\r
SpecialStatementList.append(Statement)\r
\r
+ # BaseName\r
BaseName = ModuleObject.GetBaseName()\r
if BaseName.startswith('.') or BaseName.startswith('-'):\r
BaseName = '_' + BaseName\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_BASE_NAME, BaseName)\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_BASE_NAME).ljust(LeftOffset) + u'= %s' % BaseName\r
SpecialStatementList.append(Statement)\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_FILE_GUID, ModuleObject.GetGuid())\r
- SpecialStatementList.append(Statement)\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_VERSION_STRING, ModuleObject.GetVersion())\r
+ \r
+ # TAB_INF_DEFINES_FILE_GUID\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_FILE_GUID).ljust(LeftOffset) + u'= %s' % ModuleObject.GetGuid()\r
SpecialStatementList.append(Statement)\r
\r
+ # TAB_INF_DEFINES_VERSION_STRING\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_VERSION_STRING).ljust(LeftOffset) + u'= %s' % ModuleObject.GetVersion()\r
+ SpecialStatementList.append(Statement)\r
+\r
+ # TAB_INF_DEFINES_VERSION_STRING\r
+ if ModuleObject.UNIFlag:\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_MODULE_UNI_FILE).ljust(LeftOffset) + \\r
+ u'= %s' % ModuleObject.GetBaseName() + '.uni'\r
+ SpecialStatementList.append(Statement)\r
+\r
+ # TAB_INF_DEFINES_MODULE_TYPE\r
if ModuleObject.GetModuleType():\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_MODULE_TYPE, ModuleObject.GetModuleType())\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_MODULE_TYPE).ljust(LeftOffset) + u'= %s' % ModuleObject.GetModuleType()\r
SpecialStatementList.append(Statement)\r
+\r
+ # TAB_INF_DEFINES_PCD_IS_DRIVER\r
if ModuleObject.GetPcdIsDriver():\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_PCD_IS_DRIVER, ModuleObject.GetPcdIsDriver())\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_PCD_IS_DRIVER).ljust(LeftOffset) + \\r
+ u'= %s' % ModuleObject.GetPcdIsDriver()\r
SpecialStatementList.append(Statement)\r
+\r
+ # TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION\r
if ModuleObject.GetUefiSpecificationVersion():\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION, \\r
- ModuleObject.GetUefiSpecificationVersion())\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION).ljust(LeftOffset) + \\r
+ u'= %s' % ModuleObject.GetUefiSpecificationVersion()\r
SpecialStatementList.append(Statement)\r
+\r
+ # TAB_INF_DEFINES_PI_SPECIFICATION_VERSION\r
if ModuleObject.GetPiSpecificationVersion():\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION, ModuleObject.GetPiSpecificationVersion())\r
- SpecialStatementList.append(Statement) \r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION).ljust(LeftOffset) + \\r
+ u'= %s' % ModuleObject.GetPiSpecificationVersion()\r
+ SpecialStatementList.append(Statement)\r
+\r
+ # LibraryClass\r
for LibraryClass in ModuleObject.GetLibraryClassList():\r
if LibraryClass.GetUsage() == DT.USAGE_ITEM_PRODUCES or \\r
LibraryClass.GetUsage() == DT.USAGE_ITEM_SOMETIMES_PRODUCES:\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_LIBRARY_CLASS, LibraryClass.GetLibraryClass())\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_LIBRARY_CLASS).ljust(LeftOffset) + \\r
+ u'= %s' % LibraryClass.GetLibraryClass()\r
if LibraryClass.GetSupModuleList():\r
Statement += '|' + DT.TAB_SPACE_SPLIT.join(l for l in LibraryClass.GetSupModuleList())\r
SpecialStatementList.append(Statement)\r
+\r
+ # Spec Item\r
for SpecItem in ModuleObject.GetSpecList():\r
Spec, Version = SpecItem\r
Spec = ConvertSpec(Spec)\r
Statement = '%s %s = %s' % (DT.TAB_INF_DEFINES_SPEC, Spec, Version)\r
SpecialStatementList.append(Statement)\r
- \r
+\r
+ # Extern\r
ExternList = []\r
for Extern in ModuleObject.GetExternList():\r
ArchList = Extern.GetSupArchList()\r
HelpStringList = Extern.GetHelpTextList()\r
FFE = Extern.GetFeatureFlag()\r
ExternList.append([ArchList, EntryPoint, UnloadImage, Constructor, Destructor, FFE, HelpStringList])\r
- \r
#\r
# Add VALID_ARCHITECTURES information\r
#\r
ValidArchStatement = None\r
if ModuleObject.SupArchList:\r
- ValidArchStatement = '# ' + '\n'\r
+ ValidArchStatement = '\n' + '# ' + '\n'\r
ValidArchStatement += '# The following information is for reference only and not required by the build tools.\n'\r
ValidArchStatement += '# ' + '\n'\r
ValidArchStatement += '# VALID_ARCHITECTURES = %s' % (' '.join(ModuleObject.SupArchList)) + '\n'\r
- ValidArchStatement += '# ' + '\n'\r
- \r
+ ValidArchStatement += '# '\r
if DT.TAB_ARCH_COMMON not in NewSectionDict:\r
NewSectionDict[DT.TAB_ARCH_COMMON] = []\r
NewSectionDict[DT.TAB_ARCH_COMMON] = NewSectionDict[DT.TAB_ARCH_COMMON] + SpecialStatementList\r
GenMetaFileMisc.AddExternToDefineSec(NewSectionDict, DT.TAB_ARCH_COMMON, ExternList)\r
if ValidArchStatement is not None:\r
NewSectionDict[DT.TAB_ARCH_COMMON] = NewSectionDict[DT.TAB_ARCH_COMMON] + [ValidArchStatement]\r
- \r
Content += GenSection('Defines', NewSectionDict)\r
- \r
return Content\r
\r
def GenLibraryClasses(ModuleObject):\r
FFE = LibraryClass.GetFeatureFlag()\r
Statement += Name\r
if FFE:\r
- Statement += '|' + FFE \r
+ Statement += '|' + FFE\r
ModuleList = LibraryClass.GetSupModuleList()\r
ArchList = LibraryClass.GetSupArchList()\r
for Index in xrange(0, len(ArchList)):\r
ArchList[Index] = ConvertArchForInstall(ArchList[Index])\r
ArchList.sort()\r
SortedArch = ' '.join(ArchList)\r
- \r
KeyList = []\r
if not ModuleList or IsAllModuleList(ModuleList):\r
- KeyList = [SortedArch] \r
+ KeyList = [SortedArch]\r
else:\r
ModuleString = DT.TAB_VALUE_SPLIT.join(l for l in ModuleList)\r
if not ArchList:\r
KeyList = [SortedArch + '.' + ModuleString]\r
else:\r
KeyList = [Arch + '.' + ModuleString for Arch in ArchList]\r
- \r
for Key in KeyList:\r
if Key in NewSectionDict:\r
NewSectionDict[Key] = NewSectionDict[Key] + [Statement]\r
if not BinaryFile.AsBuiltList:\r
continue\r
for LibraryItem in BinaryFile.AsBuiltList[0].LibraryInstancesList:\r
- Statement = '# Guid: ' + LibraryItem.Guid + ' Version: ' + LibraryItem.Version\r
+ Statement = '# Guid: ' + LibraryItem.Guid + ' Version: ' + LibraryItem.Version\r
+\r
if len(BinaryFile.SupArchList) == 0:\r
- if LibraryClassDict.has_key('COMMON'):\r
+ if LibraryClassDict.has_key('COMMON') and Statement not in LibraryClassDict['COMMON']:\r
LibraryClassDict['COMMON'].append(Statement)\r
else:\r
LibraryClassDict['COMMON'] = ['## @LIB_INSTANCES']\r
else:\r
for Arch in BinaryFile.SupArchList:\r
if LibraryClassDict.has_key(Arch):\r
- LibraryClassDict[Arch].append(Statement)\r
+ if Statement not in LibraryClassDict[Arch]:\r
+ LibraryClassDict[Arch].append(Statement)\r
+ else:\r
+ continue\r
else:\r
LibraryClassDict[Arch] = ['## @LIB_INSTANCES']\r
LibraryClassDict[Arch].append(Statement)\r
- \r
Content += GenSection('LibraryClasses', LibraryClassDict)\r
- \r
+\r
return Content\r
\r
def GenPackages(ModuleObject):\r
# generate [Packages] section\r
#\r
NewSectionDict = Sdict()\r
- WorkspaceDir = getenv('WORKSPACE')\r
+ WorkspaceDir = GlobalData.gWORKSPACE\r
for PackageDependency in ModuleObject.GetPackageDependencyList():\r
#\r
# Generate generic comment\r
HelpText = PackageDependency.GetHelpText()\r
if HelpText:\r
HelpStr = HelpText.GetString()\r
- CommentStr = GenGenericCommentF(HelpStr) \r
+ CommentStr = GenGenericCommentF(HelpStr)\r
Statement = CommentStr\r
Guid = PackageDependency.GetGuid()\r
Version = PackageDependency.GetVersion()\r
FFE = PackageDependency.GetFeatureFlag()\r
+ Path = ''\r
#\r
# find package path/name\r
# \r
#\r
# get relative path\r
#\r
- RelaPath = Path[Path.upper().find(WorkspaceDir.upper()) + len(WorkspaceDir) + 1:]\r
+ RelaPath = GetRelativePath(Path, WorkspaceDir)\r
Statement += RelaPath.replace('\\', '/')\r
if FFE:\r
- Statement += '|' + FFE \r
+ Statement += '|' + FFE\r
ArchList = PackageDependency.GetSupArchList()\r
ArchList.sort()\r
SortedArch = ' '.join(ArchList)\r
if SortedArch in NewSectionDict:\r
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]\r
else:\r
- NewSectionDict[SortedArch] = [Statement] \r
-\r
+ NewSectionDict[SortedArch] = [Statement]\r
Content += GenSection('Packages', NewSectionDict)\r
- \r
return Content\r
\r
def GenSources(ModuleObject):\r
#\r
Content = ''\r
NewSectionDict = {}\r
- \r
- for Source in ModuleObject.GetSourceFileList(): \r
+ for Source in ModuleObject.GetSourceFileList():\r
SourceFile = Source.GetSourceFile()\r
Family = Source.GetFamily()\r
FeatureFlag = Source.GetFeatureFlag()\r
SupArchList = Source.GetSupArchList()\r
SupArchList.sort()\r
- SortedArch = ' '.join(SupArchList) \r
-\r
+ SortedArch = ' '.join(SupArchList)\r
Statement = GenSourceStatement(ConvertPath(SourceFile), Family, FeatureFlag)\r
if SortedArch in NewSectionDict:\r
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]\r
else:\r
NewSectionDict[SortedArch] = [Statement]\r
-\r
Content += GenSection('Sources', NewSectionDict)\r
- \r
+\r
return Content\r
\r
def GenDepex(ModuleObject):\r
SupModList = Depex.GetModuleType()\r
Expression = Depex.GetDepex()\r
Statement = CommentStr + Expression\r
- \r
SupArchList.sort()\r
KeyList = []\r
if not SupArchList:\r
for ModuleType in SupModList:\r
for Arch in SupArchList:\r
KeyList.append(ConvertArchForInstall(Arch) + '.' + ModuleType)\r
- \r
for Key in KeyList:\r
if Key in NewSectionDict:\r
NewSectionDict[Key] = NewSectionDict[Key] + [Statement]\r
else:\r
NewSectionDict[Key] = [Statement]\r
- \r
Content += GenSection('Depex', NewSectionDict, False)\r
\r
return Content\r
-\r
## GenUserExtensions\r
#\r
# GenUserExtensions\r
def GenUserExtensions(ModuleObject):\r
NewSectionDict = {}\r
for UserExtension in ModuleObject.GetUserExtensionList():\r
+ if UserExtension.GetUserID() == DT.TAB_BINARY_HEADER_USERID and \\r
+ UserExtension.GetIdentifier() == DT.TAB_BINARY_HEADER_IDENTIFIER:\r
+ continue\r
if UserExtension.GetIdentifier() == 'Depex':\r
continue\r
Statement = UserExtension.GetStatement()\r
if not Statement:\r
continue\r
- \r
ArchList = UserExtension.GetSupArchList()\r
for Index in xrange(0, len(ArchList)):\r
ArchList[Index] = ConvertArchForInstall(ArchList[Index])\r
ArchList.sort()\r
- \r
KeyList = []\r
CommonPreFix = ''\r
if UserExtension.GetUserID():\r
if ArchList:\r
KeyList = [CommonPreFix + '.' + Arch for Arch in ArchList]\r
else:\r
- KeyList = [CommonPreFix] \r
- \r
+ KeyList = [CommonPreFix]\r
for Key in KeyList:\r
if Key in NewSectionDict:\r
NewSectionDict[Key] = NewSectionDict[Key] + [Statement]\r
else:\r
NewSectionDict[Key] = [Statement]\r
Content = GenSection('UserExtensions', NewSectionDict, False)\r
- \r
+\r
return Content\r
- \r
+\r
# GenSourceStatement\r
#\r
# @param SourceFile: string of source file path/name\r
#\r
# @retval Statement: The generated statement for source\r
#\r
-def GenSourceStatement(SourceFile, Family, FeatureFlag, TagName=None, \r
+def GenSourceStatement(SourceFile, Family, FeatureFlag, TagName=None,\r
ToolCode=None, HelpStr=None):\r
Statement = ''\r
if HelpStr:\r
- Statement += GenGenericCommentF(HelpStr) \r
+ Statement += GenGenericCommentF(HelpStr)\r
#\r
# format of SourceFile|Family|TagName|ToolCode|FeatureFlag\r
#\r
Statement += SourceFile\r
- \r
if TagName == None:\r
TagName = ''\r
if ToolCode == None:\r
ToolCode = ''\r
if HelpStr == None:\r
HelpStr = ''\r
- \r
if FeatureFlag:\r
Statement += '|' + Family + '|' + TagName + '|' + ToolCode + '|' + FeatureFlag\r
elif ToolCode:\r
Statement += '|' + Family + '|' + TagName\r
elif Family:\r
Statement += '|' + Family\r
- \r
return Statement\r
\r
# GenBinaryStatement\r
# @param Value: (Target, Family, TagName, Comment)\r
#\r
#\r
-def GenBinaryStatement(Key, Value):\r
+def GenBinaryStatement(Key, Value, SubTypeGuidValue=None):\r
(FileName, FileType, FFE, SortedArch) = Key\r
if SortedArch:\r
pass\r
Family = ''\r
TagName = ''\r
Comment = ''\r
- \r
if Comment:\r
Statement = GenGenericCommentF(Comment)\r
else:\r
Statement = ''\r
- \r
- Statement += FileType + '|' + FileName\r
-\r
+ if FileType == 'SUBTYPE_GUID' and SubTypeGuidValue:\r
+ Statement += FileType + '|' + SubTypeGuidValue + '|' + FileName\r
+ else:\r
+ Statement += FileType + '|' + FileName\r
if FileType in DT.BINARY_FILE_TYPE_UI_LIST + DT.BINARY_FILE_TYPE_VER_LIST:\r
if FFE:\r
Statement += '|' + Target + '|' + FFE\r
Statement += '|' + Target + '|' + Family\r
elif Target:\r
Statement += '|' + Target\r
-\r
return Statement\r
-\r
## GenGuidSections\r
# \r
# @param GuidObjList: List of GuidObject\r
#\r
# generate [Guids] section\r
#\r
- Content = '' \r
+ Content = ''\r
GuidDict = Sdict()\r
-\r
for Guid in GuidObjList:\r
HelpTextList = Guid.GetHelpTextList()\r
HelpStr = _GetHelpStr(HelpTextList)\r
-\r
CName = Guid.GetCName()\r
FFE = Guid.GetFeatureFlag()\r
Statement = CName\r
if FFE:\r
Statement += '|' + FFE\r
- \r
Usage = Guid.GetUsage()\r
GuidType = Guid.GetGuidTypeList()[0]\r
VariableName = Guid.GetVariableName()\r
- \r
#\r
- # we need to differentiate the generic comment and usage comment\r
- # as multiple generic comment need to be put at first\r
+ # Differentiate the generic comment and usage comment as multiple generic comment need to be put at first\r
#\r
if Usage == DT.ITEM_UNDEFINED and GuidType == DT.ITEM_UNDEFINED:\r
# generate list of generic comment\r
Comment = ' # ' + Comment\r
else:\r
Comment = ''\r
- \r
if Usage != DT.ITEM_UNDEFINED and GuidType == DT.ITEM_UNDEFINED:\r
- Comment = '## ' + Usage + Comment\r
+ Comment = '## ' + Usage + ' ## GUID ' + Comment\r
elif GuidType == 'Variable':\r
Comment = '## ' + Usage + ' ## ' + GuidType + ':' + VariableName + Comment\r
else:\r
Comment = '## ' + Usage + ' ## ' + GuidType + Comment\r
- \r
+\r
if Comment:\r
Comment += '\n'\r
- \r
#\r
# merge duplicate items\r
#\r
SortedArch = ' '.join(ArchList)\r
if (Statement, SortedArch) in GuidDict:\r
PreviousComment = GuidDict[Statement, SortedArch]\r
- Comment = PreviousComment + Comment \r
+ Comment = PreviousComment + Comment\r
GuidDict[Statement, SortedArch] = Comment\r
-\r
- \r
- NewSectionDict = GenMetaFileMisc.TransferDict(GuidDict) \r
-\r
+ NewSectionDict = GenMetaFileMisc.TransferDict(GuidDict, 'INF_GUID')\r
#\r
# generate the section contents\r
#\r
if NewSectionDict:\r
Content = GenSection('Guids', NewSectionDict)\r
- \r
+\r
return Content\r
\r
## GenProtocolPPiSections\r
for Object in ObjList:\r
HelpTextList = Object.GetHelpTextList()\r
HelpStr = _GetHelpStr(HelpTextList)\r
-\r
CName = Object.GetCName()\r
FFE = Object.GetFeatureFlag()\r
Statement = CName\r
if FFE:\r
Statement += '|' + FFE\r
- \r
Usage = Object.GetUsage()\r
Notify = Object.GetNotify()\r
- \r
#\r
- # we need to differentiate the generic comment and usage comment\r
- # as consecutive generic comment need to be put together\r
+ # Differentiate the generic comment and usage comment as consecutive generic comment need to be put together\r
#\r
if Usage == DT.ITEM_UNDEFINED and Notify == '':\r
# generate list of generic comment\r
Comment = ' # ' + Comment\r
else:\r
Comment = ''\r
- \r
if Usage == DT.ITEM_UNDEFINED and not Comment and Notify == '':\r
Comment = ''\r
else:\r
Comment = '## ' + Usage + ' ## ' + 'NOTIFY' + Comment\r
else:\r
Comment = '## ' + Usage + Comment\r
- \r
if Comment:\r
Comment += '\n'\r
- \r
#\r
# merge duplicate items\r
#\r
PreviousComment = Dict[Statement, SortedArch]\r
Comment = PreviousComment + Comment\r
Dict[Statement, SortedArch] = Comment\r
- \r
- NewSectionDict = GenMetaFileMisc.TransferDict(Dict) \r
-\r
+ NewSectionDict = GenMetaFileMisc.TransferDict(Dict, 'INF_PPI_PROTOCOL')\r
#\r
# generate the section contents\r
#\r
Content = GenSection('Protocols', NewSectionDict)\r
else:\r
Content = GenSection('Ppis', NewSectionDict)\r
- \r
+\r
return Content\r
\r
## GenPcdSections\r
for Pcd in ModuleObject.GetPcdList():\r
HelpTextList = Pcd.GetHelpTextList()\r
HelpStr = _GetHelpStr(HelpTextList)\r
- \r
Statement = ''\r
CName = Pcd.GetCName()\r
TokenSpaceGuidCName = Pcd.GetTokenSpaceGuidCName()\r
else:\r
Dict = Sdict()\r
ItemTypeDict[ItemType] = Dict\r
- \r
FFE = Pcd.GetFeatureFlag()\r
Statement += TokenSpaceGuidCName + '.' + CName\r
if DefaultValue:\r
Statement += '|' + FFE\r
elif FFE:\r
Statement += '||' + FFE\r
- \r
#\r
# Generate comment\r
#\r
Usage = Pcd.GetValidUsage()\r
- \r
- #\r
# if FeatureFlag Pcd, then assume all Usage is CONSUMES\r
- #\r
if ItemType == DT.TAB_INF_FEATURE_PCD:\r
Usage = DT.USAGE_ITEM_CONSUMES\r
- if Usage == DT.ITEM_UNDEFINED or (ItemType == DT.TAB_INF_FEATURE_PCD):\r
+ if Usage == DT.ITEM_UNDEFINED:\r
# generate list of generic comment\r
Comment = GenGenericCommentF(HelpStr)\r
else:\r
Comment = ' # ' + Comment\r
else:\r
Comment = ''\r
- \r
Comment = '## ' + Usage + Comment\r
- \r
if Comment:\r
Comment += '\n'\r
- \r
#\r
# Merge duplicate entries\r
#\r
if (Statement, SortedArch) in Dict:\r
PreviousComment = Dict[Statement, SortedArch]\r
Comment = PreviousComment + Comment\r
- Dict[Statement, SortedArch] = Comment \r
- \r
+ Dict[Statement, SortedArch] = Comment\r
for ItemType in ItemTypeDict:\r
- #\r
# First we need to transfer the Dict to use SortedArch as key\r
- #\r
Dict = ItemTypeDict[ItemType]\r
- NewSectionDict = GenMetaFileMisc.TransferDict(Dict) \r
- \r
+ NewSectionDict = GenMetaFileMisc.TransferDict(Dict, 'INF_PCD')\r
if NewSectionDict:\r
Content += GenSection(ItemType, NewSectionDict)\r
#\r
else:\r
Content += GenAsBuiltPacthPcdSections(ModuleObject)\r
Content += GenAsBuiltPcdExSections(ModuleObject)\r
- \r
+\r
return Content\r
\r
## GenPcdSections\r
PatchPcdDict = {}\r
for BinaryFile in ModuleObject.GetBinaryFileList():\r
if not BinaryFile.AsBuiltList:\r
- continue \r
- for PatchPcd in BinaryFile.AsBuiltList[0].PatchPcdList: \r
+ continue\r
+ for PatchPcd in BinaryFile.AsBuiltList[0].PatchPcdList:\r
TokenSpaceName = ''\r
PcdCName = PatchPcd.CName\r
PcdValue = PatchPcd.DefaultValue\r
HelpString = ''\r
for HelpStringItem in HelpTextList:\r
for HelpLine in GetSplitValueList(HelpStringItem.String, '\n'):\r
- HelpString += '# ' + HelpLine + '\n'\r
- \r
- TokenSpaceName, PcdCName = GenMetaFileMisc.ObtainPcdName(ModuleObject.PackageDependencyList, \r
- TokenSpaceGuidValue, \r
+ HelpString += '## ' + HelpLine + '\n'\r
+ TokenSpaceName, PcdCName = GenMetaFileMisc.ObtainPcdName(ModuleObject.PackageDependencyList,\r
+ TokenSpaceGuidValue,\r
Token)\r
- if TokenSpaceName == '' or PcdCName == '': \r
- Logger.Error("Upt", \r
+ if TokenSpaceName == '' or PcdCName == '':\r
+ Logger.Error("Upt",\r
ToolError.RESOURCE_NOT_AVAILABLE,\r
- ST.ERR_INSTALL_FILE_DEC_FILE_ERROR%(TokenSpaceGuidValue, Token), \r
- File=ModuleObject.GetFullPath()) \r
- Statement = HelpString[:-3] + TokenSpaceName + '.' + PcdCName + ' | ' + PcdValue + ' | ' + PcdOffset\r
- \r
- if len(BinaryFile.SupArchList) == 0:\r
- if PatchPcdDict.has_key('COMMON'):\r
- PatchPcdDict['COMMON'].append(Statement)\r
+ ST.ERR_INSTALL_FILE_DEC_FILE_ERROR % (TokenSpaceGuidValue, Token),\r
+ File=ModuleObject.GetFullPath())\r
+ Statement = HelpString + TokenSpaceName + '.' + PcdCName + ' | ' + PcdValue + ' | ' + \\r
+ PcdOffset + DT.TAB_SPACE_SPLIT\r
+ #\r
+ # Use binary file's Arch to be Pcd's Arch \r
+ #\r
+ ArchList = []\r
+ FileNameObjList = BinaryFile.GetFileNameList()\r
+ if FileNameObjList:\r
+ ArchList = FileNameObjList[0].GetSupArchList()\r
+ if len(ArchList) == 0:\r
+ if PatchPcdDict.has_key(DT.TAB_ARCH_COMMON):\r
+ if Statement not in PatchPcdDict[DT.TAB_ARCH_COMMON]:\r
+ PatchPcdDict[DT.TAB_ARCH_COMMON].append(Statement)\r
else:\r
- PatchPcdDict['COMMON'] = [Statement]\r
+ PatchPcdDict[DT.TAB_ARCH_COMMON] = [Statement]\r
else:\r
- for Arch in BinaryFile.SupArchList:\r
+ for Arch in ArchList:\r
if PatchPcdDict.has_key(Arch):\r
- PatchPcdDict[Arch].append(Statement)\r
+ if Statement not in PatchPcdDict[Arch]:\r
+ PatchPcdDict[Arch].append(Statement)\r
else:\r
PatchPcdDict[Arch] = [Statement]\r
- return GenSection('PatchPcd', PatchPcdDict)\r
-\r
+ return GenSection(DT.TAB_INF_PATCH_PCD, PatchPcdDict)\r
## GenPcdSections\r
#\r
#\r
PcdExDict = {}\r
for BinaryFile in ModuleObject.GetBinaryFileList():\r
if not BinaryFile.AsBuiltList:\r
- continue \r
+ continue\r
for PcdExItem in BinaryFile.AsBuiltList[0].PcdExValueList:\r
TokenSpaceName = ''\r
PcdCName = PcdExItem.CName\r
- PcdValue = PcdExItem.DefaultValue\r
TokenSpaceGuidValue = PcdExItem.TokenSpaceGuidValue\r
Token = PcdExItem.Token\r
HelpTextList = PcdExItem.HelpTextList\r
HelpString = ''\r
for HelpStringItem in HelpTextList:\r
for HelpLine in GetSplitValueList(HelpStringItem.String, '\n'):\r
- HelpString += '# ' + HelpLine + '\n' \r
- TokenSpaceName, PcdCName = GenMetaFileMisc.ObtainPcdName(ModuleObject.PackageDependencyList, \r
+ HelpString += '## ' + HelpLine + '\n'\r
+ TokenSpaceName, PcdCName = GenMetaFileMisc.ObtainPcdName(ModuleObject.PackageDependencyList,\r
TokenSpaceGuidValue, Token)\r
- \r
- if TokenSpaceName == '' or PcdCName == '': \r
+ if TokenSpaceName == '' or PcdCName == '':\r
Logger.Error("Upt",\r
ToolError.RESOURCE_NOT_AVAILABLE,\r
- ST.ERR_INSTALL_FILE_DEC_FILE_ERROR%(TokenSpaceGuidValue, Token), \r
- File=ModuleObject.GetFullPath()) \r
- \r
- Statement = HelpString[:-3] + TokenSpaceName + '.' + PcdCName + ' | ' + PcdValue\r
- \r
- if len(BinaryFile.SupArchList) == 0:\r
+ ST.ERR_INSTALL_FILE_DEC_FILE_ERROR % (TokenSpaceGuidValue, Token),\r
+ File=ModuleObject.GetFullPath())\r
+\r
+ Statement = HelpString + TokenSpaceName + DT.TAB_SPLIT + PcdCName + DT.TAB_SPACE_SPLIT\r
+\r
+ #\r
+ # Use binary file's Arch to be Pcd's Arch \r
+ #\r
+ ArchList = []\r
+ FileNameObjList = BinaryFile.GetFileNameList()\r
+ if FileNameObjList:\r
+ ArchList = FileNameObjList[0].GetSupArchList()\r
+\r
+ if len(ArchList) == 0:\r
if PcdExDict.has_key('COMMON'):\r
PcdExDict['COMMON'].append(Statement)\r
else:\r
PcdExDict['COMMON'] = [Statement]\r
else:\r
- for Arch in BinaryFile.SupArchList:\r
+ for Arch in ArchList:\r
if PcdExDict.has_key(Arch):\r
- PcdExDict[Arch].append(Statement)\r
+ if Statement not in PcdExDict[Arch]:\r
+ PcdExDict[Arch].append(Statement)\r
else:\r
PcdExDict[Arch] = [Statement]\r
return GenSection('PcdEx', PcdExDict)\r
- \r
+\r
## GenSpecialSections\r
# generate special sections for Event/BootMode/Hob\r
#\r
HelpTextList = Obj.GetHelpTextList()\r
HelpStr = _GetHelpStr(HelpTextList)\r
CommentStr = GenGenericCommentF(HelpStr)\r
- \r
if SectionName == 'Hob':\r
Type = Obj.GetHobType()\r
elif SectionName == 'Event':\r
Type = Obj.GetSupportedBootModes()\r
else:\r
assert(SectionName)\r
- \r
Usage = Obj.GetUsage()\r
Statement = ' ' + Type + ' ## ' + Usage\r
- \r
if CommentStr in ['#\n', '#\n#\n']:\r
CommentStr = '#\n#\n#\n'\r
#\r
- # the first head comment line should start with '##\n', \r
- # if it starts with '#\n', then add one '#'\r
+ # the first head comment line should start with '##\n', if it starts with '#\n', then add one '#'\r
# else add '##\n' to meet the format defined in INF spec\r
#\r
if CommentStr.startswith('#\n'):\r
CommentStr = '#' + CommentStr\r
elif CommentStr:\r
CommentStr = '##\n' + CommentStr\r
-\r
if CommentStr and not CommentStr.endswith('\n#\n'):\r
- CommentStr = CommentStr + '#\n' \r
- \r
+ CommentStr = CommentStr + '#\n'\r
NewStateMent = CommentStr + Statement\r
SupArch = Obj.GetSupArchList()\r
SupArch.sort()\r
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [NewStateMent]\r
else:\r
NewSectionDict[SortedArch] = [NewStateMent]\r
- \r
SectionContent = GenSection(SectionName, NewSectionDict)\r
SectionContent = SectionContent.strip()\r
if SectionContent:\r
Content = '# ' + ('\n' + '# ').join(GetSplitValueList(SectionContent, '\n'))\r
Content = Content.lstrip()\r
#\r
- # add two empty line after the generated section content to differentiate \r
- # it between other possible sections\r
- #\r
- if Content: \r
+ # add two empty line after the generated section content to differentiate it between other possible sections\r
+ # \r
+ if Content:\r
Content += '\n#\n#\n'\r
return Content\r
-\r
## GenBuildOptions\r
#\r
#\r
NewSectionDict[Arch] = NewSectionDict[Arch] + [BuildOptionDict[Arch]]\r
else:\r
NewSectionDict[Arch] = [BuildOptionDict[Arch]]\r
- \r
Content = GenSection('BuildOptions', NewSectionDict)\r
else:\r
BuildOptionDict = {}\r
if not BinaryFile.AsBuiltList:\r
continue\r
for BuilOptionItem in BinaryFile.AsBuiltList[0].BinaryBuildFlagList:\r
- Statement = '#' + BuilOptionItem.AsBuiltOptionFlags\r
+ Statement = '#' + BuilOptionItem.AsBuiltOptionFlags\r
if len(BinaryFile.SupArchList) == 0:\r
if BuildOptionDict.has_key('COMMON'):\r
if Statement not in BuildOptionDict['COMMON']:\r
else:\r
BuildOptionDict[Arch] = ['## @AsBuilt']\r
BuildOptionDict[Arch].append(Statement)\r
- \r
Content = GenSection('BuildOptions', BuildOptionDict)\r
- \r
- return Content\r
\r
+ return Content\r
## GenBinaries\r
#\r
#\r
BinariesDict = UserExtension.GetBinariesDict()\r
if BinariesDict:\r
break\r
- \r
for BinaryFile in ModuleObject.GetBinaryFileList():\r
FileNameObjList = BinaryFile.GetFileNameList()\r
for FileNameObj in FileNameObjList:\r
FFE = FileNameObj.GetFeatureFlag()\r
ArchList = FileNameObj.GetSupArchList()\r
ArchList.sort()\r
- SortedArch = ' '.join(ArchList) \r
- \r
+ SortedArch = ' '.join(ArchList)\r
Key = (FileName, FileType, FFE, SortedArch)\r
-\r
if Key in BinariesDict:\r
ValueList = BinariesDict[Key]\r
for ValueItem in ValueList:\r
else:\r
NewSectionDict[SortedArch] = [Statement]\r
#\r
- # as we already generated statement for this DictKey\r
- # here set the Valuelist to be empty to avoid generate duplicate entries \r
- # as the DictKey may have multiple entries\r
+ # as we already generated statement for this DictKey here set the Valuelist to be empty \r
+ # to avoid generate duplicate entries as the DictKey may have multiple entries\r
#\r
BinariesDict[Key] = []\r
else:\r
- Statement = GenBinaryStatement(Key, None)\r
+ if FileType == 'SUBTYPE_GUID' and FileNameObj.GetGuidValue():\r
+ Statement = GenBinaryStatement(Key, None, FileNameObj.GetGuidValue())\r
+ else:\r
+ Statement = GenBinaryStatement(Key, None)\r
if SortedArch in NewSectionDict:\r
NewSectionDict[SortedArch] = NewSectionDict[SortedArch] + [Statement]\r
else:\r
- NewSectionDict[SortedArch] = [Statement] \r
- \r
- return GenSection('Binaries', NewSectionDict)
\ No newline at end of file
+ NewSectionDict[SortedArch] = [Statement]\r
+ Content = GenSection('Binaries', NewSectionDict)\r
+\r
+ return Content\r
#\r
# This file contained the miscellaneous routines for GenMetaFile usage.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
# @param ExternList: string of source file FeatureFlag field\r
# \r
def AddExternToDefineSec(SectionDict, Arch, ExternList):\r
+ LeftOffset = 31\r
for ArchList, EntryPoint, UnloadImage, Constructor, Destructor, FFE, HelpStringList in ExternList:\r
if Arch or ArchList:\r
if EntryPoint:\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_ENTRY_POINT, EntryPoint)\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_ENTRY_POINT).ljust(LeftOffset) + u'= %s' % EntryPoint\r
if FFE:\r
Statement += ' | %s' % FFE\r
if len(HelpStringList) > 0:\r
if len(HelpStringList) > 1:\r
Statement = Statement + HelpStringList[1].GetString()\r
SectionDict[Arch] = SectionDict[Arch] + [Statement]\r
+\r
if UnloadImage:\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_UNLOAD_IMAGE, UnloadImage)\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_UNLOAD_IMAGE).ljust(LeftOffset) + u'= %s' % UnloadImage\r
if FFE:\r
Statement += ' | %s' % FFE\r
- \r
+\r
if len(HelpStringList) > 0:\r
Statement = HelpStringList[0].GetString() + '\n' + Statement\r
if len(HelpStringList) > 1:\r
Statement = Statement + HelpStringList[1].GetString()\r
SectionDict[Arch] = SectionDict[Arch] + [Statement]\r
+\r
if Constructor:\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_CONSTRUCTOR, Constructor)\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_CONSTRUCTOR).ljust(LeftOffset) + u'= %s' % Constructor\r
if FFE:\r
Statement += ' | %s' % FFE\r
- \r
+\r
if len(HelpStringList) > 0:\r
Statement = HelpStringList[0].GetString() + '\n' + Statement\r
if len(HelpStringList) > 1:\r
- Statement = Statement + HelpStringList[1].GetString() \r
- SectionDict[Arch] = SectionDict[Arch] + [Statement] \r
+ Statement = Statement + HelpStringList[1].GetString()\r
+ SectionDict[Arch] = SectionDict[Arch] + [Statement]\r
+\r
if Destructor:\r
- Statement = '%s = %s' % (DT.TAB_INF_DEFINES_DESTRUCTOR, Destructor)\r
+ Statement = (u'%s ' % DT.TAB_INF_DEFINES_DESTRUCTOR).ljust(LeftOffset) + u'= %s' % Destructor\r
if FFE:\r
Statement += ' | %s' % FFE\r
- \r
+\r
if len(HelpStringList) > 0:\r
Statement = HelpStringList[0].GetString() + '\n' + Statement\r
if len(HelpStringList) > 1:\r
Statement = Statement + HelpStringList[1].GetString()\r
SectionDict[Arch] = SectionDict[Arch] + [Statement]\r
- \r
+\r
## ObtainPcdName\r
#\r
# Using TokenSpaceGuidValue and Token to obtain PcdName from DEC file\r
#\r
Guid = PackageDependency.GetGuid()\r
Version = PackageDependency.GetVersion()\r
- \r
+\r
#\r
# find package path/name\r
# \r
if (not Version) or (Version == PkgInfo[2]):\r
Path = PkgInfo[3]\r
break\r
- \r
- DecFile = Dec(Path)\r
+\r
+ DecFile = None\r
+ if Path not in GlobalData.gPackageDict:\r
+ DecFile = Dec(Path)\r
+ GlobalData.gPackageDict[Path] = DecFile\r
+ else:\r
+ DecFile = GlobalData.gPackageDict[Path]\r
+\r
DecGuidsDict = DecFile.GetGuidSectionObject().ValueDict\r
DecPcdsDict = DecFile.GetPcdSectionObject().ValueDict\r
- \r
+\r
TokenSpaceGuidName = ''\r
PcdCName = ''\r
TokenSpaceGuidNameFound = False\r
PcdCNameFound = False\r
- \r
+\r
#\r
# Get TokenSpaceGuidCName from Guids section \r
#\r
if TokenSpaceGuidNameFound:\r
break\r
for GuidItem in GuidList:\r
- if TokenSpaceGuidValue == GuidItem.GuidString:\r
+ if TokenSpaceGuidValue.upper() == GuidItem.GuidString.upper():\r
TokenSpaceGuidName = GuidItem.GuidCName\r
TokenSpaceGuidNameFound = True\r
break\r
- \r
+\r
#\r
# Retrieve PcdCName from Pcds Section\r
#\r
for PcdKey in DecPcdsDict:\r
PcdList = DecPcdsDict[PcdKey]\r
if PcdCNameFound:\r
- break\r
+ return TokenSpaceGuidName, PcdCName\r
for PcdItem in PcdList:\r
if TokenSpaceGuidName == PcdItem.TokenSpaceGuidCName and Token == PcdItem.TokenValue:\r
PcdCName = PcdItem.TokenCName\r
PcdCNameFound = True\r
- break \r
- \r
+ break\r
+\r
return TokenSpaceGuidName, PcdCName\r
\r
## _TransferDict\r
# (GenericComment, UsageComment) as value into a dict that using SortedArch as\r
# key and NewStatement as value \r
#\r
-def TransferDict(OrigDict):\r
+def TransferDict(OrigDict, Type=None):\r
NewDict = {}\r
-\r
+ LeftOffset = 0\r
+ if Type in ['INF_GUID', 'INF_PPI_PROTOCOL']:\r
+ LeftOffset = 45\r
+ if Type in ['INF_PCD']:\r
+ LeftOffset = 75\r
+ if LeftOffset > 0:\r
+ for Statement, SortedArch in OrigDict:\r
+ if len(Statement) > LeftOffset:\r
+ LeftOffset = len(Statement)\r
+ \r
for Statement, SortedArch in OrigDict:\r
Comment = OrigDict[Statement, SortedArch]\r
#\r
# apply the NComment/1Comment rule\r
#\r
- if Comment.find('\n') != len(Comment) - 1: \r
+ if Comment.find('\n') != len(Comment) - 1:\r
NewStateMent = Comment + Statement\r
else:\r
- NewStateMent = Statement + ' ' + Comment.rstrip('\n')\r
+ if LeftOffset:\r
+ NewStateMent = Statement.ljust(LeftOffset) + ' ' + Comment.rstrip('\n')\r
+ else:\r
+ NewStateMent = Statement + ' ' + Comment.rstrip('\n')\r
\r
if SortedArch in NewDict:\r
NewDict[SortedArch] = NewDict[SortedArch] + [NewStateMent]\r
else:\r
NewDict[SortedArch] = [NewStateMent]\r
\r
- return NewDict \r
-
\ No newline at end of file
+ return NewDict\r
+\r
## @file\r
# Install distribution package.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
##\r
# Import Modules\r
#\r
+from Core.FileHook import __FileHookOpen__\r
import os.path\r
from os import chmod\r
from os import SEEK_SET\r
from os import SEEK_END\r
import stat\r
import md5\r
+import copy\r
from sys import stdin\r
from sys import platform\r
from shutil import rmtree\r
from Logger.ToolError import FILE_TYPE_MISMATCH\r
import Logger.Log as Logger\r
\r
-from Library.Misc import CheckEnvVariable\r
from Library.Misc import Sdict\r
from Library.Misc import ConvertPath\r
from Library.ParserValidate import IsValidInstallPath\r
Input = Input.replace('\r', '').replace('\n', '')\r
return InstallNewPackage(WorkspaceDir, Input, False)\r
\r
-\r
## InstallNewModule\r
#\r
# @param WorkspaceDir: Workspace Directory\r
#\r
# UnZipDp\r
#\r
-def UnZipDp(WorkspaceDir, Options, DataBase):\r
+def UnZipDp(WorkspaceDir, DpPkgFileName):\r
ContentZipFile = None\r
Logger.Quiet(ST.MSG_UZIP_PARSE_XML)\r
- DpPkgFileName = Options.PackageFile\r
DistFile = PackageFile(DpPkgFileName)\r
\r
DpDescFileName, ContentFileName = GetDPFile(DistFile.GetZipFile())\r
DistPkg.Header.RePackage = False\r
if DistPkg.Header.ReadOnly == '':\r
DistPkg.Header.ReadOnly = False\r
- \r
- #\r
- # prepare check dependency\r
- #\r
- Dep = DependencyRules(DataBase)\r
- #\r
- # Check distribution package installed or not\r
- #\r
- if Dep.CheckDpExists(DistPkg.Header.GetGuid(),\r
- DistPkg.Header.GetVersion()):\r
- Logger.Error("InstallPkg", UPT_ALREADY_INSTALLED_ERROR,\r
- ST.WRN_DIST_PKG_INSTALLED)\r
- #\r
- # Check distribution dependency (all module dependency should be\r
- # satisfied)\r
- #\r
- if not Dep.CheckDpDepexSatisfied(DistPkg):\r
- Logger.Error("InstallPkg", UNKNOWN_ERROR,\r
- ST.ERR_PACKAGE_NOT_MATCH_DEPENDENCY,\r
- ExtraData=DistPkg.Header.Name)\r
+\r
#\r
# unzip contents.zip file\r
#\r
Logger.Error("InstallPkg", FILE_NOT_FOUND,\r
ST.ERR_FILE_BROKEN % ContentFileName)\r
\r
- FilePointer = open(ContentFile, "rb")\r
+ FilePointer = __FileHookOpen__(ContentFile, "rb")\r
#\r
# Assume no archive comment.\r
#\r
# verify MD5 signature when existed\r
#\r
if DistPkg.Header.Signature != '':\r
- Md5Sigature = md5.new(open(ContentFile, 'rb').read())\r
+ Md5Sigature = md5.new(__FileHookOpen__(ContentFile, 'rb').read())\r
if DistPkg.Header.Signature != Md5Sigature.hexdigest():\r
ContentZipFile.Close()\r
Logger.Error("InstallPkg", FILE_CHECKSUM_FAILURE,\r
ExtraData=ContentFile)\r
\r
- return DistPkg, Dep, ContentZipFile, DpPkgFileName\r
+ return DistPkg, ContentZipFile, DpPkgFileName, DistFile\r
\r
## GetPackageList\r
#\r
Logger.Info(ST.MSG_INSTALL_PACKAGE % Package.GetName())\r
if Dep.CheckPackageExists(Guid, Version):\r
Logger.Info(ST.WRN_PACKAGE_EXISTED %(Guid, Version))\r
- NewPackagePath = InstallNewPackage(WorkspaceDir, PackagePath, Options.CustomPath)\r
+ if Options.UseGuidedPkgPath:\r
+ GuidedPkgPath = "%s_%s_%s" % (Package.GetName(), Guid, Version)\r
+ NewPackagePath = InstallNewPackage(WorkspaceDir, GuidedPkgPath, Options.CustomPath)\r
+ else:\r
+ NewPackagePath = InstallNewPackage(WorkspaceDir, PackagePath, Options.CustomPath)\r
InstallPackageContent(PackagePath, NewPackagePath, Package, ContentZipFile, Dep, WorkspaceDir, ModuleList, \r
DistPkg.Header.ReadOnly)\r
PackageList.append(Package)\r
# dependency (Hard to get the location of the newly installed package)\r
#\r
for Package in PackageList:\r
- FilePath = PackageToDec(Package)\r
- Md5Sigature = md5.new(open(str(FilePath), 'rb').read())\r
+ FilePath = PackageToDec(Package, DistPkg.Header)\r
+ Md5Sigature = md5.new(__FileHookOpen__(str(FilePath), 'rb').read())\r
Md5Sum = Md5Sigature.hexdigest()\r
if (FilePath, Md5Sum) not in Package.FileList:\r
Package.FileList.append((FilePath, Md5Sum))\r
# install them directly. If not, we will try to create a new directory \r
# for it.\r
#\r
- ModulePathList = [] \r
+ ModulePathList = []\r
\r
#\r
# Check module exist and install\r
# generate all inf for modules\r
#\r
for (Module, Package) in ModuleList:\r
- FilePath = ModuleToInf(Module)\r
- Md5Sigature = md5.new(open(str(FilePath), 'rb').read())\r
+ CheckCNameInModuleRedefined(Module, DistPkg)\r
+ FilePath = ModuleToInf(Module, Package, DistPkg.Header)\r
+ Md5Sigature = md5.new(__FileHookOpen__(str(FilePath), 'rb').read())\r
Md5Sum = Md5Sigature.hexdigest()\r
if Package:\r
if (FilePath, Md5Sum) not in Package.FileList:\r
else:\r
if (FilePath, Md5Sum) not in Module.FileList:\r
Module.FileList.append((FilePath, Md5Sum))\r
+ #\r
+ # append the module unicode files to Package FileList\r
+ #\r
+ for (FilePath, Md5Sum) in Module.FileList:\r
+ if str(FilePath).endswith('.uni') and Package and (FilePath, Md5Sum) not in Package.FileList:\r
+ Package.FileList.append((FilePath, Md5Sum))\r
\r
return NewDict\r
\r
+##\r
+# Get all protocol/ppi/guid CNames and pcd name from all dependent DEC file\r
+#\r
+def GetDepProtocolPpiGuidPcdNames(DePackageObjList):\r
+ #\r
+ # [[Dec1Protocol1, Dec1Protocol2...], [Dec2Protocols...],...]\r
+ #\r
+ DependentProtocolCNames = []\r
+ DependentPpiCNames = []\r
+ DependentGuidCNames = []\r
+ DependentPcdNames = []\r
+ \r
+ for PackageObj in DePackageObjList:\r
+ #\r
+ # Get protocol CName list from all dependent DEC file\r
+ #\r
+ ProtocolCNames = []\r
+ for Protocol in PackageObj.GetProtocolList():\r
+ if Protocol.GetCName() not in ProtocolCNames:\r
+ ProtocolCNames.append(Protocol.GetCName())\r
+ \r
+ DependentProtocolCNames.append(ProtocolCNames)\r
+ \r
+ #\r
+ # Get Ppi CName list from all dependent DEC file\r
+ # \r
+ PpiCNames = []\r
+ for Ppi in PackageObj.GetPpiList():\r
+ if Ppi.GetCName() not in PpiCNames:\r
+ PpiCNames.append(Ppi.GetCName())\r
+\r
+ DependentPpiCNames.append(PpiCNames)\r
+ \r
+ #\r
+ # Get Guid CName list from all dependent DEC file\r
+ # \r
+ GuidCNames = []\r
+ for Guid in PackageObj.GetGuidList():\r
+ if Guid.GetCName() not in GuidCNames:\r
+ GuidCNames.append(Guid.GetCName())\r
+ \r
+ DependentGuidCNames.append(GuidCNames)\r
+ \r
+ #\r
+ # Get PcdName list from all dependent DEC file\r
+ #\r
+ PcdNames = []\r
+ for Pcd in PackageObj.GetPcdList():\r
+ PcdName = '.'.join([Pcd.GetTokenSpaceGuidCName(), Pcd.GetCName()])\r
+ if PcdName not in PcdNames:\r
+ PcdNames.append(PcdName)\r
+ \r
+ DependentPcdNames.append(PcdNames)\r
+ \r
+ \r
+ return DependentProtocolCNames, DependentPpiCNames, DependentGuidCNames, DependentPcdNames\r
+\r
+##\r
+# Check if protocol CName is redefined\r
+#\r
+def CheckProtoclCNameRedefined(Module, DependentProtocolCNames):\r
+ for ProtocolInModule in Module.GetProtocolList():\r
+ IsCNameDefined = False\r
+ for PackageProtocolCNames in DependentProtocolCNames:\r
+ if ProtocolInModule.GetCName() in PackageProtocolCNames:\r
+ if IsCNameDefined:\r
+ Logger.Error("\nUPT", FORMAT_INVALID, \r
+ File = Module.GetFullPath(), \r
+ ExtraData = \\r
+ ST.ERR_INF_PARSER_ITEM_DUPLICATE_IN_DEC % ProtocolInModule.GetCName())\r
+ else:\r
+ IsCNameDefined = True\r
+\r
+##\r
+# Check if Ppi CName is redefined\r
+#\r
+def CheckPpiCNameRedefined(Module, DependentPpiCNames):\r
+ for PpiInModule in Module.GetPpiList():\r
+ IsCNameDefined = False\r
+ for PackagePpiCNames in DependentPpiCNames:\r
+ if PpiInModule.GetCName() in PackagePpiCNames:\r
+ if IsCNameDefined:\r
+ Logger.Error("\nUPT", FORMAT_INVALID, \r
+ File = Module.GetFullPath(), \r
+ ExtraData = ST.ERR_INF_PARSER_ITEM_DUPLICATE_IN_DEC % PpiInModule.GetCName())\r
+ else:\r
+ IsCNameDefined = True \r
+\r
+##\r
+# Check if Guid CName is redefined\r
+#\r
+def CheckGuidCNameRedefined(Module, DependentGuidCNames):\r
+ for GuidInModule in Module.GetGuidList():\r
+ IsCNameDefined = False\r
+ for PackageGuidCNames in DependentGuidCNames:\r
+ if GuidInModule.GetCName() in PackageGuidCNames:\r
+ if IsCNameDefined:\r
+ Logger.Error("\nUPT", FORMAT_INVALID, \r
+ File = Module.GetFullPath(), \r
+ ExtraData = \\r
+ ST.ERR_INF_PARSER_ITEM_DUPLICATE_IN_DEC % GuidInModule.GetCName())\r
+ else:\r
+ IsCNameDefined = True\r
+\r
+##\r
+# Check if PcdName is redefined\r
+#\r
+def CheckPcdNameRedefined(Module, DependentPcdNames):\r
+ PcdObjs = []\r
+ if not Module.GetBinaryFileList():\r
+ PcdObjs += Module.GetPcdList()\r
+ else:\r
+ Binary = Module.GetBinaryFileList()[0]\r
+ for AsBuild in Binary.GetAsBuiltList():\r
+ PcdObjs += AsBuild.GetPatchPcdList() + AsBuild.GetPcdExList()\r
+\r
+ for PcdObj in PcdObjs:\r
+ PcdName = '.'.join([PcdObj.GetTokenSpaceGuidCName(), PcdObj.GetCName()])\r
+ IsPcdNameDefined = False\r
+ for PcdNames in DependentPcdNames:\r
+ if PcdName in PcdNames:\r
+ if IsPcdNameDefined:\r
+ Logger.Error("\nUPT", FORMAT_INVALID, \r
+ File = Module.GetFullPath(), \r
+ ExtraData = ST.ERR_INF_PARSER_ITEM_DUPLICATE_IN_DEC % PcdName)\r
+ else:\r
+ IsPcdNameDefined = True\r
+\r
+##\r
+# Check if any Protocol/Ppi/Guid and Pcd name is redefined in its dependent DEC files\r
+#\r
+def CheckCNameInModuleRedefined(Module, DistPkg):\r
+ DePackageObjList = []\r
+ #\r
+ # Get all dependent package objects\r
+ # \r
+ for Obj in Module.GetPackageDependencyList():\r
+ Guid = Obj.GetGuid()\r
+ Version = Obj.GetVersion()\r
+ for Key in DistPkg.PackageSurfaceArea:\r
+ if Key[0] == Guid and Key[1] == Version:\r
+ if DistPkg.PackageSurfaceArea[Key] not in DePackageObjList:\r
+ DePackageObjList.append(DistPkg.PackageSurfaceArea[Key])\r
+ \r
+ DependentProtocolCNames, DependentPpiCNames, DependentGuidCNames, DependentPcdNames = \\r
+ GetDepProtocolPpiGuidPcdNames(DePackageObjList)\r
+\r
+ CheckProtoclCNameRedefined(Module, DependentProtocolCNames)\r
+ CheckPpiCNameRedefined(Module, DependentPpiCNames)\r
+ CheckGuidCNameRedefined(Module, DependentGuidCNames)\r
+ CheckPcdNameRedefined(Module, DependentPcdNames)\r
+\r
## GenToolMisc\r
#\r
# GenToolMisc\r
ContentZipFile, DistFile = None, None\r
\r
try:\r
- DataBase = GlobalData.gDB \r
- CheckEnvVariable()\r
+ DataBase = GlobalData.gDB\r
WorkspaceDir = GlobalData.gWORKSPACE\r
if not Options.PackageFile:\r
Logger.Error("InstallPkg", OPTION_MISSING, ExtraData=ST.ERR_SPECIFY_PACKAGE)\r
#\r
# unzip dist.pkg file\r
#\r
- DistPkg, Dep, ContentZipFile, DpPkgFileName = UnZipDp(WorkspaceDir, Options, DataBase)\r
-\r
- #\r
- # PackageList, ModuleList record the information for the meta-data\r
- # files that need to be generated later\r
- #\r
- PackageList = []\r
- ModuleList = []\r
- DistPkg.PackageSurfaceArea = GetPackageList(DistPkg, Dep, WorkspaceDir, Options, \r
- ContentZipFile, ModuleList, PackageList)\r
+ DistPkg, ContentZipFile, DpPkgFileName, DistFile = UnZipDp(WorkspaceDir, Options.PackageFile)\r
\r
- DistPkg.ModuleSurfaceArea = GetModuleList(DistPkg, Dep, WorkspaceDir, ContentZipFile, ModuleList) \r
- \r
- \r
- GenToolMisc(DistPkg, WorkspaceDir, ContentZipFile)\r
- \r
#\r
- # copy "Distribution File" to directory $(WORKSPACE)/conf/upt\r
+ # check dependency\r
#\r
- DistFileName = os.path.split(DpPkgFileName)[1]\r
- DestDir = os.path.normpath(os.path.join(WorkspaceDir, GlobalData.gUPT_DIR))\r
- CreateDirectory(DestDir)\r
- DestFile = os.path.normpath(os.path.join(DestDir, DistFileName))\r
- if os.path.exists(DestFile):\r
- FileName, Ext = os.path.splitext(DistFileName)\r
- NewFileName = FileName + '_' + DistPkg.Header.GetGuid() + '_' + DistPkg.Header.GetVersion() + Ext\r
- DestFile = os.path.normpath(os.path.join(DestDir, NewFileName))\r
- if os.path.exists(DestFile):\r
- #\r
- # ask for user input the new file name\r
- #\r
- Logger.Info( ST.MSG_NEW_FILE_NAME_FOR_DIST)\r
- Input = stdin.readline()\r
- Input = Input.replace('\r', '').replace('\n', '')\r
- DestFile = os.path.normpath(os.path.join(DestDir, Input))\r
- copyfile(DpPkgFileName, DestFile)\r
- NewDpPkgFileName = DestFile[DestFile.find(DestDir) + len(DestDir) + 1:]\r
+ Dep = DependencyRules(DataBase)\r
+ CheckInstallDpx(Dep, DistPkg)\r
\r
#\r
- # update database\r
+ # Install distribution\r
#\r
- Logger.Quiet(ST.MSG_UPDATE_PACKAGE_DATABASE)\r
- DataBase.AddDPObject(DistPkg, NewDpPkgFileName, DistFileName, \r
- DistPkg.Header.RePackage)\r
- \r
+ InstallDp(DistPkg, DpPkgFileName, ContentZipFile, Options, Dep, WorkspaceDir, DataBase)\r
ReturnCode = 0\r
\r
except FatalError, XExcept:\r
ReturnCode = XExcept.args[0]\r
if Logger.GetLevel() <= Logger.DEBUG_9:\r
- Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
- platform) + format_exc())\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(), platform) + format_exc())\r
+ \r
except KeyboardInterrupt:\r
ReturnCode = ABORT_ERROR\r
if Logger.GetLevel() <= Logger.DEBUG_9:\r
- Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
- platform) + format_exc())\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(), platform) + format_exc())\r
+ \r
except:\r
ReturnCode = CODE_ERROR\r
Logger.Error(\r
)\r
Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
platform) + format_exc())\r
-\r
finally:\r
Logger.Quiet(ST.MSG_REMOVE_TEMP_FILE_STARTED)\r
if DistFile:\r
rmtree(GlobalData.gUNPACK_DIR)\r
GlobalData.gUNPACK_DIR = None\r
Logger.Quiet(ST.MSG_REMOVE_TEMP_FILE_DONE)\r
-\r
if ReturnCode == 0:\r
Logger.Quiet(ST.MSG_FINISH)\r
- \r
return ReturnCode\r
\r
+# BackupDist method\r
+# \r
+# This method will backup the Distribution file into the $(WORKSPACE)/conf/upt, and rename it \r
+# if there is already a same-named distribution existed.\r
+#\r
+# @param DpPkgFileName: The distribution path\r
+# @param Guid: The distribution Guid\r
+# @param Version: The distribution Version\r
+# @param WorkspaceDir: The workspace directory\r
+# @retval NewDpPkgFileName: The exact backup file name\r
+#\r
+def BackupDist(DpPkgFileName, Guid, Version, WorkspaceDir):\r
+ DistFileName = os.path.split(DpPkgFileName)[1]\r
+ DestDir = os.path.normpath(os.path.join(WorkspaceDir, GlobalData.gUPT_DIR))\r
+ CreateDirectory(DestDir)\r
+ DestFile = os.path.normpath(os.path.join(DestDir, DistFileName))\r
+ if os.path.exists(DestFile):\r
+ FileName, Ext = os.path.splitext(DistFileName)\r
+ NewFileName = FileName + '_' + Guid + '_' + Version + Ext\r
+ DestFile = os.path.normpath(os.path.join(DestDir, NewFileName))\r
+ if os.path.exists(DestFile):\r
+ #\r
+ # ask for user input the new file name\r
+ #\r
+ Logger.Info( ST.MSG_NEW_FILE_NAME_FOR_DIST)\r
+ Input = stdin.readline()\r
+ Input = Input.replace('\r', '').replace('\n', '')\r
+ DestFile = os.path.normpath(os.path.join(DestDir, Input))\r
+ copyfile(DpPkgFileName, DestFile)\r
+ NewDpPkgFileName = DestFile[DestFile.find(DestDir) + len(DestDir) + 1:]\r
+ return NewDpPkgFileName\r
+\r
+## CheckInstallDpx method\r
+#\r
+# check whether distribution could be installed\r
+#\r
+# @param Dep: the DependencyRules instance that used to check dependency\r
+# @param DistPkg: the distribution object\r
+#\r
+def CheckInstallDpx(Dep, DistPkg):\r
+ #\r
+ # Check distribution package installed or not\r
+ #\r
+ if Dep.CheckDpExists(DistPkg.Header.GetGuid(),\r
+ DistPkg.Header.GetVersion()):\r
+ Logger.Error("InstallPkg", UPT_ALREADY_INSTALLED_ERROR,\r
+ ST.WRN_DIST_PKG_INSTALLED)\r
+ #\r
+ # Check distribution dependency (all module dependency should be\r
+ # satisfied)\r
+ #\r
+ if not Dep.CheckInstallDpDepexSatisfied(DistPkg):\r
+ Logger.Error("InstallPkg", UNKNOWN_ERROR,\r
+ ST.ERR_PACKAGE_NOT_MATCH_DEPENDENCY,\r
+ ExtraData=DistPkg.Header.Name)\r
+\r
## InstallModuleContent method\r
#\r
# If this is standalone module, then Package should be none,\r
\r
if not IsValidInstallPath(File):\r
Logger.Error("UPT", FORMAT_INVALID, ST.ERR_FILE_NAME_INVALIDE%File)\r
- \r
+\r
FromFile = os.path.join(FromPath, ModulePath, File)\r
Executable = Item.GetExecutable() \r
ToFile = os.path.normpath(os.path.join(NewModuleFullPath, ConvertPath(File)))\r
FromFile = FileName\r
ToFile = os.path.normpath(os.path.join(WorkspaceDir, \r
ConvertPath(FileName.replace(FromPath, NewPath, 1))))\r
- CheckList = Module.FileList\r
+ CheckList = copy.copy(Module.FileList)\r
if Package:\r
CheckList += Package.FileList\r
for Item in CheckList:\r
# @return: True or False \r
#\r
def InstallFile(ContentZipFile, FromFile, ToFile, ReadOnly, Executable=False):\r
- if not ContentZipFile or not ContentZipFile.UnpackFile(FromFile, ToFile):\r
- Logger.Error("UPT", FILE_NOT_FOUND, ST.ERR_INSTALL_FILE_FROM_EMPTY_CONTENT%FromFile)\r
+ if os.path.exists(os.path.normpath(ToFile)):\r
+ pass\r
+ else:\r
+ if not ContentZipFile or not ContentZipFile.UnpackFile(FromFile, ToFile):\r
+ Logger.Error("UPT", FILE_NOT_FOUND, ST.ERR_INSTALL_FILE_FROM_EMPTY_CONTENT % FromFile)\r
\r
- if ReadOnly:\r
- if not Executable:\r
- chmod(ToFile, stat.S_IREAD)\r
+ if ReadOnly:\r
+ if not Executable:\r
+ chmod(ToFile, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)\r
+ else:\r
+ chmod(ToFile, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)\r
+ elif Executable:\r
+ chmod(ToFile, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR | stat.S_IWGRP |\r
+ stat.S_IWOTH | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)\r
else:\r
- chmod(ToFile, stat.S_IREAD|stat.S_IEXEC)\r
- elif Executable:\r
- chmod(ToFile, stat.S_IREAD|stat.S_IWRITE|stat.S_IEXEC)\r
- else:\r
- chmod(ToFile, stat.S_IREAD|stat.S_IWRITE)\r
+ chmod(ToFile, stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH | stat.S_IWUSR | stat.S_IWGRP | stat.S_IWOTH)\r
\r
- Md5Sigature = md5.new(open(str(ToFile), 'rb').read())\r
+ Md5Sigature = md5.new(__FileHookOpen__(str(ToFile), 'rb').read())\r
Md5Sum = Md5Sigature.hexdigest()\r
+\r
return Md5Sum\r
- \r
+\r
## InstallPackageContent method\r
#\r
# @param FromPath: FromPath\r
CreateDirectory(ToFile)\r
continue\r
if ReadOnly:\r
- chmod(ToFile, stat.S_IREAD)\r
+ chmod(ToFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH)\r
else:\r
- chmod(ToFile, stat.S_IREAD|stat.S_IWRITE) \r
- Md5Sigature = md5.new(open(str(ToFile), 'rb').read())\r
+ chmod(ToFile, stat.S_IRUSR|stat.S_IRGRP|stat.S_IROTH|stat.S_IWUSR|stat.S_IWGRP|stat.S_IWOTH) \r
+ Md5Sigature = md5.new(__FileHookOpen__(str(ToFile), 'rb').read())\r
Md5Sum = Md5Sigature.hexdigest()\r
if (ToFile, Md5Sum) not in Package.FileList:\r
Package.FileList.append((ToFile, Md5Sum))\r
ExtraData=ST.ERR_DIST_FILE_TOOFEW)\r
return DescFile, ContentFile\r
\r
+## InstallDp method\r
+#\r
+# Install the distribution to current workspace\r
+#\r
+def InstallDp(DistPkg, DpPkgFileName, ContentZipFile, Options, Dep, WorkspaceDir, DataBase):\r
+ #\r
+ # PackageList, ModuleList record the information for the meta-data\r
+ # files that need to be generated later\r
+ #\r
+ PackageList = []\r
+ ModuleList = []\r
+ DistPkg.PackageSurfaceArea = GetPackageList(DistPkg, Dep, WorkspaceDir, Options, \r
+ ContentZipFile, ModuleList, PackageList)\r
+\r
+ DistPkg.ModuleSurfaceArea = GetModuleList(DistPkg, Dep, WorkspaceDir, ContentZipFile, ModuleList)\r
+ \r
+ GenToolMisc(DistPkg, WorkspaceDir, ContentZipFile)\r
+ \r
+ #\r
+ # copy "Distribution File" to directory $(WORKSPACE)/conf/upt\r
+ #\r
+ DistFileName = os.path.split(DpPkgFileName)[1]\r
+ NewDpPkgFileName = BackupDist(DpPkgFileName, DistPkg.Header.GetGuid(), DistPkg.Header.GetVersion(), WorkspaceDir)\r
+\r
+ #\r
+ # update database\r
+ #\r
+ Logger.Quiet(ST.MSG_UPDATE_PACKAGE_DATABASE)\r
+ DataBase.AddDPObject(DistPkg, NewDpPkgFileName, DistFileName, \r
+ DistPkg.Header.RePackage)\r
+\r
--- /dev/null
+## @file\r
+# Inventory workspace's distribution package information.\r
+#\r
+# Copyright (c) 2014, 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
+Inventory workspace's distribution package information.\r
+"""\r
+##\r
+# Import Modules\r
+#\r
+from sys import platform\r
+from traceback import format_exc\r
+from platform import python_version\r
+\r
+from Logger import StringTable as ST\r
+from Logger.ToolError import FatalError\r
+from Logger.ToolError import ABORT_ERROR\r
+from Logger.ToolError import CODE_ERROR\r
+import Logger.Log as Logger\r
+\r
+from Library import GlobalData\r
+\r
+## InventoryDistInstalled\r
+#\r
+# This method retrieves the installed distribution information from the internal UPT database\r
+#\r
+# @param DataBase: the UPT database\r
+#\r
+def InventoryDistInstalled(DataBase):\r
+ DistInstalled = DataBase.InventoryDistInstalled()\r
+ \r
+ #\r
+ # find the max length for each item\r
+ #\r
+ DpNameStr = "DpName"\r
+ DpGuidStr = "DpGuid"\r
+ DpVerStr = "DpVer"\r
+ DpOriginalNameStr = "DpOriginalName"\r
+ MaxGuidlen = len(DpGuidStr)\r
+ MaxVerlen = len(DpVerStr)\r
+ MaxDpAliasFileNameLen = len(DpNameStr) \r
+ MaxDpOrigFileNamelen = len(DpOriginalNameStr)\r
+ \r
+ for (DpGuid, DpVersion, DpOriginalName, DpAliasFileName) in DistInstalled:\r
+ MaxGuidlen = max(MaxGuidlen, len(DpGuid))\r
+ MaxVerlen = max(MaxVerlen, len(DpVersion))\r
+ MaxDpAliasFileNameLen = max(MaxDpAliasFileNameLen, len(DpAliasFileName))\r
+ MaxDpOrigFileNamelen = max(MaxDpOrigFileNamelen, len(DpOriginalName))\r
+\r
+ OutMsgFmt = "%-*s\t%-*s\t%-*s\t%-s"\r
+ OutMsg = OutMsgFmt % (MaxDpAliasFileNameLen, \r
+ DpNameStr, \r
+ MaxGuidlen, \r
+ DpGuidStr, \r
+ MaxVerlen, \r
+ DpVerStr, \r
+ DpOriginalNameStr)\r
+ Logger.Info(OutMsg)\r
+ \r
+ for (DpGuid, DpVersion, DpFileName, DpAliasFileName) in DistInstalled:\r
+ OutMsg = OutMsgFmt % (MaxDpAliasFileNameLen, \r
+ DpAliasFileName, \r
+ MaxGuidlen, \r
+ DpGuid, \r
+ MaxVerlen, \r
+ DpVersion, \r
+ DpFileName)\r
+ Logger.Info(OutMsg)\r
+\r
+## Tool entrance method\r
+#\r
+# This method mainly dispatch specific methods per the command line options.\r
+# If no error found, return zero value so the caller of this tool can know\r
+# if it's executed successfully or not.\r
+#\r
+# @param Options: command Options\r
+#\r
+def Main(Options = None):\r
+ if Options:\r
+ pass\r
+\r
+ try:\r
+ DataBase = GlobalData.gDB\r
+ InventoryDistInstalled(DataBase) \r
+ ReturnCode = 0 \r
+ except FatalError, XExcept:\r
+ ReturnCode = XExcept.args[0]\r
+ if Logger.GetLevel() <= Logger.DEBUG_9:\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(), platform) + format_exc())\r
+ except KeyboardInterrupt: \r
+ ReturnCode = ABORT_ERROR\r
+ if Logger.GetLevel() <= Logger.DEBUG_9:\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(), platform) + format_exc())\r
+ except:\r
+ ReturnCode = CODE_ERROR\r
+ Logger.Error("\nInventoryWs",\r
+ CODE_ERROR,\r
+ ST.ERR_UNKNOWN_FATAL_INVENTORYWS_ERR,\r
+ ExtraData=ST.MSG_SEARCH_FOR_HELP,\r
+ RaiseError=False\r
+ )\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
+ platform) + format_exc())\r
+\r
+ if ReturnCode == 0:\r
+ Logger.Quiet(ST.MSG_FINISH)\r
+ \r
+ return ReturnCode
\ No newline at end of file
## @file\r
# This file is used to define comment generating interface\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.DataType import TAB_INF_GUIDTYPE_VAR\r
from Library.DataType import USAGE_ITEM_NOTIFY\r
from Library.DataType import ITEM_UNDEFINED\r
-from Library.DataType import LANGUAGE_EN_US\r
-\r
+from Library.DataType import TAB_HEADER_COMMENT\r
+from Library.DataType import TAB_BINARY_HEADER_COMMENT\r
+from Library.DataType import TAB_COMMENT_SPLIT\r
+from Library.DataType import TAB_SPECIAL_COMMENT\r
+from Library.DataType import END_OF_LINE\r
+from Library.DataType import TAB_COMMENT_EDK1_SPLIT\r
+from Library.DataType import TAB_COMMENT_EDK1_START\r
+from Library.DataType import TAB_COMMENT_EDK1_END\r
+from Library.DataType import TAB_STAR\r
+from Library.DataType import TAB_PCD_PROMPT\r
+from Library.UniClassObject import ConvertSpecialUnicodes\r
+from Library.Misc import GetLocalValue\r
## GenTailCommentLines\r
#\r
# @param TailCommentLines: the tail comment lines that need to be generated\r
# line tail comment\r
# \r
def GenTailCommentLines (TailCommentLines, LeadingSpaceNum = 0):\r
- EndOfLine = "\n"\r
- TailCommentLines = TailCommentLines.rstrip(EndOfLine)\r
- CommentStr = " ## " + (EndOfLine + LeadingSpaceNum * TAB_SPACE_SPLIT + \\r
- " ## ").join(GetSplitValueList(TailCommentLines, \\r
- EndOfLine))\r
+ TailCommentLines = TailCommentLines.rstrip(END_OF_LINE)\r
+ CommentStr = TAB_SPACE_SPLIT*2 + TAB_SPECIAL_COMMENT + TAB_SPACE_SPLIT + \\r
+ (END_OF_LINE + LeadingSpaceNum * TAB_SPACE_SPLIT + TAB_SPACE_SPLIT*2 + TAB_SPECIAL_COMMENT + \\r
+ TAB_SPACE_SPLIT).join(GetSplitValueList(TailCommentLines, END_OF_LINE))\r
+ \r
return CommentStr\r
\r
## GenGenericComment\r
def GenGenericComment (CommentLines):\r
if not CommentLines:\r
return ''\r
- EndOfLine = "\n"\r
- CommentLines = CommentLines.rstrip(EndOfLine)\r
- CommentStr = '## ' + (EndOfLine + '# ').join\\r
- (GetSplitValueList(CommentLines, EndOfLine)) + EndOfLine\r
+ CommentLines = CommentLines.rstrip(END_OF_LINE)\r
+ CommentStr = TAB_SPECIAL_COMMENT + TAB_SPACE_SPLIT + (END_OF_LINE + TAB_COMMENT_SPLIT + TAB_SPACE_SPLIT).join\\r
+ (GetSplitValueList(CommentLines, END_OF_LINE)) + END_OF_LINE\r
return CommentStr\r
\r
## GenGenericCommentF\r
# @param CommentLines: Generic comment Text, maybe Multiple Lines\r
# @return CommentStr: Generated comment line \r
# \r
-def GenGenericCommentF (CommentLines, NumOfPound=1):\r
+def GenGenericCommentF (CommentLines, NumOfPound=1, IsPrompt=False, IsInfLibraryClass=False):\r
if not CommentLines:\r
return ''\r
- EndOfLine = "\n"\r
#\r
# if comment end with '\n', then remove it to prevent one extra line\r
# generate later on\r
#\r
- if CommentLines.endswith(EndOfLine):\r
+ if CommentLines.endswith(END_OF_LINE):\r
CommentLines = CommentLines[:-1]\r
- CommentLineList = GetSplitValueList(CommentLines, EndOfLine)\r
CommentStr = ''\r
- for Line in CommentLineList:\r
- if Line == '':\r
- CommentStr += '#' * NumOfPound + '\n'\r
- else:\r
- CommentStr += '#' * NumOfPound + ' ' + Line + '\n'\r
+ if IsPrompt:\r
+ CommentStr += TAB_COMMENT_SPLIT * NumOfPound + TAB_SPACE_SPLIT + TAB_PCD_PROMPT + TAB_SPACE_SPLIT + \\r
+ CommentLines.replace(END_OF_LINE, '') + END_OF_LINE\r
+ else:\r
+ CommentLineList = GetSplitValueList(CommentLines, END_OF_LINE)\r
+ FindLibraryClass = False\r
+ for Line in CommentLineList:\r
+ # If this comment is for @libraryclass and it has multiple lines\r
+ # make sure the second lines align to the first line after @libraryclass as below\r
+ #\r
+ # ## @libraryclass XYZ FIRST_LINE\r
+ # ## ABC SECOND_LINE\r
+ #\r
+ if IsInfLibraryClass and Line.find(u'@libraryclass ') > -1:\r
+ FindLibraryClass = True\r
+ if Line == '':\r
+ CommentStr += TAB_COMMENT_SPLIT * NumOfPound + END_OF_LINE\r
+ else:\r
+ if FindLibraryClass and Line.find(u'@libraryclass ') > -1:\r
+ CommentStr += TAB_COMMENT_SPLIT * NumOfPound + TAB_SPACE_SPLIT + Line + END_OF_LINE\r
+ elif FindLibraryClass:\r
+ CommentStr += TAB_COMMENT_SPLIT * NumOfPound + TAB_SPACE_SPLIT * 16 + Line + END_OF_LINE\r
+ else:\r
+ CommentStr += TAB_COMMENT_SPLIT * NumOfPound + TAB_SPACE_SPLIT + Line + END_OF_LINE\r
\r
return CommentStr\r
\r
# @param Copyright possible multiple copyright lines\r
# @param License possible multiple license lines\r
#\r
-def GenHeaderCommentSection(Abstract, Description, Copyright, License):\r
- EndOfLine = '\n'\r
+def GenHeaderCommentSection(Abstract, Description, Copyright, License, IsBinaryHeader=False, \\r
+ CommChar=TAB_COMMENT_SPLIT):\r
Content = ''\r
- \r
- Content += '## @file' + EndOfLine\r
+\r
+ #\r
+ # Convert special character to (c), (r) and (tm).\r
+ #\r
+ if isinstance(Abstract, unicode):\r
+ Abstract = ConvertSpecialUnicodes(Abstract)\r
+ if isinstance(Description, unicode):\r
+ Description = ConvertSpecialUnicodes(Description)\r
+ if IsBinaryHeader:\r
+ Content += CommChar * 2 + TAB_SPACE_SPLIT + TAB_BINARY_HEADER_COMMENT + END_OF_LINE\r
+ elif CommChar == TAB_COMMENT_EDK1_SPLIT:\r
+ Content += CommChar + TAB_SPACE_SPLIT + TAB_COMMENT_EDK1_START + TAB_STAR + TAB_SPACE_SPLIT +\\r
+ TAB_HEADER_COMMENT + END_OF_LINE\r
+ else:\r
+ Content += CommChar * 2 + TAB_SPACE_SPLIT + TAB_HEADER_COMMENT + END_OF_LINE\r
if Abstract:\r
- Abstract = Abstract.rstrip(EndOfLine)\r
- Content += '# ' + Abstract + EndOfLine\r
- Content += '#' + EndOfLine\r
+ Abstract = Abstract.rstrip(END_OF_LINE)\r
+ Content += CommChar + TAB_SPACE_SPLIT + (END_OF_LINE + CommChar + TAB_SPACE_SPLIT).join(GetSplitValueList\\r
+ (Abstract, END_OF_LINE))\r
+ Content += END_OF_LINE + CommChar + END_OF_LINE\r
else:\r
- Content += '#' + EndOfLine\r
+ Content += CommChar + END_OF_LINE\r
\r
if Description:\r
- Description = Description.rstrip(EndOfLine)\r
- Content += '# ' + (EndOfLine + '# ').join(GetSplitValueList\\r
- (Description, '\n'))\r
- Content += EndOfLine + '#' + EndOfLine \r
+ Description = Description.rstrip(END_OF_LINE)\r
+ Content += CommChar + TAB_SPACE_SPLIT + (END_OF_LINE + CommChar + TAB_SPACE_SPLIT).join(GetSplitValueList\\r
+ (Description, END_OF_LINE))\r
+ Content += END_OF_LINE + CommChar + END_OF_LINE \r
\r
#\r
# There is no '#\n' line to separate multiple copyright lines in code base \r
#\r
if Copyright:\r
- Copyright = Copyright.rstrip(EndOfLine)\r
- Content += '# ' + (EndOfLine + '# ').join\\r
- (GetSplitValueList(Copyright, '\n'))\r
- Content += EndOfLine + '#' + EndOfLine\r
+ Copyright = Copyright.rstrip(END_OF_LINE)\r
+ Content += CommChar + TAB_SPACE_SPLIT + (END_OF_LINE + CommChar + TAB_SPACE_SPLIT).join\\r
+ (GetSplitValueList(Copyright, END_OF_LINE))\r
+ Content += END_OF_LINE + CommChar + END_OF_LINE\r
\r
if License:\r
- License = License.rstrip(EndOfLine)\r
- Content += '# ' + (EndOfLine + '# ').join(GetSplitValueList\\r
- (License, '\n'))\r
- Content += EndOfLine + '#' + EndOfLine\r
-\r
- Content += '##' + EndOfLine\r
+ License = License.rstrip(END_OF_LINE)\r
+ Content += CommChar + TAB_SPACE_SPLIT + (END_OF_LINE + CommChar + TAB_SPACE_SPLIT).join(GetSplitValueList\\r
+ (License, END_OF_LINE))\r
+ Content += END_OF_LINE + CommChar + END_OF_LINE\r
+ \r
+ if CommChar == TAB_COMMENT_EDK1_SPLIT:\r
+ Content += CommChar + TAB_SPACE_SPLIT + TAB_STAR + TAB_COMMENT_EDK1_END + END_OF_LINE\r
+ else:\r
+ Content += CommChar * 2 + END_OF_LINE\r
\r
return Content\r
\r
# @return HelpStr: the help text string found, '' means no help text found\r
#\r
def _GetHelpStr(HelpTextObjList):\r
- HelpStr = ''\r
-\r
- for HelpObj in HelpTextObjList:\r
- if HelpObj and HelpObj.GetLang() == LANGUAGE_EN_US:\r
- HelpStr = HelpObj.GetString()\r
- return HelpStr\r
- \r
- for HelpObj in HelpTextObjList:\r
- if HelpObj and HelpObj.GetLang().startswith('en'):\r
- HelpStr = HelpObj.GetString()\r
- return HelpStr\r
-\r
+ ValueList = [] \r
for HelpObj in HelpTextObjList:\r
- if HelpObj and not HelpObj.GetLang():\r
- HelpStr = HelpObj.GetString()\r
- return HelpStr\r
- \r
- return HelpStr
\ No newline at end of file
+ ValueList.append((HelpObj.GetLang(), HelpObj.GetString()))\r
+ return GetLocalValue(ValueList, True)\r
## @file\r
# This file is used to define comment parsing interface\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.DataType import TAB_SPACE_SPLIT\r
from Library.DataType import TAB_COMMA_SPLIT\r
from Library.DataType import SUP_MODULE_LIST\r
+from Library.DataType import TAB_VALUE_SPLIT\r
+from Library.DataType import TAB_PCD_VALIDRANGE\r
+from Library.DataType import TAB_PCD_VALIDLIST\r
+from Library.DataType import TAB_PCD_EXPRESSION\r
+from Library.DataType import TAB_PCD_PROMPT\r
+from Library.DataType import TAB_CAPHEX_START\r
+from Library.DataType import TAB_HEX_START\r
+from Library.DataType import PCD_ERR_CODE_MAX_SIZE\r
+from Library.ExpressionValidate import IsValidRangeExpr\r
+from Library.ExpressionValidate import IsValidListExpr\r
+from Library.ExpressionValidate import IsValidLogicalExpr\r
from Object.POM.CommonObject import TextObject\r
from Object.POM.CommonObject import PcdErrorObject\r
import Logger.Log as Logger\r
# @param CommentList: List of (Comment, LineNumber)\r
# @param FileName: FileName of the comment\r
#\r
-def ParseHeaderCommentSection(CommentList, FileName = None):\r
+def ParseHeaderCommentSection(CommentList, FileName = None, IsBinaryHeader = False):\r
Abstract = ''\r
Description = ''\r
Copyright = ''\r
License = ''\r
EndOfLine = "\n"\r
- STR_HEADER_COMMENT_START = "@file"\r
+ if IsBinaryHeader:\r
+ STR_HEADER_COMMENT_START = "@BinaryHeader"\r
+ else:\r
+ STR_HEADER_COMMENT_START = "@file"\r
HeaderCommentStage = HEADER_COMMENT_NOT_STARTED\r
\r
#\r
# in case there is no abstract and description\r
#\r
if not Comment:\r
- Abstract = ''\r
HeaderCommentStage = HEADER_COMMENT_DESCRIPTION\r
elif _IsCopyrightLine(Comment):\r
Result, ErrMsg = _ValidateCopyright(Comment)\r
if not Comment and not License:\r
continue\r
License += Comment + EndOfLine\r
- \r
- if not Copyright:\r
- Logger.Error("\nUPT", FORMAT_INVALID, ST.ERR_COPYRIGHT_MISSING, \\r
- FileName)\r
-\r
- if not License:\r
- Logger.Error("\nUPT", FORMAT_INVALID, ST.ERR_LICENSE_MISSING, FileName)\r
- \r
+ \r
return Abstract.strip(), Description.strip(), Copyright.strip(), License.strip()\r
\r
## _IsCopyrightLine\r
ReIsCopyrightRe = re.compile(r"""(^|\s)COPYRIGHT *\(""", re.DOTALL)\r
if ReIsCopyrightRe.search(LineContent):\r
Result = True\r
- \r
+\r
return Result\r
\r
## ParseGenericComment\r
\r
return HelpTxt\r
\r
+## ParsePcdErrorCode\r
+#\r
+# @param Value: original ErrorCode value \r
+# @param ContainerFile: Input value for filename of Dec file\r
+# @param LineNum: Line Num \r
+# \r
+def ParsePcdErrorCode (Value = None, ContainerFile = None, LineNum = None): \r
+ try: \r
+ if Value.strip().startswith((TAB_HEX_START, TAB_CAPHEX_START)):\r
+ Base = 16\r
+ else:\r
+ Base = 10\r
+ ErrorCode = long(Value, Base)\r
+ if ErrorCode > PCD_ERR_CODE_MAX_SIZE or ErrorCode < 0:\r
+ Logger.Error('Parser', \r
+ FORMAT_NOT_SUPPORTED,\r
+ "The format %s of ErrorCode is not valid, should be UNIT32 type or long type" % Value,\r
+ File = ContainerFile, \r
+ Line = LineNum)\r
+ #\r
+ # To delete the tailing 'L'\r
+ #\r
+ return hex(ErrorCode)[:-1]\r
+ except ValueError, XStr:\r
+ if XStr:\r
+ pass\r
+ Logger.Error('Parser', \r
+ FORMAT_NOT_SUPPORTED,\r
+ "The format %s of ErrorCode is not valid, should be UNIT32 type or long type" % Value,\r
+ File = ContainerFile, \r
+ Line = LineNum)\r
\r
## ParseDecPcdGenericComment\r
#\r
# LineNum)\r
# @param ContainerFile: Input value for filename of Dec file\r
# \r
-def ParseDecPcdGenericComment (GenericComment, ContainerFile): \r
+def ParseDecPcdGenericComment (GenericComment, ContainerFile, TokenSpaceGuidCName, CName, MacroReplaceDict): \r
HelpStr = '' \r
+ PromptStr = ''\r
PcdErr = None\r
+ PcdErrList = []\r
+ ValidValueNum = 0\r
+ ValidRangeNum = 0\r
+ ExpressionNum = 0\r
\r
for (CommentLine, LineNum) in GenericComment:\r
Comment = CleanString2(CommentLine)[1]\r
- if Comment.startswith("@ValidRange"):\r
- if PcdErr:\r
+ #\r
+ # To replace Macro\r
+ #\r
+ MACRO_PATTERN = '[\t\s]*\$\([A-Z][_A-Z0-9]*\)'\r
+ MatchedStrs = re.findall(MACRO_PATTERN, Comment)\r
+ for MatchedStr in MatchedStrs:\r
+ if MatchedStr:\r
+ Macro = MatchedStr.strip().lstrip('$(').rstrip(')').strip()\r
+ if Macro in MacroReplaceDict:\r
+ Comment = Comment.replace(MatchedStr, MacroReplaceDict[Macro]) \r
+ if Comment.startswith(TAB_PCD_VALIDRANGE):\r
+ if ValidValueNum > 0 or ExpressionNum > 0:\r
Logger.Error('Parser', \r
FORMAT_NOT_SUPPORTED,\r
ST.WRN_MULTI_PCD_RANGES,\r
File = ContainerFile, \r
Line = LineNum)\r
- ValidRange = Comment.replace("@ValidRange", "", 1)\r
- if _CheckRangeExpression(ValidRange):\r
+ else:\r
PcdErr = PcdErrorObject()\r
- PcdErr.SetValidValueRange(ValidRange)\r
- elif Comment.startswith("@ValidList"):\r
- if PcdErr:\r
+ PcdErr.SetTokenSpaceGuidCName(TokenSpaceGuidCName)\r
+ PcdErr.SetCName(CName)\r
+ PcdErr.SetFileLine(Comment)\r
+ PcdErr.SetLineNum(LineNum)\r
+ ValidRangeNum += 1\r
+ ValidRange = Comment.replace(TAB_PCD_VALIDRANGE, "", 1).strip()\r
+ Valid, Cause = _CheckRangeExpression(ValidRange)\r
+ if Valid:\r
+ ValueList = ValidRange.split(TAB_VALUE_SPLIT)\r
+ if len(ValueList) > 1:\r
+ PcdErr.SetValidValueRange((TAB_VALUE_SPLIT.join(ValueList[1:])).strip())\r
+ PcdErr.SetErrorNumber(ParsePcdErrorCode(ValueList[0], ContainerFile, LineNum))\r
+ else:\r
+ PcdErr.SetValidValueRange(ValidRange)\r
+ PcdErrList.append(PcdErr)\r
+ else:\r
+ Logger.Error("Parser",\r
+ FORMAT_NOT_SUPPORTED,\r
+ Cause, \r
+ ContainerFile, \r
+ LineNum)\r
+ elif Comment.startswith(TAB_PCD_VALIDLIST):\r
+ if ValidRangeNum > 0 or ExpressionNum > 0:\r
Logger.Error('Parser', \r
FORMAT_NOT_SUPPORTED,\r
ST.WRN_MULTI_PCD_RANGES,\r
File = ContainerFile, \r
Line = LineNum)\r
- ValidValue = Comment.replace("@ValidList", "", 1).replace(TAB_COMMA_SPLIT, TAB_SPACE_SPLIT)\r
- PcdErr = PcdErrorObject()\r
- PcdErr.SetValidValue(ValidValue)\r
- elif Comment.startswith("@Expression"):\r
- if PcdErr:\r
+ elif ValidValueNum > 0:\r
+ Logger.Error('Parser', \r
+ FORMAT_NOT_SUPPORTED,\r
+ ST.WRN_MULTI_PCD_VALIDVALUE,\r
+ File = ContainerFile, \r
+ Line = LineNum)\r
+ else:\r
+ PcdErr = PcdErrorObject()\r
+ PcdErr.SetTokenSpaceGuidCName(TokenSpaceGuidCName)\r
+ PcdErr.SetCName(CName)\r
+ PcdErr.SetFileLine(Comment)\r
+ PcdErr.SetLineNum(LineNum)\r
+ ValidValueNum += 1\r
+ ValidValueExpr = Comment.replace(TAB_PCD_VALIDLIST, "", 1).strip()\r
+ Valid, Cause = _CheckListExpression(ValidValueExpr)\r
+ if Valid:\r
+ ValidValue = Comment.replace(TAB_PCD_VALIDLIST, "", 1).replace(TAB_COMMA_SPLIT, TAB_SPACE_SPLIT)\r
+ ValueList = ValidValue.split(TAB_VALUE_SPLIT)\r
+ if len(ValueList) > 1:\r
+ PcdErr.SetValidValue((TAB_VALUE_SPLIT.join(ValueList[1:])).strip())\r
+ PcdErr.SetErrorNumber(ParsePcdErrorCode(ValueList[0], ContainerFile, LineNum))\r
+ else:\r
+ PcdErr.SetValidValue(ValidValue)\r
+ PcdErrList.append(PcdErr)\r
+ else:\r
+ Logger.Error("Parser",\r
+ FORMAT_NOT_SUPPORTED,\r
+ Cause, \r
+ ContainerFile, \r
+ LineNum)\r
+ elif Comment.startswith(TAB_PCD_EXPRESSION):\r
+ if ValidRangeNum > 0 or ValidValueNum > 0:\r
Logger.Error('Parser', \r
FORMAT_NOT_SUPPORTED,\r
ST.WRN_MULTI_PCD_RANGES,\r
File = ContainerFile, \r
Line = LineNum)\r
- Expression = Comment.replace("@Expression", "", 1)\r
- if _CheckRangeExpression(Expression):\r
+ else:\r
PcdErr = PcdErrorObject()\r
- PcdErr.SetExpression(Expression)\r
+ PcdErr.SetTokenSpaceGuidCName(TokenSpaceGuidCName)\r
+ PcdErr.SetCName(CName)\r
+ PcdErr.SetFileLine(Comment)\r
+ PcdErr.SetLineNum(LineNum)\r
+ ExpressionNum += 1\r
+ Expression = Comment.replace(TAB_PCD_EXPRESSION, "", 1).strip()\r
+ Valid, Cause = _CheckExpression(Expression)\r
+ if Valid:\r
+ ValueList = Expression.split(TAB_VALUE_SPLIT)\r
+ if len(ValueList) > 1:\r
+ PcdErr.SetExpression((TAB_VALUE_SPLIT.join(ValueList[1:])).strip())\r
+ PcdErr.SetErrorNumber(ParsePcdErrorCode(ValueList[0], ContainerFile, LineNum))\r
+ else:\r
+ PcdErr.SetExpression(Expression)\r
+ PcdErrList.append(PcdErr)\r
+ else: \r
+ Logger.Error("Parser",\r
+ FORMAT_NOT_SUPPORTED,\r
+ Cause, \r
+ ContainerFile, \r
+ LineNum) \r
+ elif Comment.startswith(TAB_PCD_PROMPT):\r
+ if PromptStr:\r
+ Logger.Error('Parser', \r
+ FORMAT_NOT_SUPPORTED,\r
+ ST.WRN_MULTI_PCD_PROMPT,\r
+ File = ContainerFile, \r
+ Line = LineNum)\r
+ PromptStr = Comment.replace(TAB_PCD_PROMPT, "", 1).strip()\r
else:\r
- HelpStr += Comment + '\n'\r
+ if Comment:\r
+ HelpStr += Comment + '\n'\r
\r
#\r
# remove the last EOL if the comment is of format 'FOO\n'\r
if HelpStr != '\n' and not HelpStr.endswith('\n\n'):\r
HelpStr = HelpStr[:-1]\r
\r
- return HelpStr, PcdErr\r
+ return HelpStr, PcdErrList, PromptStr\r
\r
## ParseDecPcdTailComment\r
#\r
\r
return SupModuleList, HelpStr\r
\r
+## _CheckListExpression\r
+#\r
+# @param Expression: Pcd value list expression \r
+#\r
+def _CheckListExpression(Expression):\r
+ ListExpr = ''\r
+ if TAB_VALUE_SPLIT in Expression:\r
+ ListExpr = Expression[Expression.find(TAB_VALUE_SPLIT)+1:] \r
+ else:\r
+ ListExpr = Expression\r
+ \r
+ return IsValidListExpr(ListExpr)\r
+\r
+## _CheckExpreesion\r
+#\r
+# @param Expression: Pcd value expression\r
+#\r
+def _CheckExpression(Expression):\r
+ Expr = ''\r
+ if TAB_VALUE_SPLIT in Expression:\r
+ Expr = Expression[Expression.find(TAB_VALUE_SPLIT)+1:]\r
+ else:\r
+ Expr = Expression\r
+ return IsValidLogicalExpr(Expr, True)\r
\r
## _CheckRangeExpression\r
#\r
# @param Expression: Pcd range expression\r
# \r
def _CheckRangeExpression(Expression):\r
- #\r
- # check grammar for Pcd range expression is not required yet\r
- #\r
- if Expression:\r
- pass\r
- return True\r
+ RangeExpr = ''\r
+ if TAB_VALUE_SPLIT in Expression:\r
+ RangeExpr = Expression[Expression.find(TAB_VALUE_SPLIT)+1:]\r
+ else:\r
+ RangeExpr = Expression\r
+ \r
+ return IsValidRangeExpr(RangeExpr)\r
\r
## ValidateCopyright\r
#\r
Usage = None\r
Type = None\r
String = None\r
- HelpText = None\r
\r
Comment = Comment[0]\r
\r
## @file\r
# This file is used to define class for data type structure\r
#\r
-# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
"PRODUCES",\r
"SOMETIMES_PRODUCES"]\r
\r
-LANGUAGE_EN_US = 'en-US'\r
+TAB_LANGUAGE_EN_US = 'en-US'\r
+TAB_LANGUAGE_ENG = 'eng'\r
+TAB_LANGUAGE_EN = 'en'\r
+TAB_LANGUAGE_EN_X = 'en-x-tianocore'\r
\r
USAGE_ITEM_PRODUCES = 'PRODUCES'\r
USAGE_ITEM_SOMETIMES_PRODUCES = 'SOMETIMES_PRODUCES'\r
\r
ITEM_UNDEFINED = 'UNDEFINED'\r
\r
+TAB_PCD_VALIDRANGE = '@ValidRange'\r
+TAB_PCD_VALIDLIST = '@ValidList'\r
+TAB_PCD_EXPRESSION = '@Expression'\r
+TAB_PCD_PROMPT = '@Prompt'\r
+TAB_STR_TOKENCNAME = 'STR'\r
+TAB_STR_TOKENPROMPT = 'PROMPT'\r
+TAB_STR_TOKENHELP = 'HELP'\r
+TAB_STR_TOKENERR = 'ERR'\r
\r
#\r
# Dictionary of usage tokens and their synonmys\r
##\r
# Binary File Type List\r
#\r
-BINARY_FILE_TYPE_LIST = ["GUID", "PE32", "PIC", "TE", "DXE_DEPEX", "VER", "UI", "COMPAT16", "FV", "BIN", "RAW",\r
+BINARY_FILE_TYPE_LIST = ["PE32", "PIC", "TE", "DXE_DEPEX", "VER", "UI", "COMPAT16", "FV", "BIN", "RAW",\r
"ACPI", "ASL",\r
"PEI_DEPEX",\r
"SMM_DEPEX",\r
- "SUBTYPE_GUID" \r
+ "SUBTYPE_GUID",\r
+ "DISPOSABLE"\r
]\r
BINARY_FILE_TYPE_LIST_IN_UDP = \\r
["GUID", "FREEFORM",\r
"BIN", "VER", "UI" \r
]\r
\r
+SUBTYPE_GUID_BINARY_FILE_TYPE = "FREEFORM"\r
##\r
# Possible values for COMPONENT_TYPE, and their descriptions, are listed in \r
# the table, \r
TAB_DEQUAL_SPLIT = '=='\r
TAB_VALUE_SPLIT = '|'\r
TAB_COMMA_SPLIT = ','\r
+TAB_HORIZON_LINE_SPLIT = '-'\r
TAB_SPACE_SPLIT = ' '\r
TAB_UNDERLINE_SPLIT = '_'\r
TAB_SEMI_COLON_SPLIT = ';'\r
TAB_SPECIAL_COMMENT = '##'\r
TAB_HEADER_COMMENT = '@file'\r
TAB_BINARY_HEADER_COMMENT = '@BinaryHeader'\r
-TAB_STAR = "*"\r
+TAB_STAR = '*'\r
+TAB_ENCODING_UTF16LE = 'utf_16_le'\r
+TAB_CAPHEX_START = '0X'\r
+TAB_HEX_START = '0x'\r
+TAB_PCD_ERROR = 'Error'\r
+TAB_PCD_ERROR_SECTION_COMMENT = 'Error message section'\r
+TAB_UNI_FILE_SUFFIXS = ['.uni', '.UNI', '.Uni']\r
\r
TAB_EDK_SOURCE = '$(EDK_SOURCE)'\r
TAB_EFI_SOURCE = '$(EFI_SOURCE)'\r
TAB_ARCH_IPF = 'IPF'\r
TAB_ARCH_ARM = 'ARM'\r
TAB_ARCH_EBC = 'EBC'\r
-TAB_ARCH_AARCH64 = 'AARCH64'\r
\r
ARCH_LIST = \\r
-[TAB_ARCH_IA32, TAB_ARCH_X64, TAB_ARCH_IPF, TAB_ARCH_ARM, TAB_ARCH_EBC, TAB_ARCH_AARCH64]\r
+[TAB_ARCH_IA32, TAB_ARCH_X64, TAB_ARCH_IPF, TAB_ARCH_ARM, TAB_ARCH_EBC]\r
\r
SUP_MODULE_BASE = 'BASE'\r
SUP_MODULE_SEC = 'SEC'\r
TAB_SOURCES_IPF = TAB_SOURCES + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_SOURCES_ARM = TAB_SOURCES + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_SOURCES_EBC = TAB_SOURCES + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_SOURCES_AARCH64 = TAB_SOURCES + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_BINARIES = 'Binaries'\r
TAB_BINARIES_COMMON = TAB_BINARIES + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_BINARIES_IPF = TAB_BINARIES + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_BINARIES_ARM = TAB_BINARIES + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_BINARIES_EBC = TAB_BINARIES + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_BINARIES_AARCH64 = TAB_BINARIES + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_INCLUDES = 'Includes'\r
TAB_INCLUDES_COMMON = TAB_INCLUDES + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_INCLUDES_IPF = TAB_INCLUDES + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_INCLUDES_ARM = TAB_INCLUDES + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_INCLUDES_EBC = TAB_INCLUDES + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_INCLUDES_AARCH64 = TAB_INCLUDES + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_GUIDS = 'Guids'\r
TAB_GUIDS_COMMON = TAB_GUIDS + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_GUIDS_IPF = TAB_GUIDS + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_GUIDS_ARM = TAB_GUIDS + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_GUIDS_EBC = TAB_GUIDS + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_GUIDS_AARCH64 = TAB_GUIDS + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_PROTOCOLS = 'Protocols'\r
TAB_PROTOCOLS_COMMON = TAB_PROTOCOLS + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_PROTOCOLS_IPF = TAB_PROTOCOLS + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_PROTOCOLS_ARM = TAB_PROTOCOLS + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_PROTOCOLS_EBC = TAB_PROTOCOLS + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_PROTOCOLS_AARCH64 = TAB_PROTOCOLS + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_PPIS = 'Ppis'\r
TAB_PPIS_COMMON = TAB_PPIS + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_PPIS_IPF = TAB_PPIS + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_PPIS_ARM = TAB_PPIS + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_PPIS_EBC = TAB_PPIS + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_PPIS_AARCH64 = TAB_PPIS + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_LIBRARY_CLASSES = 'LibraryClasses'\r
TAB_LIBRARY_CLASSES_COMMON = TAB_LIBRARY_CLASSES + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_LIBRARY_CLASSES_IPF = TAB_LIBRARY_CLASSES + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_LIBRARY_CLASSES_ARM = TAB_LIBRARY_CLASSES + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_LIBRARY_CLASSES_EBC = TAB_LIBRARY_CLASSES + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_LIBRARY_CLASSES_AARCH64 = TAB_LIBRARY_CLASSES + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_PACKAGES = 'Packages'\r
TAB_PACKAGES_COMMON = TAB_PACKAGES + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_PACKAGES_IPF = TAB_PACKAGES + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_PACKAGES_ARM = TAB_PACKAGES + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_PACKAGES_EBC = TAB_PACKAGES + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_PACKAGES_AARCH64 = TAB_PACKAGES + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_PCDS = 'Pcds'\r
TAB_PCDS_FIXED_AT_BUILD = 'FixedAtBuild'\r
TAB_SPLIT + TAB_ARCH_ARM\r
TAB_PCDS_FIXED_AT_BUILD_EBC = TAB_PCDS + TAB_PCDS_FIXED_AT_BUILD + \\r
TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_PCDS_FIXED_AT_BUILD_AARCH64 = TAB_PCDS + TAB_PCDS_FIXED_AT_BUILD + \\r
-TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_PCDS_PATCHABLE_IN_MODULE_NULL = TAB_PCDS + TAB_PCDS_PATCHABLE_IN_MODULE\r
TAB_PCDS_PATCHABLE_IN_MODULE_COMMON = TAB_PCDS + TAB_PCDS_PATCHABLE_IN_MODULE \\r
TAB_SPLIT + TAB_ARCH_ARM\r
TAB_PCDS_PATCHABLE_IN_MODULE_EBC = TAB_PCDS + TAB_PCDS_PATCHABLE_IN_MODULE + \\r
TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_PCDS_PATCHABLE_IN_MODULE_AARCH64 = TAB_PCDS + TAB_PCDS_PATCHABLE_IN_MODULE + \\r
-TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_PCDS_FEATURE_FLAG_NULL = TAB_PCDS + TAB_PCDS_FEATURE_FLAG\r
TAB_PCDS_FEATURE_FLAG_COMMON = TAB_PCDS + TAB_PCDS_FEATURE_FLAG + TAB_SPLIT \\r
TAB_ARCH_ARM\r
TAB_PCDS_FEATURE_FLAG_EBC = TAB_PCDS + TAB_PCDS_FEATURE_FLAG + TAB_SPLIT + \\r
TAB_ARCH_EBC\r
-TAB_PCDS_FEATURE_FLAG_AARCH64 = TAB_PCDS + TAB_PCDS_FEATURE_FLAG + TAB_SPLIT + \\r
-TAB_ARCH_AARCH64\r
\r
TAB_PCDS_DYNAMIC_EX_NULL = TAB_PCDS + TAB_PCDS_DYNAMIC_EX\r
TAB_PCDS_DYNAMIC_EX_DEFAULT_NULL = TAB_PCDS + TAB_PCDS_DYNAMIC_EX_DEFAULT\r
TAB_ARCH_ARM\r
TAB_PCDS_DYNAMIC_EX_EBC = TAB_PCDS + TAB_PCDS_DYNAMIC_EX + TAB_SPLIT + \\r
TAB_ARCH_EBC\r
-TAB_PCDS_DYNAMIC_EX_AARCH64 = TAB_PCDS + TAB_PCDS_DYNAMIC_EX + TAB_SPLIT + \\r
-TAB_ARCH_AARCH64\r
\r
TAB_PCDS_DYNAMIC_NULL = TAB_PCDS + TAB_PCDS_DYNAMIC\r
TAB_PCDS_DYNAMIC_DEFAULT_NULL = TAB_PCDS + TAB_PCDS_DYNAMIC_DEFAULT\r
TAB_PCDS_DYNAMIC_IPF = TAB_PCDS + TAB_PCDS_DYNAMIC + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_PCDS_DYNAMIC_ARM = TAB_PCDS + TAB_PCDS_DYNAMIC + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_PCDS_DYNAMIC_EBC = TAB_PCDS + TAB_PCDS_DYNAMIC + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_PCDS_DYNAMIC_AARCH64 = TAB_PCDS + TAB_PCDS_DYNAMIC + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_PCD_DYNAMIC_TYPE_LIST = [TAB_PCDS_DYNAMIC_DEFAULT_NULL, \\r
TAB_PCDS_DYNAMIC_VPD_NULL, \\r
TAB_DEPEX_IPF = TAB_DEPEX + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_DEPEX_ARM = TAB_DEPEX + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_DEPEX_EBC = TAB_DEPEX + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_DEPEX_AARCH64 = TAB_DEPEX + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_SKUIDS = 'SkuIds'\r
\r
TAB_LIBRARIES_IPF = TAB_LIBRARIES + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_LIBRARIES_ARM = TAB_LIBRARIES + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_LIBRARIES_EBC = TAB_LIBRARIES + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_LIBRARIES_AARCH64 = TAB_LIBRARIES + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_COMPONENTS = 'Components'\r
TAB_COMPONENTS_COMMON = TAB_COMPONENTS + TAB_SPLIT + TAB_ARCH_COMMON\r
TAB_COMPONENTS_IPF = TAB_COMPONENTS + TAB_SPLIT + TAB_ARCH_IPF\r
TAB_COMPONENTS_ARM = TAB_COMPONENTS + TAB_SPLIT + TAB_ARCH_ARM\r
TAB_COMPONENTS_EBC = TAB_COMPONENTS + TAB_SPLIT + TAB_ARCH_EBC\r
-TAB_COMPONENTS_AARCH64 = TAB_COMPONENTS + TAB_SPLIT + TAB_ARCH_AARCH64\r
\r
TAB_COMPONENTS_SOURCE_OVERRIDE_PATH = 'SOURCE_OVERRIDE_PATH'\r
\r
TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION = 'UEFI_SPECIFICATION_VERSION'\r
TAB_INF_DEFINES_PI_SPECIFICATION_VERSION = 'PI_SPECIFICATION_VERSION'\r
TAB_INF_DEFINES_EDK_RELEASE_VERSION = 'EDK_RELEASE_VERSION'\r
+TAB_INF_DEFINES_MODULE_UNI_FILE = 'MODULE_UNI_FILE'\r
TAB_INF_DEFINES_BINARY_MODULE = 'BINARY_MODULE'\r
TAB_INF_DEFINES_LIBRARY_CLASS = 'LIBRARY_CLASS'\r
TAB_INF_DEFINES_COMPONENT_TYPE = 'COMPONENT_TYPE'\r
TAB_DEC_DEFINES_PACKAGE_NAME = 'PACKAGE_NAME'\r
TAB_DEC_DEFINES_PACKAGE_GUID = 'PACKAGE_GUID'\r
TAB_DEC_DEFINES_PACKAGE_VERSION = 'PACKAGE_VERSION'\r
-TAB_DEC_DEFINES_PKG_UNI_FILE = 'PKG_UNI_FILE'\r
+TAB_DEC_DEFINES_PKG_UNI_FILE = 'PACKAGE_UNI_FILE'\r
TAB_DEC_PACKAGE_ABSTRACT = 'STR_PACKAGE_ABSTRACT'\r
TAB_DEC_PACKAGE_DESCRIPTION = 'STR_PACKAGE_DESCRIPTION'\r
TAB_DEC_PACKAGE_LICENSE = 'STR_PACKAGE_LICENSE'\r
TAB_HEADER_LICENSE = 'License'\r
TAB_BINARY_HEADER_IDENTIFIER = 'BinaryHeader'\r
TAB_BINARY_HEADER_USERID = 'TianoCore'\r
+\r
#\r
# Build database path\r
#\r
TYPE_HOB_SECTION = 'HOB'\r
TYPE_EVENT_SECTION = 'EVENT'\r
TYPE_BOOTMODE_SECTION = 'BOOTMODE' \r
+\r
+PCD_ERR_CODE_MAX_SIZE = 4294967295\r
## @file\r
# This file is used to check PCD logical expression\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
'>' : '=',\r
'<' : '='\r
}\r
+ \r
for Operator in OpList:\r
if not self.Token[self.Index:].startswith(Operator):\r
continue\r
+ \r
self.Index += len(Operator)\r
Char = self.Token[self.Index : self.Index + 1]\r
+\r
if (Operator in LetterOp and (Char == '_' or Char.isalnum())) \\r
or (Operator in OpMap and OpMap[Operator] == Char):\r
self.Index -= len(Operator)\r
break\r
+ \r
return True\r
+ \r
return False\r
\r
## _LogicalExpressionParser\r
return False\r
\r
return True\r
+ \r
return False\r
\r
def IsAtomicNumVal(self):\r
#\r
def LogicalExpression(self):\r
Ret = self.SpecNot()\r
- while self.IsCurrentOp(['||', 'OR', 'or', '&&', 'AND', 'and', 'XOR']):\r
+ while self.IsCurrentOp(['||', 'OR', 'or', '&&', 'AND', 'and', 'XOR', 'xor', '^']):\r
if self.Token[self.Index-1] == '|' and self.Parens <= 0:\r
- raise _ExprError(ST.ERR_EXPR_OR)\r
- if Ret == self.ARITH:\r
+ raise _ExprError(ST.ERR_EXPR_OR % self.Token)\r
+ if Ret not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
Ret = self.SpecNot()\r
- if Ret == self.ARITH:\r
+ if Ret not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
Ret = self.REALLOGICAL\r
return Ret\r
\r
def SpecNot(self):\r
- if self.IsCurrentOp(["NOT", "!"]):\r
+ if self.IsCurrentOp(["NOT", "!", "not"]):\r
return self.SpecNot()\r
return self.Rel()\r
\r
- ## A < B, A > B, A <= B, A >= b\r
+ ## A < B, A > B, A <= B, A >= B\r
#\r
def Rel(self):\r
Ret = self.Expr()\r
if self.IsCurrentOp(["<=", ">=", ">", "<", "GT", "LT", "GE", "LE",\r
"==", "EQ", "!=", "NE"]):\r
- if Ret == self.STRINGITEM or Ret == self.REALLOGICAL:\r
+ if Ret == self.STRINGITEM:\r
raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
Ret = self.Expr()\r
- if Ret == self.STRINGITEM or Ret == self.REALLOGICAL:\r
+ if Ret == self.REALLOGICAL:\r
raise _ExprError(ST.ERR_EXPR_LOGICAL % self.Token)\r
Ret = self.REALLOGICAL\r
return Ret\r
#\r
def Expr(self):\r
Ret = self.Factor()\r
- while self.IsCurrentOp(["+", "-", "&", "|", "^"]):\r
+ while self.IsCurrentOp(["+", "-", "&", "|", "^", "XOR", "xor"]):\r
if self.Token[self.Index-1] == '|' and self.Parens <= 0:\r
raise _ExprError(ST.ERR_EXPR_OR)\r
if Ret == self.STRINGITEM or Ret == self.REALLOGICAL:\r
return self.ARITH\r
else:\r
raise _ExprError(ST.ERR_EXPR_FACTOR % \\r
- (self.Token, self.Token[self.Index:]))\r
+ (self.Token[self.Index:], self.Token))\r
\r
## IsValidLogicalExpression\r
#\r
def IsValidLogicalExpression(self):\r
if self.Len == 0:\r
- return False, ST.ERR_EXPR_EMPTY\r
+ return False, ST.ERR_EXPRESS_EMPTY\r
try:\r
- if self.LogicalExpression() == self.ARITH:\r
+ if self.LogicalExpression() not in [self.ARITH, self.LOGICAL, self.REALLOGICAL, self.STRINGITEM]:\r
return False, ST.ERR_EXPR_LOGICAL % self.Token\r
except _ExprError, XExcept:\r
return False, XExcept.Error\r
'[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+'\r
def __init__(self, Token):\r
_ExprBase.__init__(self, Token)\r
+ self.Parens = 0\r
+ self.HEX = 1\r
+ self.INT = 2\r
+ self.IsParenHappen = False\r
+ self.IsLogicalOpHappen = False\r
\r
## IsValidRangeExpression\r
#\r
def IsValidRangeExpression(self):\r
if self.Len == 0:\r
- return False\r
+ return False, ST.ERR_EXPR_RANGE_EMPTY\r
try:\r
- self.RangeExpression()\r
- except _ExprError:\r
- return False\r
+ if self.RangeExpression() not in [self.HEX, self.INT]:\r
+ return False, ST.ERR_EXPR_RANGE % self.Token\r
+ except _ExprError, XExcept:\r
+ return False, XExcept.Error\r
+ \r
self.SkipWhitespace()\r
if self.Index != self.Len:\r
- return False\r
- return True\r
+ return False, (ST.ERR_EXPR_RANGE % self.Token)\r
+ return True, ''\r
\r
## RangeExpression\r
#\r
def RangeExpression(self):\r
- self.Unary()\r
- while self.IsCurrentOp(['OR', 'AND', 'XOR']):\r
- self.Unary()\r
+ Ret = self.Unary()\r
+ while self.IsCurrentOp(['OR', 'AND', 'and', 'or']):\r
+ self.IsLogicalOpHappen = True\r
+ if not self.IsParenHappen:\r
+ raise _ExprError(ST.ERR_PAREN_NOT_USED % self.Token)\r
+ self.IsParenHappen = False\r
+ Ret = self.Unary()\r
+ \r
+ if self.IsCurrentOp(['XOR']):\r
+ Ret = self.Unary()\r
+ \r
+ return Ret\r
\r
## Unary\r
#\r
def Unary(self):\r
- if self.IsCurrentOp(["NOT", "-"]):\r
+ if self.IsCurrentOp(["NOT"]):\r
return self.Unary()\r
+ \r
return self.ValidRange()\r
\r
## ValidRange\r
# \r
def ValidRange(self):\r
+ Ret = -1\r
if self.IsCurrentOp(["("]):\r
- self.RangeExpression()\r
+ self.IsLogicalOpHappen = False\r
+ self.IsParenHappen = True\r
+ self.Parens += 1\r
+ if self.Parens > 1:\r
+ raise _ExprError(ST.ERR_EXPR_RANGE_DOUBLE_PAREN_NESTED % self.Token)\r
+ Ret = self.RangeExpression()\r
if not self.IsCurrentOp([")"]):\r
- raise _ExprError('')\r
- return\r
+ raise _ExprError(ST.ERR_EXPR_RIGHT_PAREN % self.Token)\r
+ self.Parens -= 1\r
+ return Ret\r
+ \r
+ if self.IsLogicalOpHappen:\r
+ raise _ExprError(ST.ERR_PAREN_NOT_USED % self.Token)\r
\r
- if self.IsCurrentOp(["LT", "GT", "LE", "GE", "EQ"]):\r
+ if self.IsCurrentOp(["LT", "GT", "LE", "GE", "EQ", "XOR"]):\r
IntMatch = \\r
re.compile(self.INT_PATTERN).match(self.Token[self.Index:])\r
HexMatch = \\r
re.compile(self.HEX_PATTERN).match(self.Token[self.Index:])\r
if HexMatch and HexMatch.start() == 0:\r
self.Index += HexMatch.end()\r
+ Ret = self.HEX\r
elif IntMatch and IntMatch.start() == 0:\r
self.Index += IntMatch.end()\r
+ Ret = self.INT\r
else:\r
- raise _ExprError('')\r
+ raise _ExprError(ST.ERR_EXPR_RANGE_FACTOR % (self.Token[self.Index:], self.Token))\r
else:\r
IntRangeMatch = re.compile(\r
self.INT_RANGE_PATTERN).match(self.Token[self.Index:]\r
)\r
if HexRangeMatch and HexRangeMatch.start() == 0:\r
self.Index += HexRangeMatch.end()\r
+ Ret = self.HEX\r
elif IntRangeMatch and IntRangeMatch.start() == 0:\r
self.Index += IntRangeMatch.end()\r
+ Ret = self.INT\r
else:\r
- raise _ExprError('')\r
+ raise _ExprError(ST.ERR_EXPR_RANGE % self.Token)\r
+\r
+ return Ret\r
+\r
+## _ValidListExpressionParser\r
+#\r
+class _ValidListExpressionParser(_ExprBase):\r
+ VALID_LIST_PATTERN = '(0[xX][0-9a-fA-F]+|[0-9]+)([\t\s]*,[\t\s]*(0[xX][0-9a-fA-F]+|[0-9]+))*'\r
+ def __init__(self, Token):\r
+ _ExprBase.__init__(self, Token)\r
+ self.NUM = 1\r
\r
- if self.Token[self.Index:self.Index+1] == '_' or \\r
- self.Token[self.Index:self.Index+1].isalnum():\r
- raise _ExprError('')\r
+ def IsValidListExpression(self):\r
+ if self.Len == 0:\r
+ return False, ST.ERR_EXPR_LIST_EMPTY\r
+ try:\r
+ if self.ListExpression() not in [self.NUM]:\r
+ return False, ST.ERR_EXPR_LIST % self.Token\r
+ except _ExprError, XExcept:\r
+ return False, XExcept.Error\r
\r
+ self.SkipWhitespace()\r
+ if self.Index != self.Len:\r
+ return False, (ST.ERR_EXPR_LIST % self.Token)\r
+\r
+ return True, ''\r
+ \r
+ def ListExpression(self):\r
+ Ret = -1\r
+ self.SkipWhitespace()\r
+ ListMatch = re.compile(self.VALID_LIST_PATTERN).match(self.Token[self.Index:])\r
+ if ListMatch and ListMatch.start() == 0:\r
+ self.Index += ListMatch.end()\r
+ Ret = self.NUM\r
+ else:\r
+ raise _ExprError(ST.ERR_EXPR_LIST % self.Token)\r
+\r
+ return Ret\r
+ \r
## _StringTestParser\r
#\r
class _StringTestParser(_ExprBase):\r
self.StringItem()\r
if not self.IsCurrentOp(["==", "EQ", "!=", "NE"]):\r
raise _ExprError(ST.ERR_EXPR_EQUALITY % \\r
- (self.Token, self.Token[self.Index:]))\r
+ (self.Token[self.Index:], self.Token))\r
self.StringItem()\r
if self.Index != self.Len:\r
raise _ExprError(ST.ERR_EXPR_BOOLEAN % \\r
(self.Token[self.Index:], self.Token))\r
\r
##\r
-# Check syntax of logical expression\r
+# Check syntax of string test\r
#\r
-# @param Token: expression token\r
+# @param Token: string test token\r
#\r
-def IsValidLogicalExpr(Token, Flag=False):\r
+def IsValidStringTest(Token, Flag=False):\r
#\r
# Not do the check right now, keep the implementation for future enhancement.\r
#\r
if not Flag:\r
return True, ""\r
- return _LogicalExpressionParser(Token).IsValidLogicalExpression()\r
+ return _StringTestParser(Token).IsValidStringTest()\r
+\r
\r
##\r
-# Check syntax of string test\r
+# Check syntax of logical expression\r
#\r
-# @param Token: string test token\r
+# @param Token: expression token\r
#\r
-def IsValidStringTest(Token, Flag=False):\r
+def IsValidLogicalExpr(Token, Flag=False):\r
#\r
# Not do the check right now, keep the implementation for future enhancement.\r
#\r
if not Flag:\r
return True, ""\r
- return _StringTestParser(Token).IsValidStringTest()\r
+ return _LogicalExpressionParser(Token).IsValidLogicalExpression()\r
\r
##\r
# Check syntax of range expression\r
def IsValidRangeExpr(Token):\r
return _ValidRangeExpressionParser(Token).IsValidRangeExpression()\r
\r
+##\r
+# Check syntax of value list expression token\r
+#\r
+# @param Token: value list expression token \r
+#\r
+def IsValidListExpr(Token):\r
+ return _ValidListExpressionParser(Token).IsValidListExpression()\r
+\r
##\r
# Check whether the feature flag expression is valid or not\r
#\r
return True, ""\r
\r
if __name__ == '__main__':\r
- print _LogicalExpressionParser('a ^ b > a + b').IsValidLogicalExpression()\r
+# print IsValidRangeExpr('LT 9')\r
+ print _LogicalExpressionParser('gCrownBayTokenSpaceGuid.PcdPciDevice1BridgeAddressLE0').IsValidLogicalExpression()\r
+\r
+\r
+ \r
## @file\r
# This file is used to define common static strings and global data used by UPT\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
# Flag used to mark whether the INF file is Binary INF or not.\r
#\r
gIS_BINARY_INF = False\r
+\r
+#\r
+# Used by FileHook module.\r
+#\r
+gRECOVERMGR = None\r
+\r
+#\r
+# Used by PCD parser\r
+#\r
+gPackageDict = {}\r
+\r
#\r
# Used by Library instance parser\r
# {FilePath: FileObj}\r
## @file\r
# Common routines used by all tools\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.DataType import SUP_MODULE_LIST\r
from Library.DataType import END_OF_LINE\r
from Library.DataType import TAB_SPLIT\r
-from Library.DataType import LANGUAGE_EN_US\r
+from Library.DataType import TAB_LANGUAGE_EN_US\r
+from Library.DataType import TAB_LANGUAGE_EN\r
+from Library.DataType import TAB_LANGUAGE_EN_X\r
+from Library.DataType import TAB_UNI_FILE_SUFFIXS\r
from Library.String import GetSplitValueList\r
from Library.ParserValidate import IsValidHexVersion\r
from Library.ParserValidate import IsValidPath\r
from Object.POM.CommonObject import TextObject\r
+from Core.FileHook import __FileHookOpen__\r
\r
## Convert GUID string in xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx style to C \r
# structure style\r
\r
if os.path.exists(File):\r
try:\r
- if Content == open(File, "rb").read():\r
+ if Content == __FileHookOpen__(File, "rb").read():\r
return False\r
except BaseException:\r
Logger.Error(None, ToolError.FILE_OPEN_FAILURE, ExtraData=File)\r
\r
CreateDirectory(os.path.dirname(File))\r
try:\r
- FileFd = open(File, "wb")\r
+ FileFd = __FileHookOpen__(File, "wb")\r
FileFd.write(Content)\r
FileFd.close()\r
except BaseException:\r
for Item in SkipList:\r
if Item in Dirs:\r
Dirs.remove(Item)\r
+ if Item in Files:\r
+ Files.remove(Item)\r
for Dir in Dirs:\r
if Dir.startswith('.'):\r
Dirs.remove(Dir)\r
\r
Key = property(_GetFileKey)\r
\r
-## Check environment variables\r
+## Get current workspace\r
#\r
-# Check environment variables that must be set for build. Currently they are\r
+# get WORKSPACE from environment variable if present,if not use current working directory as WORKSPACE\r
#\r
-# WORKSPACE The directory all packages/platforms start from\r
-# EDK_TOOLS_PATH The directory contains all tools needed by the build\r
-# PATH $(EDK_TOOLS_PATH)/Bin/<sys> must be set in PATH\r
-#\r
-# If any of above environment variable is not set or has error, the build\r
-# will be broken.\r
-#\r
-def CheckEnvVariable():\r
+def GetWorkspace():\r
#\r
# check WORKSPACE\r
#\r
- if "WORKSPACE" not in environ:\r
- Logger.Error("UPT",\r
- ToolError.UPT_ENVIRON_MISSING_ERROR,\r
- ST.ERR_NOT_FOUND_ENVIRONMENT,\r
- ExtraData="WORKSPACE")\r
-\r
- WorkspaceDir = os.path.normpath(environ["WORKSPACE"])\r
- if not os.path.exists(WorkspaceDir):\r
- Logger.Error("UPT",\r
- ToolError.UPT_ENVIRON_MISSING_ERROR,\r
- ST.ERR_WORKSPACE_NOTEXIST,\r
- ExtraData="%s" % WorkspaceDir)\r
- elif ' ' in WorkspaceDir:\r
- Logger.Error("UPT",\r
- ToolError.FORMAT_NOT_SUPPORTED,\r
- ST.ERR_SPACE_NOTALLOWED,\r
- ExtraData=WorkspaceDir)\r
+ if "WORKSPACE" in environ:\r
+ WorkspaceDir = os.path.normpath(environ["WORKSPACE"])\r
+ if not os.path.exists(WorkspaceDir):\r
+ Logger.Error("UPT",\r
+ ToolError.UPT_ENVIRON_MISSING_ERROR,\r
+ ST.ERR_WORKSPACE_NOTEXIST,\r
+ ExtraData="%s" % WorkspaceDir)\r
+ else:\r
+ WorkspaceDir = os.getcwd()\r
\r
+ if WorkspaceDir[-1] == ':':\r
+ WorkspaceDir += os.sep\r
+ return WorkspaceDir\r
+\r
+## Get relative path\r
+#\r
+# use full path and workspace to get relative path\r
+# the destination of this function is mainly to resolve the root path issue(like c: or c:\) \r
+#\r
+# @param Fullpath: a string of fullpath\r
+# @param Workspace: a string of workspace\r
+#\r
+def GetRelativePath(Fullpath, Workspace):\r
+ \r
+ RelativePath = ''\r
+ if Workspace.endswith(os.sep):\r
+ RelativePath = Fullpath[Fullpath.upper().find(Workspace.upper())+len(Workspace):]\r
+ else:\r
+ RelativePath = Fullpath[Fullpath.upper().find(Workspace.upper())+len(Workspace)+1:]\r
+ \r
+ return RelativePath\r
+ \r
## Check whether all module types are in list\r
#\r
# check whether all module types (SUP_MODULE_LIST) are in list\r
#\r
def GenDummyHelpTextObj():\r
HelpTxt = TextObject()\r
- HelpTxt.SetLang(LANGUAGE_EN_US)\r
+ HelpTxt.SetLang(TAB_LANGUAGE_EN_US)\r
HelpTxt.SetString(' ')\r
return HelpTxt\r
\r
VerString = GetSplitValueList(VerString, '=', 1)[1]\r
\r
return FileGuidString, VerString\r
+\r
+## GetLocalValue\r
+#\r
+# Generate the local value for INF and DEC file. If Lang attribute not present, then use this value.\r
+# If present, and there is no element without the Lang attribute, and one of the elements has the rfc1766 code is \r
+# "en-x-tianocore", or "en-US" if "en-x-tianocore" was not found, or "en" if "en-US" was not found, or startswith 'en' \r
+# if 'en' was not found, then use this value.\r
+# If multiple entries of a tag exist which have the same language code, use the last entry.\r
+#\r
+# @param ValueList A list need to be processed.\r
+# @param UseFirstValue: True to use the first value, False to use the last value \r
+#\r
+# @return LocalValue\r
+def GetLocalValue(ValueList, UseFirstValue=False):\r
+ Value1 = ''\r
+ Value2 = ''\r
+ Value3 = ''\r
+ Value4 = ''\r
+ Value5 = ''\r
+ for (Key, Value) in ValueList:\r
+ if Key == TAB_LANGUAGE_EN_X:\r
+ if UseFirstValue:\r
+ if not Value1:\r
+ Value1 = Value\r
+ else:\r
+ Value1 = Value\r
+ if Key == TAB_LANGUAGE_EN_US:\r
+ if UseFirstValue:\r
+ if not Value2:\r
+ Value2 = Value\r
+ else:\r
+ Value2 = Value\r
+ if Key == TAB_LANGUAGE_EN:\r
+ if UseFirstValue:\r
+ if not Value3:\r
+ Value3 = Value\r
+ else:\r
+ Value3 = Value\r
+ if Key.startswith(TAB_LANGUAGE_EN):\r
+ if UseFirstValue:\r
+ if not Value4:\r
+ Value4 = Value\r
+ else:\r
+ Value4 = Value\r
+ if Key == '':\r
+ if UseFirstValue:\r
+ if not Value5:\r
+ Value5 = Value\r
+ else:\r
+ Value5 = Value\r
+ \r
+ if Value1:\r
+ return Value1\r
+ if Value2:\r
+ return Value2\r
+ if Value3:\r
+ return Value3\r
+ if Value4:\r
+ return Value4\r
+ if Value5:\r
+ return Value5\r
+ \r
+ return ''\r
+\r
+\r
+## GetCharIndexOutStr\r
+#\r
+# Get comment character index outside a string\r
+#\r
+# @param Line: The string to be checked\r
+# @param CommentCharacter: Comment char, used to ignore comment content\r
+#\r
+# @retval Index\r
+#\r
+def GetCharIndexOutStr(CommentCharacter, Line):\r
+ #\r
+ # remove whitespace\r
+ #\r
+ Line = Line.strip()\r
+\r
+ #\r
+ # Check whether comment character is in a string\r
+ #\r
+ InString = False\r
+ for Index in range(0, len(Line)):\r
+ if Line[Index] == '"':\r
+ InString = not InString\r
+ elif Line[Index] == CommentCharacter and InString :\r
+ pass\r
+ elif Line[Index] == CommentCharacter and (Index +1) < len(Line) and Line[Index+1] == CommentCharacter \\r
+ and not InString :\r
+ return Index\r
+ return -1\r
+\r
+## ValidateUNIFilePath\r
+#\r
+# Check the UNI file path\r
+#\r
+# @param FilePath: The UNI file path \r
+#\r
+def ValidateUNIFilePath(Path):\r
+ Suffix = Path[Path.rfind(TAB_SPLIT):]\r
+ \r
+ #\r
+ # Check if the suffix is one of the '.uni', '.UNI', '.Uni' \r
+ #\r
+ if Suffix not in TAB_UNI_FILE_SUFFIXS:\r
+ Logger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID, \r
+ Message=ST.ERR_UNI_FILE_SUFFIX_WRONG, \r
+ ExtraData=Path) \r
+ \r
+ #\r
+ # Check if '..' in the file name(without suffixe)\r
+ #\r
+ if (TAB_SPLIT + TAB_SPLIT) in Path:\r
+ Logger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID, \r
+ Message=ST.ERR_UNI_FILE_NAME_INVALID, \r
+ ExtraData=Path) \r
+ \r
+ #\r
+ # Check if the file name is valid according to the DEC and INF specification\r
+ #\r
+ Pattern = '[a-zA-Z0-9_][a-zA-Z0-9_\-\.]*'\r
+ FileName = Path.replace(Suffix, '')\r
+ InvalidCh = re.sub(Pattern, '', FileName)\r
+ if InvalidCh:\r
+ Logger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID, \r
+ Message=ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID, \r
+ ExtraData=Path) \r
+\r
## @file ParserValidate.py\r
+# Functions for parser validation\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
for Char in PcdValue:\r
if Char == '\n' or Char == '\t' or Char == '\f':\r
return False\r
- \r
+ \r
#\r
# <Boolean>\r
#\r
if IsValidHex(PcdValue):\r
return True\r
\r
- ReIsValidIntegerSingle = re.compile(r"^\s*[0-9]\s*$", re.DOTALL) \r
+ ReIsValidIntegerSingle = re.compile(r"^\s*[0-9]\s*$", re.DOTALL)\r
if ReIsValidIntegerSingle.match(PcdValue) != None:\r
return True\r
\r
if ReIsValidIntegerMulti.match(PcdValue) != None:\r
return True\r
\r
- \r
#\r
# <StringVal> ::= {<StringType>} {<Array>} {"$(" <MACRO> ")"}\r
# <StringType> ::= {<UnicodeString>} {<CString>}\r
# This file is used to define common parsing related functions used in parsing \r
# INF/DEC/DSC process\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
import Logger.Log as Logger\r
\r
from Parser.DecParser import Dec\r
+import GlobalData\r
\r
gPKG_INFO_DICT = {}\r
\r
# @param String: String with BuildOption statement\r
# @param File: The file which defines build option, used in error report\r
#\r
-def GetBuildOption(String, File, LineNo=-1):\r
+def GetBuildOption(String, File, LineNo= -1):\r
(Family, ToolChain, Flag) = ('', '', '')\r
if String.find(DataType.TAB_EQUAL_SPLIT) < 0:\r
RaiseParserError(String, 'BuildOptions', File, \\r
# @param ContainerFile: The file which describes the library class, used for \r
# error report\r
#\r
-def GetLibraryClass(Item, ContainerFile, WorkspaceDir, LineNo=-1):\r
+def GetLibraryClass(Item, ContainerFile, WorkspaceDir, LineNo= -1):\r
List = GetSplitValueList(Item[0])\r
SupMod = DataType.SUP_MODULE_LIST_STRING\r
if len(List) != 2:\r
# @param ContainerFile: The file which describes the library class, used for \r
# error report\r
#\r
-def GetLibraryClassOfInf(Item, ContainerFile, WorkspaceDir, LineNo = -1):\r
+def GetLibraryClassOfInf(Item, ContainerFile, WorkspaceDir, LineNo= -1):\r
ItemList = GetSplitValueList((Item[0] + DataType.TAB_VALUE_SPLIT * 2))\r
SupMod = DataType.SUP_MODULE_LIST_STRING\r
\r
# @param Section: Used for error report\r
# @param File: Used for error report\r
#\r
-def CheckPcdTokenInfo(TokenInfoString, Section, File, LineNo=-1):\r
+def CheckPcdTokenInfo(TokenInfoString, Section, File, LineNo= -1):\r
Format = '<TokenSpaceGuidCName>.<PcdCName>'\r
if TokenInfoString != '' and TokenInfoString != None:\r
TokenInfoList = GetSplitValueList(TokenInfoString, DataType.TAB_SPLIT)\r
# report\r
\r
#\r
-def GetPcd(Item, Type, ContainerFile, LineNo=-1):\r
+def GetPcd(Item, Type, ContainerFile, LineNo= -1):\r
TokenGuid, TokenName, Value, MaximumDatumSize, Token = '', '', '', '', ''\r
List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT * 2)\r
\r
# @param ContainerFile: The file which describes the pcd, used for error \r
# report\r
#\r
-def GetFeatureFlagPcd(Item, Type, ContainerFile, LineNo=-1):\r
+def GetFeatureFlagPcd(Item, Type, ContainerFile, LineNo= -1):\r
TokenGuid, TokenName, Value = '', '', ''\r
List = GetSplitValueList(Item)\r
if len(List) != 2:\r
# @param ContainerFile: The file which describes the pcd, used for error \r
# report\r
#\r
-def GetDynamicDefaultPcd(Item, Type, ContainerFile, LineNo=-1):\r
+def GetDynamicDefaultPcd(Item, Type, ContainerFile, LineNo= -1):\r
TokenGuid, TokenName, Value, DatumTyp, MaxDatumSize = '', '', '', '', ''\r
List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT * 2)\r
if len(List) < 4 or len(List) > 8:\r
# @param ContainerFile: The file which describes the pcd, used for error \r
# report\r
#\r
-def GetDynamicHiiPcd(Item, Type, ContainerFile, LineNo = -1):\r
+def GetDynamicHiiPcd(Item, Type, ContainerFile, LineNo= -1):\r
TokenGuid, TokenName, List1, List2, List3, List4, List5 = \\r
'', '', '', '', '', '', ''\r
List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT * 2)\r
# @param ContainerFile: The file which describes the pcd, used for error \r
# report\r
#\r
-def GetDynamicVpdPcd(Item, Type, ContainerFile, LineNo=-1):\r
+def GetDynamicVpdPcd(Item, Type, ContainerFile, LineNo= -1):\r
TokenGuid, TokenName, List1, List2 = '', '', '', ''\r
List = GetSplitValueList(Item + DataType.TAB_VALUE_SPLIT)\r
if len(List) < 3 or len(List) > 4:\r
# @param ContainerFile: The file which describes the library class, used \r
# for error report\r
#\r
-def GetSource(Item, ContainerFile, FileRelativePath, LineNo=-1):\r
+def GetSource(Item, ContainerFile, FileRelativePath, LineNo= -1):\r
ItemNew = Item + DataType.TAB_VALUE_SPLIT * 4\r
List = GetSplitValueList(ItemNew)\r
if len(List) < 5 or len(List) > 9:\r
# @param ContainerFile: The file which describes the library class, \r
# used for error report\r
#\r
-def GetBinary(Item, ContainerFile, LineNo=-1):\r
+def GetBinary(Item, ContainerFile, LineNo= -1):\r
ItemNew = Item + DataType.TAB_VALUE_SPLIT\r
List = GetSplitValueList(ItemNew)\r
if len(List) < 3 or len(List) > 5:\r
# @param ContainerFile: The file which describes the library class, \r
# used for error report\r
#\r
-def GetGuidsProtocolsPpisOfDec(Item, Type, ContainerFile, LineNo=-1):\r
+def GetGuidsProtocolsPpisOfDec(Item, Type, ContainerFile, LineNo= -1):\r
List = GetSplitValueList(Item, DataType.TAB_EQUAL_SPLIT)\r
if len(List) != 2:\r
RaiseParserError(Item, Type, ContainerFile, '<CName>=<GuidValue>', \\r
RegisterFormatGuid = List[1]\r
else:\r
RaiseParserError(Item, Type, ContainerFile, \\r
- 'CFormat or RegisterFormat', LineNo) \r
+ 'CFormat or RegisterFormat', LineNo)\r
\r
return (List[0], RegisterFormatGuid)\r
\r
# @param ContainerFile: The file which describes the library class, \r
# used for error report\r
#\r
-def GetPackage(Item, ContainerFile, FileRelativePath, LineNo=-1):\r
+def GetPackage(Item, ContainerFile, FileRelativePath, LineNo= -1):\r
ItemNew = Item + DataType.TAB_VALUE_SPLIT\r
List = GetSplitValueList(ItemNew)\r
CheckFileType(List[0], '.Dec', ContainerFile, 'package', List[0], LineNo)\r
# @param File: Dec file\r
# @param LineNo: Line number\r
#\r
-def GetPcdOfDec(Item, Type, File, LineNo=-1):\r
+def GetPcdOfDec(Item, Type, File, LineNo= -1):\r
Format = '<TokenSpaceGuidCName>.<PcdCName>|<Value>|<DatumType>|<Token>'\r
TokenGuid, TokenName, Value, DatumType, Token = '', '', '', '', ''\r
List = GetSplitValueList(Item)\r
LineValue, StartLine, Comment = SectionItem[0], \\r
SectionItem[1], SectionItem[2]\r
\r
- Logger.Debug(4, ST.MSG_PARSING %LineValue)\r
+ Logger.Debug(4, ST.MSG_PARSING % LineValue)\r
#\r
# And then parse DEFINE statement\r
#\r
List[Key] = [Value]\r
else:\r
List[Key].append(Value)\r
- \r
+\r
## GetPkgInfoFromDec\r
#\r
# get package name, guid, version info from dec files\r
PkgName = None\r
PkgGuid = None\r
PkgVersion = None\r
- \r
+\r
Path = Path.replace('\\', '/')\r
- \r
+\r
if not os.path.exists(Path):\r
- Logger.Error("\nUPT", FILE_NOT_FOUND, File = Path) \r
+ Logger.Error("\nUPT", FILE_NOT_FOUND, File=Path)\r
\r
if Path in gPKG_INFO_DICT:\r
return gPKG_INFO_DICT[Path]\r
\r
try:\r
- DecParser = Dec(Path)\r
+ DecParser = None\r
+ if Path not in GlobalData.gPackageDict:\r
+ DecParser = Dec(Path)\r
+ GlobalData.gPackageDict[Path] = DecParser\r
+ else:\r
+ DecParser = GlobalData.gPackageDict[Path]\r
+\r
PkgName = DecParser.GetPackageName()\r
PkgGuid = DecParser.GetPackageGuid()\r
PkgVersion = DecParser.GetPackageVersion()\r
#\r
def GetWorkspacePackage():\r
DecFileList = []\r
- WorkspaceDir = os.environ["WORKSPACE"]\r
+ WorkspaceDir = GlobalData.gWORKSPACE\r
for Root, Dirs, Files in os.walk(WorkspaceDir):\r
if 'CVS' in Dirs:\r
Dirs.remove('CVS')\r
(PkgName, PkgGuid, PkgVersion) = GetPkgInfoFromDec(DecFile)\r
if PkgName and PkgGuid and PkgVersion:\r
PkgList.append((PkgName, PkgGuid, PkgVersion, DecFile))\r
- \r
+\r
return PkgList\r
\r
## GetWorkspaceModule\r
#\r
def GetWorkspaceModule():\r
InfFileList = []\r
- WorkspaceDir = os.environ["WORKSPACE"]\r
+ WorkspaceDir = GlobalData.gWORKSPACE\r
for Root, Dirs, Files in os.walk(WorkspaceDir):\r
if 'CVS' in Dirs:\r
Dirs.remove('CVS')\r
if Ext.lower() in ['.inf']:\r
InfFileList.append\\r
(os.path.normpath(os.path.join(Root, FileSp)))\r
- \r
+\r
return InfFileList\r
\r
## MacroParser used to parse macro definition\r
# Not 'DEFINE/EDK_GLOBAL' statement, call decorated method\r
#\r
return None, None\r
- \r
+\r
TokenList = GetSplitValueList(LineContent[Match.end(1):], \\r
DataType.TAB_EQUAL_SPLIT, 1)\r
#\r
#\r
if SectionType == DataType.MODEL_META_DATA_HEADER:\r
FileLocalMacros[Name] = Value\r
- \r
+\r
ReIsValidMacroName = re.compile(r"^[A-Z][A-Z0-9_]*$", re.DOTALL)\r
if ReIsValidMacroName.match(Name) == None:\r
- Logger.Error('Parser', \r
- FORMAT_INVALID, \r
- ST.ERR_MACRONAME_INVALID%(Name),\r
- ExtraData=LineContent, \r
- File=FileName, \r
+ Logger.Error('Parser',\r
+ FORMAT_INVALID,\r
+ ST.ERR_MACRONAME_INVALID % (Name),\r
+ ExtraData=LineContent,\r
+ File=FileName,\r
Line=LineNo)\r
- \r
+\r
# Validate MACRO Value\r
#\r
# <MacroDefinition> ::= [<Comments>]{0,}\r
#\r
ReIsValidMacroValue = re.compile(r"^[\x20-\x7e]*$", re.DOTALL)\r
if ReIsValidMacroValue.match(Value) == None:\r
- Logger.Error('Parser', \r
- FORMAT_INVALID, \r
- ST.ERR_MACROVALUE_INVALID%(Value),\r
- ExtraData=LineContent, \r
- File=FileName, \r
+ Logger.Error('Parser',\r
+ FORMAT_INVALID,\r
+ ST.ERR_MACROVALUE_INVALID % (Value),\r
+ ExtraData=LineContent,\r
+ File=FileName,\r
Line=LineNo)\r
- \r
+\r
return Name, Value\r
\r
## GenSection \r
# seperated by space, \r
# value is statement\r
#\r
-def GenSection(SectionName, SectionDict, SplitArch=True):\r
+def GenSection(SectionName, SectionDict, SplitArch=True, NeedBlankLine=False):\r
Content = ''\r
for SectionAttrs in SectionDict:\r
StatementList = SectionDict[SectionAttrs]\r
Section = '[' + SectionName + '.' + (', ' + SectionName + '.').join(ArchList) + ']'\r
else:\r
Section = '[' + SectionName + ']'\r
- Content += '\n\n' + Section + '\n'\r
+ Content += '\n' + Section + '\n'\r
if StatementList != None:\r
for Statement in StatementList:\r
- Content += Statement + '\n'\r
+ LineList = Statement.split('\n')\r
+ NewStatement = ""\r
+ for Line in LineList:\r
+ # ignore blank comment\r
+ if not Line.replace("#", '').strip() and SectionName != 'Defines':\r
+ continue\r
+ # add two space before non-comments line except the comments in Defines section\r
+ if Line.strip().startswith('#') and SectionName == 'Defines':\r
+ NewStatement += "%s\n" % Line\r
+ continue\r
+ NewStatement += " %s\n" % Line\r
+ if NeedBlankLine:\r
+ Content += NewStatement + '\n'\r
+ else:\r
+ Content += NewStatement\r
\r
+ if NeedBlankLine:\r
+ Content = Content[:-1]\r
+ if not Content.replace('\\n', '').strip():\r
+ return ''\r
return Content\r
\r
## ConvertArchForInstall\r
# @return: the arch string that get converted\r
#\r
def ConvertArchForInstall(Arch):\r
- if Arch.upper() in [DataType.TAB_ARCH_IA32, DataType.TAB_ARCH_X64, \r
+ if Arch.upper() in [DataType.TAB_ARCH_IA32, DataType.TAB_ARCH_X64,\r
DataType.TAB_ARCH_IPF, DataType.TAB_ARCH_EBC]:\r
Arch = Arch.upper()\r
elif Arch.upper() == DataType.TAB_ARCH_COMMON:\r
Arch = Arch.lower()\r
- \r
+\r
return Arch\r
## @file\r
-# This file is used to define common string related functions used in parsing \r
+# This file is used to define common string related functions used in parsing\r
# process\r
#\r
# Copyright (c) 2011 - 2014, 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
+# 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
# @param MaxSplit: The max number of split values, default is -1\r
#\r
#\r
-def GetSplitValueList(String, SplitTag=DataType.TAB_VALUE_SPLIT, MaxSplit=-1):\r
+def GetSplitValueList(String, SplitTag=DataType.TAB_VALUE_SPLIT, MaxSplit= -1):\r
return map(lambda l: l.strip(), String.split(SplitTag, MaxSplit))\r
\r
## MergeArches\r
## SplitModuleType\r
#\r
# Split ModuleType out of section defien to get key\r
-# [LibraryClass.Arch.ModuleType|ModuleType|ModuleType] -> [ \r
+# [LibraryClass.Arch.ModuleType|ModuleType|ModuleType] -> [\r
# 'LibraryClass.Arch', ['ModuleType', 'ModuleType', 'ModuleType'] ]\r
#\r
# @param Key: String to be parsed\r
# @param Line: The content contain line string and line number\r
# @param FileName: The meta-file file name\r
#\r
-def ReplaceMacro(String, MacroDefinitions = None, SelfReplacement = False, Line = None, FileName = None, Flag = False):\r
+def ReplaceMacro(String, MacroDefinitions=None, SelfReplacement=False, Line=None, FileName=None, Flag=False):\r
LastString = String\r
if MacroDefinitions == None:\r
MacroDefinitions = {}\r
Count += 1\r
if Count % 2 != 0:\r
MacroString += QuotedStringItem\r
- \r
- if Count == len(QuotedStringList) and Count%2 == 0:\r
+\r
+ if Count == len(QuotedStringList) and Count % 2 == 0:\r
MacroString += QuotedStringItem\r
- \r
+\r
MacroUsed = gMACRO_PATTERN.findall(MacroString)\r
#\r
# no macro found in String, stop replacing\r
if Macro not in MacroDefinitions:\r
if SelfReplacement:\r
String = String.replace("$(%s)" % Macro, '')\r
- Logger.Debug(5, "Delete undefined MACROs in file %s line %d: %s!" %(FileName, Line[1], Line[0]))\r
+ Logger.Debug(5, "Delete undefined MACROs in file %s line %d: %s!" % (FileName, Line[1], Line[0]))\r
continue\r
if not HaveQuotedMacroFlag:\r
String = String.replace("$(%s)" % Macro, MacroDefinitions[Macro])\r
for QuotedStringItem in QuotedStringList:\r
Count += 1\r
if Count % 2 != 0:\r
- QuotedStringList[Count-1] = QuotedStringList[Count-1].replace("$(%s)" % Macro, \r
+ QuotedStringList[Count - 1] = QuotedStringList[Count - 1].replace("$(%s)" % Macro,\r
MacroDefinitions[Macro])\r
- elif Count == len(QuotedStringList) and Count%2 == 0:\r
- QuotedStringList[Count-1] = QuotedStringList[Count-1].replace("$(%s)" % Macro,\r
+ elif Count == len(QuotedStringList) and Count % 2 == 0:\r
+ QuotedStringList[Count - 1] = QuotedStringList[Count - 1].replace("$(%s)" % Macro,\r
MacroDefinitions[Macro])\r
- \r
+\r
RetString = ''\r
if HaveQuotedMacroFlag:\r
Count = 0\r
for QuotedStringItem in QuotedStringList:\r
- Count += 1 \r
+ Count += 1\r
if Count != len(QuotedStringList):\r
- RetString += QuotedStringList[Count-1] + "\""\r
+ RetString += QuotedStringList[Count - 1] + "\""\r
else:\r
- RetString += QuotedStringList[Count-1]\r
- \r
+ RetString += QuotedStringList[Count - 1]\r
+\r
String = RetString\r
- \r
- # \r
+\r
+ #\r
# in case there's macro not defined\r
#\r
if String == LastString:\r
# @param Path: The input value for Path to be converted\r
# @param Defines: A set for DEFINE statement\r
#\r
-def NormPath(Path, Defines = None):\r
+def NormPath(Path, Defines=None):\r
IsRelativePath = False\r
if Defines == None:\r
Defines = {}\r
# Remove spaces\r
#\r
# @param Line: The string to be cleaned\r
-# @param CommentCharacter: Comment char, used to ignore comment content, \r
+# @param CommentCharacter: Comment char, used to ignore comment content,\r
# default is DataType.TAB_COMMENT_SPLIT\r
#\r
def CleanString(Line, CommentCharacter=DataType.TAB_COMMENT_SPLIT, AllowCppStyleComment=False):\r
# Remove spaces\r
#\r
# @param Line: The string to be cleaned\r
-# @param CommentCharacter: Comment char, used to ignore comment content, \r
+# @param CommentCharacter: Comment char, used to ignore comment content,\r
# default is DataType.TAB_COMMENT_SPLIT\r
#\r
def CleanString2(Line, CommentCharacter=DataType.TAB_COMMENT_SPLIT, AllowCppStyleComment=False):\r
# @param CommentCharacter: Comment char, be used to ignore comment content\r
# @param KeySplitCharacter: Key split char, between key name and key value.\r
# Key1 = Value1, '=' is the key split char\r
-# @param ValueSplitFlag: Value split flag, be used to decide if has \r
+# @param ValueSplitFlag: Value split flag, be used to decide if has\r
# multiple values\r
-# @param ValueSplitCharacter: Value split char, be used to split multiple \r
-# values. Key1 = Value1|Value2, '|' is the value \r
+# @param ValueSplitCharacter: Value split char, be used to split multiple\r
+# values. Key1 = Value1|Value2, '|' is the value\r
# split char\r
#\r
def GetSingleValueOfKeyFromLines(Lines, Dictionary, CommentCharacter, KeySplitCharacter, \\r
#\r
if Line.find('$') > -1:\r
if Line.find('$(') < 0 or Line.find(')') < 0:\r
- Logger.Error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError = Logger.IS_RAISE_ERROR)\r
+ Logger.Error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError=Logger.IS_RAISE_ERROR)\r
#\r
# Check []\r
#\r
# Only get one '[' or one ']'\r
#\r
if not (Line.find('[') > -1 and Line.find(']') > -1):\r
- Logger.Error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError = Logger.IS_RAISE_ERROR)\r
+ Logger.Error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError=Logger.IS_RAISE_ERROR)\r
#\r
# Regenerate FileContent\r
#\r
NewFileContent = NewFileContent + Line + '\r\n'\r
\r
if IsFailed:\r
- Logger.Error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError = Logger.IS_RAISE_ERROR)\r
+ Logger.Error("Parser", FORMAT_INVALID, Line=LineNo, File=FileName, RaiseError=Logger.IS_RAISE_ERROR)\r
\r
return NewFileContent\r
\r
# @param Line: The line in container file which defines the file\r
# to be checked\r
#\r
-def CheckFileType(CheckFilename, ExtName, ContainerFilename, SectionName, Line, LineNo=-1):\r
+def CheckFileType(CheckFilename, ExtName, ContainerFilename, SectionName, Line, LineNo= -1):\r
if CheckFilename != '' and CheckFilename != None:\r
(Root, Ext) = os.path.splitext(CheckFilename)\r
if Ext.upper() != ExtName.upper() and Root:\r
#\r
# @param CheckFilename: Name of the file to be checked\r
# @param WorkspaceDir: Current workspace dir\r
-# @param ContainerFilename: The container file which describes the file to \r
+# @param ContainerFilename: The container file which describes the file to\r
# be checked, used for error report\r
# @param SectionName: Used for error report\r
-# @param Line: The line in container file which defines the \r
+# @param Line: The line in container file which defines the\r
# file to be checked\r
#\r
-def CheckFileExist(WorkspaceDir, CheckFilename, ContainerFilename, SectionName, Line, LineNo=-1):\r
+def CheckFileExist(WorkspaceDir, CheckFilename, ContainerFilename, SectionName, Line, LineNo= -1):\r
CheckFile = ''\r
if CheckFilename != '' and CheckFilename != None:\r
CheckFile = WorkspaceFile(WorkspaceDir, CheckFilename)\r
LineNo = GetLineNo(ContainerFile, Line)\r
ErrorMsg = ST.ERR_CHECKFILE_NOTFOUND % (CheckFile, SectionName)\r
Logger.Error("Parser", PARSER_ERROR, ErrorMsg,\r
- File=ContainerFilename, Line = LineNo, RaiseError=Logger.IS_RAISE_ERROR)\r
+ File=ContainerFilename, Line=LineNo, RaiseError=Logger.IS_RAISE_ERROR)\r
return CheckFile\r
\r
## GetLineNo\r
# @param File: File which has the string\r
# @param Format: Correct format\r
#\r
-def RaiseParserError(Line, Section, File, Format='', LineNo=-1):\r
+def RaiseParserError(Line, Section, File, Format='', LineNo= -1):\r
if LineNo == -1:\r
LineNo = GetLineNo(open(os.path.normpath(File), 'r').read(), Line)\r
ErrorMsg = ST.ERR_INVALID_NOTFOUND % (Line, Section)\r
# @param Lines: string list\r
# @param Split: split character\r
#\r
-def GetStringOfList(List, Split = ' '):\r
+def GetStringOfList(List, Split=' '):\r
if type(List) != type([]):\r
return List\r
Str = ''\r
# @param OptionString: the option string\r
# @param Which: Which flag\r
# @param Against: Against flag\r
-# \r
+#\r
def RemoveDupOption(OptionString, Which="/I", Against=None):\r
OptionList = OptionString.split()\r
ValueList = []\r
\r
## Check if the string is HexDgit\r
#\r
-# Return true if all characters in the string are digits and there is at \r
-# least one character \r
+# Return true if all characters in the string are digits and there is at\r
+# least one character\r
# or valid Hexs (started with 0x, following by hexdigit letters)\r
-# , false otherwise. \r
+# , false otherwise.\r
# @param string: input string\r
#\r
def IsHexDigit(Str):\r
- try: \r
+ try:\r
int(Str, 10)\r
return True\r
except ValueError:\r
return False\r
return False\r
\r
-## Check if the string is HexDgit and its integer value within limit of UINT32 \r
+## Check if the string is HexDgit and its interger value within limit of UINT32\r
#\r
-# Return true if all characters in the string are digits and there is at \r
-# least one character \r
+# Return true if all characters in the string are digits and there is at\r
+# least one character\r
# or valid Hexs (started with 0x, following by hexdigit letters)\r
-# , false otherwise. \r
+# , false otherwise.\r
# @param string: input string\r
#\r
def IsHexDigitUINT32(Str):\r
- try: \r
+ try:\r
Value = int(Str, 10)\r
if (Value <= 0xFFFFFFFF) and (Value >= 0):\r
return True\r
return False\r
\r
## CleanSpecialChar\r
-# \r
-# The ASCII text files of type INF, DEC, INI are edited by developers, \r
+#\r
+# The ASCII text files of type INF, DEC, INI are edited by developers,\r
# and may contain characters that cannot be directly translated to strings that\r
-# are conformant with the UDP XML Schema. Any characters in this category \r
-# (0x00-0x08, TAB [0x09], 0x0B, 0x0C, 0x0E-0x1F, 0x80-0xFF) \r
+# are conformant with the UDP XML Schema. Any characters in this category\r
+# (0x00-0x08, TAB [0x09], 0x0B, 0x0C, 0x0E-0x1F, 0x80-0xFF)\r
# must be converted to a space character[0x20] as part of the parsing process.\r
#\r
def ConvertSpecialChar(Lines):\r
for line in Lines:\r
ReMatchSpecialChar = re.compile(r"[\x00-\x08]|\x09|\x0b|\x0c|[\x0e-\x1f]|[\x7f-\xff]")\r
RetLines.append(ReMatchSpecialChar.sub(' ', line))\r
- \r
+\r
return RetLines\r
\r
## __GetTokenList\r
if TokenOP:\r
List.append(TokenOP)\r
TokenOP = ''\r
- \r
+\r
if PreChar == '\\' and Char == '\\':\r
PreChar = ''\r
else:\r
return ''.join(RetList)\r
\r
## SplitPcdEntry\r
-# \r
+#\r
# Split an PCD entry string to Token.CName and PCD value and FFE.\r
# NOTE: PCD Value and FFE can contain "|" in it's expression. And in INF specification, have below rule.\r
-# When using the characters "|" or "||" in an expression, the expression must be encapsulated in \r
+# When using the characters "|" or "||" in an expression, the expression must be encapsulated in\r
# open "(" and close ")" parenthesis.\r
-# \r
+#\r
# @param String An PCD entry string need to be split.\r
-# \r
-# @return List [PcdTokenCName, Value, FFE] \r
+#\r
+# @return List [PcdTokenCName, Value, FFE]\r
#\r
def SplitPcdEntry(String):\r
if not String:\r
- return ['', '',''], False\r
- \r
+ return ['', '', ''], False\r
+\r
PcdTokenCName = ''\r
PcdValue = ''\r
PcdFeatureFlagExp = ''\r
- \r
+\r
ValueList = GetSplitValueList(String, "|", 1)\r
- \r
+\r
#\r
# Only contain TokenCName\r
#\r
if len(ValueList) == 1:\r
return [ValueList[0]], True\r
- \r
+\r
NewValueList = []\r
- \r
+\r
if len(ValueList) == 2:\r
PcdTokenCName = ValueList[0]\r
- ValueList = GetSplitValueList(ValueList[1], "|")\r
- \r
- RemainCount = 0\r
- for Item in ValueList:\r
- ParenthesisCount = 0\r
- for Char in Item:\r
- if Char == "(":\r
- ParenthesisCount += 1\r
- if Char == ")":\r
- ParenthesisCount -= 1\r
- \r
- #\r
- # An individual item\r
- #\r
- if RemainCount == 0 and ParenthesisCount >= 0:\r
- NewValueList.append(Item)\r
- RemainCount = ParenthesisCount\r
- elif RemainCount > 0 and RemainCount + ParenthesisCount >= 0:\r
- NewValueList[-1] = NewValueList[-1] + '|' + Item \r
- RemainCount = RemainCount + ParenthesisCount\r
- elif RemainCount > 0 and RemainCount + ParenthesisCount < 0:\r
- #\r
- # ERROR, return\r
- #\r
- return ['', '', ''], False\r
+\r
+ InQuote = False\r
+ InParenthesis = False\r
+ StrItem = ''\r
+ for StrCh in ValueList[1]:\r
+ if StrCh == '"':\r
+ InQuote = not InQuote\r
+ elif StrCh == '(' or StrCh == ')':\r
+ InParenthesis = not InParenthesis\r
+\r
+ if StrCh == '|':\r
+ if not InQuote or not InParenthesis:\r
+ NewValueList.append(StrItem.strip())\r
+ StrItem = ' '\r
+ continue\r
+\r
+ StrItem += StrCh\r
+\r
+ NewValueList.append(StrItem.strip())\r
\r
if len(NewValueList) == 1:\r
PcdValue = NewValueList[0]\r
return [PcdTokenCName, PcdValue, PcdFeatureFlagExp], True\r
else:\r
return ['', '', ''], False\r
- \r
+\r
return ['', '', ''], False\r
\r
## Check if two arches matched?\r
--- /dev/null
+## @file\r
+# Collect all defined strings in multiple uni files.\r
+#\r
+# Copyright (c) 2014, 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
+Collect all defined strings in multiple uni files\r
+"""\r
+\r
+##\r
+# Import Modules\r
+#\r
+import os, codecs, re\r
+import distutils.util\r
+from Logger import ToolError\r
+from Logger import Log as EdkLogger\r
+from Logger import StringTable as ST\r
+from Library.String import GetLineNo\r
+from Library.Misc import PathClass\r
+from Library.Misc import GetCharIndexOutStr\r
+from Library import DataType as DT\r
+\r
+##\r
+# Static definitions\r
+#\r
+UNICODE_WIDE_CHAR = u'\\wide'\r
+UNICODE_NARROW_CHAR = u'\\narrow'\r
+UNICODE_NON_BREAKING_CHAR = u'\\nbr'\r
+UNICODE_UNICODE_CR = '\r'\r
+UNICODE_UNICODE_LF = '\n'\r
+\r
+NARROW_CHAR = u'\uFFF0'\r
+WIDE_CHAR = u'\uFFF1'\r
+NON_BREAKING_CHAR = u'\uFFF2'\r
+CR = u'\u000D'\r
+LF = u'\u000A'\r
+NULL = u'\u0000'\r
+TAB = u'\t'\r
+BACK_SPLASH = u'\\'\r
+\r
+gINCLUDE_PATTERN = re.compile("^!include[\s]+([\S]+)[\s]*$", re.MULTILINE | re.UNICODE)\r
+\r
+gLANG_CONV_TABLE = {'eng':'en', 'fra':'fr', \\r
+ 'aar':'aa', 'abk':'ab', 'ave':'ae', 'afr':'af', 'aka':'ak', 'amh':'am', \\r
+ 'arg':'an', 'ara':'ar', 'asm':'as', 'ava':'av', 'aym':'ay', 'aze':'az', \\r
+ 'bak':'ba', 'bel':'be', 'bul':'bg', 'bih':'bh', 'bis':'bi', 'bam':'bm', \\r
+ 'ben':'bn', 'bod':'bo', 'bre':'br', 'bos':'bs', 'cat':'ca', 'che':'ce', \\r
+ 'cha':'ch', 'cos':'co', 'cre':'cr', 'ces':'cs', 'chu':'cu', 'chv':'cv', \\r
+ 'cym':'cy', 'dan':'da', 'deu':'de', 'div':'dv', 'dzo':'dz', 'ewe':'ee', \\r
+ 'ell':'el', 'epo':'eo', 'spa':'es', 'est':'et', 'eus':'eu', 'fas':'fa', \\r
+ 'ful':'ff', 'fin':'fi', 'fij':'fj', 'fao':'fo', 'fry':'fy', 'gle':'ga', \\r
+ 'gla':'gd', 'glg':'gl', 'grn':'gn', 'guj':'gu', 'glv':'gv', 'hau':'ha', \\r
+ 'heb':'he', 'hin':'hi', 'hmo':'ho', 'hrv':'hr', 'hat':'ht', 'hun':'hu', \\r
+ 'hye':'hy', 'her':'hz', 'ina':'ia', 'ind':'id', 'ile':'ie', 'ibo':'ig', \\r
+ 'iii':'ii', 'ipk':'ik', 'ido':'io', 'isl':'is', 'ita':'it', 'iku':'iu', \\r
+ 'jpn':'ja', 'jav':'jv', 'kat':'ka', 'kon':'kg', 'kik':'ki', 'kua':'kj', \\r
+ 'kaz':'kk', 'kal':'kl', 'khm':'km', 'kan':'kn', 'kor':'ko', 'kau':'kr', \\r
+ 'kas':'ks', 'kur':'ku', 'kom':'kv', 'cor':'kw', 'kir':'ky', 'lat':'la', \\r
+ 'ltz':'lb', 'lug':'lg', 'lim':'li', 'lin':'ln', 'lao':'lo', 'lit':'lt', \\r
+ 'lub':'lu', 'lav':'lv', 'mlg':'mg', 'mah':'mh', 'mri':'mi', 'mkd':'mk', \\r
+ 'mal':'ml', 'mon':'mn', 'mar':'mr', 'msa':'ms', 'mlt':'mt', 'mya':'my', \\r
+ 'nau':'na', 'nob':'nb', 'nde':'nd', 'nep':'ne', 'ndo':'ng', 'nld':'nl', \\r
+ 'nno':'nn', 'nor':'no', 'nbl':'nr', 'nav':'nv', 'nya':'ny', 'oci':'oc', \\r
+ 'oji':'oj', 'orm':'om', 'ori':'or', 'oss':'os', 'pan':'pa', 'pli':'pi', \\r
+ 'pol':'pl', 'pus':'ps', 'por':'pt', 'que':'qu', 'roh':'rm', 'run':'rn', \\r
+ 'ron':'ro', 'rus':'ru', 'kin':'rw', 'san':'sa', 'srd':'sc', 'snd':'sd', \\r
+ 'sme':'se', 'sag':'sg', 'sin':'si', 'slk':'sk', 'slv':'sl', 'smo':'sm', \\r
+ 'sna':'sn', 'som':'so', 'sqi':'sq', 'srp':'sr', 'ssw':'ss', 'sot':'st', \\r
+ 'sun':'su', 'swe':'sv', 'swa':'sw', 'tam':'ta', 'tel':'te', 'tgk':'tg', \\r
+ 'tha':'th', 'tir':'ti', 'tuk':'tk', 'tgl':'tl', 'tsn':'tn', 'ton':'to', \\r
+ 'tur':'tr', 'tso':'ts', 'tat':'tt', 'twi':'tw', 'tah':'ty', 'uig':'ug', \\r
+ 'ukr':'uk', 'urd':'ur', 'uzb':'uz', 'ven':'ve', 'vie':'vi', 'vol':'vo', \\r
+ 'wln':'wa', 'wol':'wo', 'xho':'xh', 'yid':'yi', 'yor':'yo', 'zha':'za', \\r
+ 'zho':'zh', 'zul':'zu'}\r
+\r
+## Convert a python unicode string to a normal string\r
+#\r
+# Convert a python unicode string to a normal string\r
+# UniToStr(u'I am a string') is 'I am a string'\r
+#\r
+# @param Uni: The python unicode string\r
+#\r
+# @retval: The formatted normal string\r
+#\r
+def UniToStr(Uni):\r
+ return repr(Uni)[2:-1]\r
+\r
+## Convert a unicode string to a Hex list\r
+#\r
+# Convert a unicode string to a Hex list\r
+# UniToHexList('ABC') is ['0x41', '0x00', '0x42', '0x00', '0x43', '0x00']\r
+#\r
+# @param Uni: The python unicode string\r
+#\r
+# @retval List: The formatted hex list\r
+#\r
+def UniToHexList(Uni):\r
+ List = []\r
+ for Item in Uni:\r
+ Temp = '%04X' % ord(Item)\r
+ List.append('0x' + Temp[2:4])\r
+ List.append('0x' + Temp[0:2])\r
+ return List\r
+\r
+## Convert special unicode characters\r
+#\r
+# Convert special characters to (c), (r) and (tm).\r
+#\r
+# @param Uni: The python unicode string\r
+#\r
+# @retval NewUni: The converted unicode string\r
+#\r
+def ConvertSpecialUnicodes(Uni):\r
+ NewUni = Uni\r
+ NewUni = NewUni.replace(u'\u00A9', '(c)')\r
+ NewUni = NewUni.replace(u'\u00AE', '(r)')\r
+ NewUni = NewUni.replace(u'\u2122', '(tm)')\r
+ return NewUni\r
+\r
+## GetLanguageCode1766\r
+#\r
+# Check the language code read from .UNI file and convert RFC 4646 codes to RFC 1766 codes\r
+# RFC 1766 language codes supported in compatiblity mode\r
+# RFC 4646 language codes supported in native mode\r
+#\r
+# @param LangName: Language codes read from .UNI file\r
+#\r
+# @retval LangName: Valid lanugage code in RFC 1766 format or None\r
+#\r
+def GetLanguageCode1766(LangName, File=None):\r
+ length = len(LangName)\r
+ if length == 2:\r
+ if LangName.isalpha():\r
+ for Key in gLANG_CONV_TABLE.keys():\r
+ if gLANG_CONV_TABLE.get(Key) == LangName.lower():\r
+ return Key\r
+ elif length == 3:\r
+ if LangName.isalpha() and gLANG_CONV_TABLE.get(LangName.lower()):\r
+ return LangName\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID,\r
+ "Invalid RFC 1766 language code : %s" % LangName, \r
+ File)\r
+ elif length == 5:\r
+ if LangName[0:2].isalpha() and LangName[2] == '-':\r
+ for Key in gLANG_CONV_TABLE.keys():\r
+ if gLANG_CONV_TABLE.get(Key) == LangName[0:2].lower():\r
+ return Key\r
+ elif length >= 6:\r
+ if LangName[0:2].isalpha() and LangName[2] == '-':\r
+ for Key in gLANG_CONV_TABLE.keys():\r
+ if gLANG_CONV_TABLE.get(Key) == LangName[0:2].lower():\r
+ return Key\r
+ if LangName[0:3].isalpha() and gLANG_CONV_TABLE.get(LangName.lower()) == None and LangName[3] == '-':\r
+ for Key in gLANG_CONV_TABLE.keys():\r
+ if Key == LangName[0:3].lower():\r
+ return Key\r
+\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID,\r
+ "Invalid RFC 4646 language code : %s" % LangName, \r
+ File)\r
+ \r
+## GetLanguageCode\r
+#\r
+# Check the language code read from .UNI file and convert RFC 1766 codes to RFC 4646 codes if appropriate\r
+# RFC 1766 language codes supported in compatiblity mode\r
+# RFC 4646 language codes supported in native mode\r
+#\r
+# @param LangName: Language codes read from .UNI file\r
+#\r
+# @retval LangName: Valid lanugage code in RFC 4646 format or None\r
+#\r
+def GetLanguageCode(LangName, IsCompatibleMode, File):\r
+ length = len(LangName)\r
+ if IsCompatibleMode:\r
+ if length == 3 and LangName.isalpha():\r
+ TempLangName = gLANG_CONV_TABLE.get(LangName.lower())\r
+ if TempLangName != None:\r
+ return TempLangName\r
+ return LangName\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID,\r
+ "Invalid RFC 1766 language code : %s" % LangName, \r
+ File)\r
+ if (LangName[0] == 'X' or LangName[0] == 'x') and LangName[1] == '-':\r
+ return LangName\r
+ if length == 2:\r
+ if LangName.isalpha():\r
+ return LangName\r
+ elif length == 3:\r
+ if LangName.isalpha() and gLANG_CONV_TABLE.get(LangName.lower()) == None:\r
+ return LangName\r
+ elif length == 5:\r
+ if LangName[0:2].isalpha() and LangName[2] == '-':\r
+ return LangName\r
+ elif length >= 6:\r
+ if LangName[0:2].isalpha() and LangName[2] == '-':\r
+ return LangName\r
+ if LangName[0:3].isalpha() and gLANG_CONV_TABLE.get(LangName.lower()) == None and LangName[3] == '-':\r
+ return LangName\r
+\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID,\r
+ "Invalid RFC 4646 language code : %s" % LangName, \r
+ File)\r
+\r
+## FormatUniEntry\r
+#\r
+# Formated the entry in Uni file.\r
+#\r
+# @param StrTokenName StrTokenName.\r
+# @param TokenValueList A list need to be processed.\r
+# @param ContainerFile ContainerFile.\r
+#\r
+# @return formated entry\r
+def FormatUniEntry(StrTokenName, TokenValueList, ContainerFile):\r
+ SubContent = ''\r
+ PreFormatLength = 40\r
+ if len(StrTokenName) > PreFormatLength:\r
+ PreFormatLength = len(StrTokenName) + 1\r
+ for (Lang, Value) in TokenValueList: \r
+ if not Value or Lang == DT.TAB_LANGUAGE_EN_X:\r
+ continue\r
+ if Lang == '':\r
+ Lang = DT.TAB_LANGUAGE_EN_US\r
+ if Lang == 'eng':\r
+ Lang = DT.TAB_LANGUAGE_EN_US\r
+ elif len(Lang.split('-')[0]) == 3:\r
+ Lang = GetLanguageCode(Lang.split('-')[0], True, ContainerFile)\r
+ else:\r
+ Lang = GetLanguageCode(Lang, False, ContainerFile)\r
+ ValueList = Value.split('\n')\r
+ SubValueContent = ''\r
+ for SubValue in ValueList:\r
+ if SubValue.strip():\r
+ SubValueContent += \\r
+ ' ' * (PreFormatLength + len('#language en-US ')) + '\"%s\\n\"' % SubValue.strip() + os.linesep\r
+ SubValueContent = SubValueContent[(PreFormatLength + len('#language en-US ')):SubValueContent.rfind('\\n')] \\r
+ + '\"' + os.linesep\r
+ SubContent += ' '*PreFormatLength + '#language %-5s ' % Lang + SubValueContent\r
+ if SubContent:\r
+ SubContent = StrTokenName + ' '*(PreFormatLength - len(StrTokenName)) + SubContent[PreFormatLength:]\r
+ return SubContent\r
+\r
+\r
+## StringDefClassObject\r
+#\r
+# A structure for language definition\r
+#\r
+class StringDefClassObject(object):\r
+ def __init__(self, Name = None, Value = None, Referenced = False, Token = None, UseOtherLangDef = ''):\r
+ self.StringName = ''\r
+ self.StringNameByteList = []\r
+ self.StringValue = ''\r
+ self.StringValueByteList = ''\r
+ self.Token = 0\r
+ self.Referenced = Referenced\r
+ self.UseOtherLangDef = UseOtherLangDef\r
+ self.Length = 0\r
+\r
+ if Name != None:\r
+ self.StringName = Name\r
+ self.StringNameByteList = UniToHexList(Name)\r
+ if Value != None:\r
+ self.StringValue = Value\r
+ self.StringValueByteList = UniToHexList(self.StringValue)\r
+ self.Length = len(self.StringValueByteList)\r
+ if Token != None:\r
+ self.Token = Token\r
+\r
+ def __str__(self):\r
+ return repr(self.StringName) + ' ' + \\r
+ repr(self.Token) + ' ' + \\r
+ repr(self.Referenced) + ' ' + \\r
+ repr(self.StringValue) + ' ' + \\r
+ repr(self.UseOtherLangDef)\r
+\r
+ def UpdateValue(self, Value = None):\r
+ if Value != None:\r
+ if self.StringValue:\r
+ self.StringValue = self.StringValue + os.linesep + Value\r
+ else:\r
+ self.StringValue = Value\r
+ self.StringValueByteList = UniToHexList(self.StringValue)\r
+ self.Length = len(self.StringValueByteList)\r
+\r
+## UniFileClassObject\r
+#\r
+# A structure for .uni file definition\r
+#\r
+class UniFileClassObject(object):\r
+ def __init__(self, FileList = None, IsCompatibleMode = False, IncludePathList = None):\r
+ self.FileList = FileList\r
+ self.File = None\r
+ self.IncFileList = FileList\r
+ self.UniFileHeader = ''\r
+ self.Token = 2\r
+ self.LanguageDef = [] #[ [u'LanguageIdentifier', u'PrintableName'], ... ]\r
+ self.OrderedStringList = {} #{ u'LanguageIdentifier' : [StringDefClassObject] }\r
+ self.OrderedStringDict = {} #{ u'LanguageIdentifier' : {StringName:(IndexInList)} }\r
+ self.OrderedStringListByToken = {} #{ u'LanguageIdentifier' : {Token: StringDefClassObject} }\r
+ self.IsCompatibleMode = IsCompatibleMode\r
+ if not IncludePathList:\r
+ self.IncludePathList = []\r
+ else:\r
+ self.IncludePathList = IncludePathList\r
+ if len(self.FileList) > 0:\r
+ self.LoadUniFiles(FileList)\r
+\r
+ #\r
+ # Get Language definition\r
+ #\r
+ def GetLangDef(self, File, Line):\r
+ Lang = distutils.util.split_quoted((Line.split(u"//")[0]))\r
+ if len(Lang) != 3:\r
+ try:\r
+ FileIn = codecs.open(File.Path, mode='rb', encoding='utf_16').read()\r
+ except UnicodeError, Xstr:\r
+ FileIn = codecs.open(File.Path, mode='rb', encoding='utf_16_le').read()\r
+ except:\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FILE_OPEN_FAILURE, \r
+ "File read failure: %s" % str(Xstr),\r
+ ExtraData=File)\r
+ LineNo = GetLineNo(FileIn, Line, False)\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.PARSER_ERROR,\r
+ "Wrong language definition", \r
+ ExtraData="""%s\n\t*Correct format is like '#langdef en-US "English"'""" % Line, \r
+ File = File, Line = LineNo)\r
+ else:\r
+ LangName = GetLanguageCode(Lang[1], self.IsCompatibleMode, self.File)\r
+ LangPrintName = Lang[2]\r
+\r
+ IsLangInDef = False\r
+ for Item in self.LanguageDef:\r
+ if Item[0] == LangName:\r
+ IsLangInDef = True\r
+ break\r
+\r
+ if not IsLangInDef:\r
+ self.LanguageDef.append([LangName, LangPrintName])\r
+\r
+ #\r
+ # Add language string\r
+ #\r
+ self.AddStringToList(u'$LANGUAGE_NAME', LangName, LangName, 0, True, Index=0)\r
+ self.AddStringToList(u'$PRINTABLE_LANGUAGE_NAME', LangName, LangPrintName, 1, True, Index=1)\r
+\r
+ if not IsLangInDef:\r
+ #\r
+ # The found STRING tokens will be added into new language string list\r
+ # so that the unique STRING identifier is reserved for all languages in the package list. \r
+ #\r
+ FirstLangName = self.LanguageDef[0][0]\r
+ if LangName != FirstLangName:\r
+ for Index in range (2, len (self.OrderedStringList[FirstLangName])):\r
+ Item = self.OrderedStringList[FirstLangName][Index]\r
+ if Item.UseOtherLangDef != '':\r
+ OtherLang = Item.UseOtherLangDef\r
+ else:\r
+ OtherLang = FirstLangName\r
+ self.OrderedStringList[LangName].append (StringDefClassObject(Item.StringName, \r
+ '', \r
+ Item.Referenced, \r
+ Item.Token, \r
+ OtherLang))\r
+ self.OrderedStringDict[LangName][Item.StringName] = len(self.OrderedStringList[LangName]) - 1\r
+ return True\r
+\r
+ #\r
+ # Get String name and value\r
+ #\r
+ def GetStringObject(self, Item):\r
+ Language = ''\r
+ Value = ''\r
+\r
+ Name = Item.split()[1]\r
+ # Check the string name is the upper character\r
+ if Name != '':\r
+ MatchString = re.match('[A-Z0-9_]+', Name, re.UNICODE)\r
+ if MatchString == None or MatchString.end(0) != len(Name):\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FORMAT_INVALID,\r
+ 'The string token name %s in UNI file %s must be upper case character.' %(Name, self.File))\r
+ LanguageList = Item.split(u'#language ')\r
+ for IndexI in range(len(LanguageList)):\r
+ if IndexI == 0:\r
+ continue\r
+ else:\r
+ Language = LanguageList[IndexI].split()[0]\r
+ #.replace(u'\r\n', u'')\r
+ Value = \\r
+ LanguageList[IndexI][LanguageList[IndexI].find(u'\"') + len(u'\"') : LanguageList[IndexI].rfind(u'\"')] \r
+ Language = GetLanguageCode(Language, self.IsCompatibleMode, self.File)\r
+ self.AddStringToList(Name, Language, Value)\r
+\r
+ #\r
+ # Get include file list and load them\r
+ #\r
+ def GetIncludeFile(self, Item, Dir = None):\r
+ if Dir:\r
+ pass\r
+ FileName = Item[Item.find(u'!include ') + len(u'!include ') :Item.find(u' ', len(u'!include '))][1:-1]\r
+ self.LoadUniFile(FileName)\r
+\r
+ #\r
+ # Pre-process before parse .uni file\r
+ #\r
+ def PreProcess(self, File, IsIncludeFile=False):\r
+ if not os.path.exists(File.Path) or not os.path.isfile(File.Path):\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FILE_NOT_FOUND,\r
+ ExtraData=File.Path)\r
+\r
+ try:\r
+ FileIn = codecs.open(File.Path, mode='rb', encoding='utf_16').readlines()\r
+ except UnicodeError:\r
+ FileIn = codecs.open(File.Path, mode='rb', encoding='utf_16_le').readlines()\r
+ except:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FILE_OPEN_FAILURE, ExtraData=File.Path)\r
+ \r
+ \r
+ #\r
+ # get the file header\r
+ #\r
+ Lines = []\r
+ HeaderStart = False\r
+ HeaderEnd = False\r
+ if not self.UniFileHeader:\r
+ FirstGenHeader = True\r
+ else:\r
+ FirstGenHeader = False\r
+ for Line in FileIn:\r
+ Line = Line.strip()\r
+ if Line == u'':\r
+ continue\r
+ if Line.startswith(DT.TAB_COMMENT_EDK1_SPLIT) and (Line.find(DT.TAB_HEADER_COMMENT) > -1) \\r
+ and not HeaderEnd and not HeaderStart:\r
+ HeaderStart = True\r
+ if not Line.startswith(DT.TAB_COMMENT_EDK1_SPLIT) and HeaderStart and not HeaderEnd:\r
+ HeaderEnd = True\r
+ if Line.startswith(DT.TAB_COMMENT_EDK1_SPLIT) and HeaderStart and not HeaderEnd and FirstGenHeader:\r
+ self.UniFileHeader += Line + os.linesep\r
+ continue\r
+ \r
+ #\r
+ # Use unique identifier\r
+ #\r
+ FindFlag = -1\r
+ LineCount = 0\r
+ MultiLineFeedExits = False\r
+ #\r
+ # 0: initial value\r
+ # 1: signle String entry exist\r
+ # 2: line feed exist under the some signle String entry\r
+ #\r
+ StringEntryExistsFlag = 0\r
+ for Line in FileIn:\r
+ Line = FileIn[LineCount]\r
+ LineCount += 1\r
+ Line = Line.strip()\r
+ #\r
+ # Ignore comment line and empty line\r
+ # \r
+ if Line == u'' or Line.startswith(u'//'):\r
+ #\r
+ # Change the single line String entry flag status\r
+ #\r
+ if StringEntryExistsFlag == 1:\r
+ StringEntryExistsFlag = 2\r
+ #\r
+ # If the '#string' line and the '#language' line are not in the same line,\r
+ # there should be only one line feed character betwwen them\r
+ #\r
+ if MultiLineFeedExits:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ continue\r
+\r
+ MultiLineFeedExits = False\r
+ #\r
+ # Process comment embeded in string define lines\r
+ #\r
+ FindFlag = Line.find(u'//')\r
+ if FindFlag != -1 and Line.find(u'//') < Line.find(u'"'):\r
+ Line = Line.replace(Line[FindFlag:], u' ')\r
+ if FileIn[LineCount].strip().startswith('#language'):\r
+ Line = Line + FileIn[LineCount]\r
+ FileIn[LineCount-1] = Line\r
+ FileIn[LineCount] = os.linesep\r
+ LineCount -= 1\r
+ for Index in xrange (LineCount + 1, len (FileIn) - 1):\r
+ if (Index == len(FileIn) -1):\r
+ FileIn[Index] = os.linesep\r
+ else:\r
+ FileIn[Index] = FileIn[Index + 1]\r
+ continue\r
+ CommIndex = GetCharIndexOutStr(u'/', Line)\r
+ if CommIndex > -1:\r
+ if (len(Line) - 1) > CommIndex:\r
+ if Line[CommIndex+1] == u'/':\r
+ Line = Line[:CommIndex].strip()\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ \r
+ Line = Line.replace(UNICODE_WIDE_CHAR, WIDE_CHAR)\r
+ Line = Line.replace(UNICODE_NARROW_CHAR, NARROW_CHAR)\r
+ Line = Line.replace(UNICODE_NON_BREAKING_CHAR, NON_BREAKING_CHAR)\r
+\r
+ Line = Line.replace(u'\\\\', u'\u0006')\r
+ Line = Line.replace(u'\\r\\n', CR + LF)\r
+ Line = Line.replace(u'\\n', CR + LF)\r
+ Line = Line.replace(u'\\r', CR)\r
+ Line = Line.replace(u'\\t', u'\t')\r
+ Line = Line.replace(u'''\"''', u'''"''')\r
+ Line = Line.replace(u'\t', u' ')\r
+ Line = Line.replace(u'\u0006', u'\\')\r
+\r
+ IncList = gINCLUDE_PATTERN.findall(Line)\r
+ if len(IncList) == 1:\r
+ for Dir in [File.Dir] + self.IncludePathList:\r
+ IncFile = PathClass(str(IncList[0]), Dir)\r
+ self.IncFileList.append(IncFile)\r
+ if os.path.isfile(IncFile.Path):\r
+ Lines.extend(self.PreProcess(IncFile, True))\r
+ break\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FILE_NOT_FOUND, \r
+ Message="Cannot find include file", \r
+ ExtraData=str(IncList[0]))\r
+ continue\r
+ \r
+ #\r
+ # Between Name entry and Language entry can not contain line feed\r
+ #\r
+ if Line.startswith(u'#string') and Line.find(u'#language') == -1:\r
+ MultiLineFeedExits = True\r
+ \r
+ if Line.startswith(u'#string') and Line.find(u'#language') > 0 and Line.find(u'"') < 0:\r
+ MultiLineFeedExits = True\r
+ \r
+ #\r
+ # Between Language entry and String entry can not contain line feed\r
+ #\r
+ if Line.startswith(u'#language') and len(Line.split()) == 2:\r
+ MultiLineFeedExits = True\r
+ \r
+ #\r
+ # Between two String entry, can not contain line feed\r
+ #\r
+ if Line.startswith(u'"'):\r
+ if StringEntryExistsFlag == 2:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \r
+ Message=ST.ERR_UNIPARSE_LINEFEED_UP_EXIST % Line, ExtraData=File.Path)\r
+ \r
+ StringEntryExistsFlag = 1\r
+ if not Line.endswith('"'):\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ elif Line.startswith(u'#language'):\r
+ if StringEntryExistsFlag == 2:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \r
+ Message=ST.ERR_UNIPARSE_LINEFEED_UP_EXIST % Line, ExtraData=File.Path)\r
+ StringEntryExistsFlag = 0\r
+ else:\r
+ StringEntryExistsFlag = 0\r
+\r
+ Lines.append(Line)\r
+ \r
+ #\r
+ # Convert string def format as below\r
+ #\r
+ # #string MY_STRING_1\r
+ # #language eng\r
+ # "My first English string line 1"\r
+ # "My first English string line 2"\r
+ # #string MY_STRING_1\r
+ # #language spa\r
+ # "Mi segunda secuencia 1"\r
+ # "Mi segunda secuencia 2"\r
+ #\r
+ \r
+ if not IsIncludeFile and not Lines:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_NO_SECTION_EXIST, \\r
+ ExtraData=File.Path) \r
+\r
+ NewLines = []\r
+ StrName = u''\r
+ ExistStrNameList = []\r
+ for Line in Lines:\r
+ if StrName and not StrName.split()[1].startswith(DT.TAB_STR_TOKENCNAME + DT.TAB_UNDERLINE_SPLIT):\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_STRNAME_FORMAT_ERROR % StrName.split()[1], \\r
+ ExtraData=File.Path)\r
+ \r
+ if StrName and len(StrName.split()[1].split(DT.TAB_UNDERLINE_SPLIT)) == 4:\r
+ StringTokenList = StrName.split()[1].split(DT.TAB_UNDERLINE_SPLIT)\r
+ if (StringTokenList[3].upper() in [DT.TAB_STR_TOKENPROMPT, DT.TAB_STR_TOKENHELP] and \\r
+ StringTokenList[3] not in [DT.TAB_STR_TOKENPROMPT, DT.TAB_STR_TOKENHELP]) or \\r
+ (StringTokenList[2].upper() == DT.TAB_STR_TOKENERR and StringTokenList[2] != DT.TAB_STR_TOKENERR):\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_STRTOKEN_FORMAT_ERROR % StrName.split()[1], \\r
+ ExtraData=File.Path)\r
+ \r
+ if Line.count(u'#language') > 1:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_SEP_LANGENTRY_LINE % Line, \\r
+ ExtraData=File.Path) \r
+ \r
+ if Line.startswith(u'//'):\r
+ continue\r
+ elif Line.startswith(u'#langdef'):\r
+ if len(Line.split()) == 2:\r
+ NewLines.append(Line)\r
+ continue\r
+ elif len(Line.split()) > 2 and Line.find(u'"') > 0: \r
+ NewLines.append(Line[:Line.find(u'"')].strip())\r
+ NewLines.append(Line[Line.find(u'"'):])\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ elif Line.startswith(u'#string'):\r
+ if len(Line.split()) == 2:\r
+ StrName = Line\r
+ if StrName:\r
+ if StrName.split()[1] not in ExistStrNameList:\r
+ ExistStrNameList.append(StrName.split()[1].strip())\r
+ elif StrName.split()[1] in [DT.TAB_INF_ABSTRACT, DT.TAB_INF_DESCRIPTION, \\r
+ DT.TAB_INF_BINARY_ABSTRACT, DT.TAB_INF_BINARY_DESCRIPTION, \\r
+ DT.TAB_DEC_PACKAGE_ABSTRACT, DT.TAB_DEC_PACKAGE_DESCRIPTION, \\r
+ DT.TAB_DEC_BINARY_ABSTRACT, DT.TAB_DEC_BINARY_DESCRIPTION]:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_MULTI_ENTRY_EXIST % StrName.split()[1], \\r
+ ExtraData=File.Path)\r
+ continue\r
+ elif len(Line.split()) == 4 and Line.find(u'#language') > 0:\r
+ if Line[Line.find(u'#language')-1] != ' ' or \\r
+ Line[Line.find(u'#language')+len(u'#language')] != u' ':\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ \r
+ if Line.find(u'"') > 0:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ \r
+ StrName = Line.split()[0] + u' ' + Line.split()[1]\r
+ if StrName:\r
+ if StrName.split()[1] not in ExistStrNameList:\r
+ ExistStrNameList.append(StrName.split()[1].strip())\r
+ elif StrName.split()[1] in [DT.TAB_INF_ABSTRACT, DT.TAB_INF_DESCRIPTION, \\r
+ DT.TAB_INF_BINARY_ABSTRACT, DT.TAB_INF_BINARY_DESCRIPTION, \\r
+ DT.TAB_DEC_PACKAGE_ABSTRACT, DT.TAB_DEC_PACKAGE_DESCRIPTION, \\r
+ DT.TAB_DEC_BINARY_ABSTRACT, DT.TAB_DEC_BINARY_DESCRIPTION]:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_MULTI_ENTRY_EXIST % StrName.split()[1], \\r
+ ExtraData=File.Path)\r
+ if IsIncludeFile:\r
+ if StrName not in NewLines:\r
+ NewLines.append((Line[:Line.find(u'#language')]).strip())\r
+ else:\r
+ NewLines.append((Line[:Line.find(u'#language')]).strip())\r
+ NewLines.append((Line[Line.find(u'#language'):]).strip())\r
+ elif len(Line.split()) > 4 and Line.find(u'#language') > 0 and Line.find(u'"') > 0:\r
+ if Line[Line.find(u'#language')-1] != u' ' or \\r
+ Line[Line.find(u'#language')+len(u'#language')] != u' ':\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ \r
+ if Line[Line.find(u'"')-1] != u' ':\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path) \r
+ \r
+ StrName = Line.split()[0] + u' ' + Line.split()[1] \r
+ if StrName:\r
+ if StrName.split()[1] not in ExistStrNameList:\r
+ ExistStrNameList.append(StrName.split()[1].strip())\r
+ elif StrName.split()[1] in [DT.TAB_INF_ABSTRACT, DT.TAB_INF_DESCRIPTION, \\r
+ DT.TAB_INF_BINARY_ABSTRACT, DT.TAB_INF_BINARY_DESCRIPTION, \\r
+ DT.TAB_DEC_PACKAGE_ABSTRACT, DT.TAB_DEC_PACKAGE_DESCRIPTION, \\r
+ DT.TAB_DEC_BINARY_ABSTRACT, DT.TAB_DEC_BINARY_DESCRIPTION]:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_MULTI_ENTRY_EXIST % StrName.split()[1], \\r
+ ExtraData=File.Path) \r
+ if IsIncludeFile:\r
+ if StrName not in NewLines:\r
+ NewLines.append((Line[:Line.find(u'#language')]).strip())\r
+ else: \r
+ NewLines.append((Line[:Line.find(u'#language')]).strip())\r
+ NewLines.append((Line[Line.find(u'#language'):Line.find(u'"')]).strip())\r
+ NewLines.append((Line[Line.find(u'"'):]).strip())\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ elif Line.startswith(u'#language'):\r
+ if len(Line.split()) == 2:\r
+ if IsIncludeFile:\r
+ if StrName not in NewLines:\r
+ NewLines.append(StrName)\r
+ else:\r
+ NewLines.append(StrName)\r
+ NewLines.append(Line)\r
+ elif len(Line.split()) > 2 and Line.find(u'"') > 0:\r
+ if IsIncludeFile:\r
+ if StrName not in NewLines:\r
+ NewLines.append(StrName)\r
+ else:\r
+ NewLines.append(StrName)\r
+ NewLines.append((Line[:Line.find(u'"')]).strip())\r
+ NewLines.append((Line[Line.find(u'"'):]).strip())\r
+ else:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ elif Line.startswith(u'"'):\r
+ if u'#string' in Line or u'#language' in Line:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ NewLines.append(Line)\r
+ else:\r
+ print Line\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, ExtraData=File.Path)\r
+ \r
+ if StrName and not StrName.split()[1].startswith(u'STR_'):\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_STRNAME_FORMAT_ERROR % StrName.split()[1], \\r
+ ExtraData=File.Path) \r
+ \r
+ if StrName and not NewLines:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNI_MISS_LANGENTRY % StrName, \\r
+ ExtraData=File.Path)\r
+ \r
+ #\r
+ # Check Abstract, Description, BinaryAbstract and BinaryDescription order,\r
+ # should be Abstract, Description, BinaryAbstract, BinaryDesctiption\r
+ AbstractPosition = -1\r
+ DescriptionPosition = -1\r
+ BinaryAbstractPosition = -1\r
+ BinaryDescriptionPosition = -1\r
+ for StrName in ExistStrNameList:\r
+ if DT.TAB_HEADER_ABSTRACT.upper() in StrName:\r
+ if 'BINARY' in StrName:\r
+ BinaryAbstractPosition = ExistStrNameList.index(StrName)\r
+ else:\r
+ AbstractPosition = ExistStrNameList.index(StrName)\r
+ if DT.TAB_HEADER_DESCRIPTION.upper() in StrName:\r
+ if 'BINARY' in StrName:\r
+ BinaryDescriptionPosition = ExistStrNameList.index(StrName)\r
+ else:\r
+ DescriptionPosition = ExistStrNameList.index(StrName)\r
+ \r
+ OrderList = sorted([AbstractPosition, DescriptionPosition])\r
+ BinaryOrderList = sorted([BinaryAbstractPosition, BinaryDescriptionPosition])\r
+ Min = OrderList[0]\r
+ Max = OrderList[1]\r
+ BinaryMin = BinaryOrderList[0]\r
+ BinaryMax = BinaryOrderList[1]\r
+ if BinaryDescriptionPosition > -1:\r
+ if not(BinaryDescriptionPosition == BinaryMax and BinaryAbstractPosition == BinaryMin and \\r
+ BinaryMax > Max):\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_ENTRY_ORDER_WRONG, \\r
+ ExtraData=File.Path) \r
+ elif BinaryAbstractPosition > -1:\r
+ if not(BinaryAbstractPosition > Max):\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_ENTRY_ORDER_WRONG, \\r
+ ExtraData=File.Path) \r
+ \r
+ if DescriptionPosition > -1:\r
+ if not(DescriptionPosition == Max and AbstractPosition == Min and \\r
+ DescriptionPosition > AbstractPosition):\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \\r
+ Message=ST.ERR_UNIPARSE_ENTRY_ORDER_WRONG, \\r
+ ExtraData=File.Path) \r
+ \r
+ if not self.UniFileHeader:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \r
+ Message = ST.ERR_NO_SOURCE_HEADER,\r
+ ExtraData=File.Path)\r
+ \r
+ return NewLines\r
+\r
+ #\r
+ # Load a .uni file\r
+ #\r
+ def LoadUniFile(self, File = None):\r
+ if File == None:\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.PARSER_ERROR, \r
+ Message='No unicode file is given', \r
+ ExtraData=File.Path)\r
+ \r
+ self.File = File\r
+ \r
+ #\r
+ # Process special char in file\r
+ #\r
+ Lines = self.PreProcess(File)\r
+\r
+ #\r
+ # Get Unicode Information\r
+ #\r
+ for IndexI in range(len(Lines)):\r
+ Line = Lines[IndexI]\r
+ if (IndexI + 1) < len(Lines):\r
+ SecondLine = Lines[IndexI + 1]\r
+ if (IndexI + 2) < len(Lines):\r
+ ThirdLine = Lines[IndexI + 2]\r
+\r
+ #\r
+ # Get Language def information\r
+ #\r
+ if Line.find(u'#langdef ') >= 0:\r
+ self.GetLangDef(File, Line + u' ' + SecondLine)\r
+ continue\r
+\r
+ Name = ''\r
+ Language = ''\r
+ Value = ''\r
+ CombineToken = False\r
+ #\r
+ # Get string def information format as below\r
+ #\r
+ # #string MY_STRING_1\r
+ # #language eng\r
+ # "My first English string line 1"\r
+ # "My first English string line 2"\r
+ # #string MY_STRING_1\r
+ # #language spa\r
+ # "Mi segunda secuencia 1"\r
+ # "Mi segunda secuencia 2"\r
+ #\r
+ if Line.find(u'#string ') >= 0 and Line.find(u'#language ') < 0 and \\r
+ SecondLine.find(u'#string ') < 0 and SecondLine.find(u'#language ') >= 0 and \\r
+ ThirdLine.find(u'#string ') < 0 and ThirdLine.find(u'#language ') < 0:\r
+ if Line.find('"') > 0 or SecondLine.find('"') > 0:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FORMAT_INVALID, \r
+ Message=ST.ERR_UNIPARSE_DBLQUOTE_UNMATCHED,\r
+ ExtraData=File.Path)\r
+ \r
+ Name = Line[Line.find(u'#string ') + len(u'#string ') : ].strip(' ')\r
+ Language = SecondLine[SecondLine.find(u'#language ') + len(u'#language ') : ].strip(' ')\r
+ for IndexJ in range(IndexI + 2, len(Lines)):\r
+ if Lines[IndexJ].find(u'#string ') < 0 and Lines[IndexJ].find(u'#language ') < 0 and \\r
+ Lines[IndexJ].strip().startswith(u'"') and Lines[IndexJ].strip().endswith(u'"'):\r
+ if Lines[IndexJ][-2] == ' ':\r
+ CombineToken = True\r
+ if CombineToken:\r
+ if Lines[IndexJ].strip()[1:-1].strip():\r
+ Value = Value + Lines[IndexJ].strip()[1:-1].rstrip() + ' '\r
+ else:\r
+ Value = Value + Lines[IndexJ].strip()[1:-1]\r
+ CombineToken = False\r
+ else:\r
+ Value = Value + Lines[IndexJ].strip()[1:-1] + os.linesep\r
+ else:\r
+ IndexI = IndexJ\r
+ break\r
+ if Value.endswith(os.linesep):\r
+ Value = Value[: Value.rfind(os.linesep)]\r
+ Language = GetLanguageCode(Language, self.IsCompatibleMode, self.File)\r
+ self.AddStringToList(Name, Language, Value)\r
+ continue\r
+\r
+ #\r
+ # Load multiple .uni files\r
+ #\r
+ def LoadUniFiles(self, FileList):\r
+ if len(FileList) > 0:\r
+ for File in FileList:\r
+ FilePath = File.Path.strip()\r
+ if FilePath.endswith('.uni') or FilePath.endswith('.UNI') or FilePath.endswith('.Uni'):\r
+ self.LoadUniFile(File)\r
+\r
+ #\r
+ # Add a string to list\r
+ #\r
+ def AddStringToList(self, Name, Language, Value, Token = 0, Referenced = False, UseOtherLangDef = '', Index = -1):\r
+ for LangNameItem in self.LanguageDef:\r
+ if Language == LangNameItem[0]:\r
+ break\r
+ \r
+ if Language not in self.OrderedStringList:\r
+ self.OrderedStringList[Language] = []\r
+ self.OrderedStringDict[Language] = {}\r
+ \r
+ IsAdded = True\r
+ if Name in self.OrderedStringDict[Language]:\r
+ IsAdded = False\r
+ if Value != None:\r
+ ItemIndexInList = self.OrderedStringDict[Language][Name]\r
+ Item = self.OrderedStringList[Language][ItemIndexInList]\r
+ Item.UpdateValue(Value)\r
+ Item.UseOtherLangDef = '' \r
+\r
+ if IsAdded:\r
+ Token = len(self.OrderedStringList[Language])\r
+ if Index == -1:\r
+ self.OrderedStringList[Language].append(StringDefClassObject(Name, \r
+ Value, \r
+ Referenced, \r
+ Token, \r
+ UseOtherLangDef))\r
+ self.OrderedStringDict[Language][Name] = Token\r
+ for LangName in self.LanguageDef:\r
+ #\r
+ # New STRING token will be added into all language string lists.\r
+ # so that the unique STRING identifier is reserved for all languages in the package list. \r
+ #\r
+ if LangName[0] != Language:\r
+ if UseOtherLangDef != '':\r
+ OtherLangDef = UseOtherLangDef\r
+ else:\r
+ OtherLangDef = Language\r
+ self.OrderedStringList[LangName[0]].append(StringDefClassObject(Name, \r
+ '', \r
+ Referenced, \r
+ Token, \r
+ OtherLangDef))\r
+ self.OrderedStringDict[LangName[0]][Name] = len(self.OrderedStringList[LangName[0]]) - 1\r
+ else:\r
+ self.OrderedStringList[Language].insert(Index, StringDefClassObject(Name, \r
+ Value, \r
+ Referenced, \r
+ Token, \r
+ UseOtherLangDef))\r
+ self.OrderedStringDict[Language][Name] = Index\r
+\r
+ #\r
+ # Set the string as referenced\r
+ #\r
+ def SetStringReferenced(self, Name):\r
+ #\r
+ # String stoken are added in the same order in all language string lists.\r
+ # So, only update the status of string stoken in first language string list.\r
+ #\r
+ Lang = self.LanguageDef[0][0]\r
+ if Name in self.OrderedStringDict[Lang]:\r
+ ItemIndexInList = self.OrderedStringDict[Lang][Name]\r
+ Item = self.OrderedStringList[Lang][ItemIndexInList]\r
+ Item.Referenced = True\r
+\r
+ #\r
+ # Search the string in language definition by Name\r
+ #\r
+ def FindStringValue(self, Name, Lang):\r
+ if Name in self.OrderedStringDict[Lang]:\r
+ ItemIndexInList = self.OrderedStringDict[Lang][Name]\r
+ return self.OrderedStringList[Lang][ItemIndexInList]\r
+\r
+ return None\r
+\r
+ #\r
+ # Search the string in language definition by Token\r
+ #\r
+ def FindByToken(self, Token, Lang):\r
+ for Item in self.OrderedStringList[Lang]:\r
+ if Item.Token == Token:\r
+ return Item\r
+\r
+ return None\r
+\r
+ #\r
+ # Re-order strings and re-generate tokens\r
+ #\r
+ def ReToken(self):\r
+ if len(self.LanguageDef) == 0:\r
+ return None\r
+ #\r
+ # Retoken all language strings according to the status of string stoken in the first language string.\r
+ #\r
+ FirstLangName = self.LanguageDef[0][0]\r
+\r
+ # Convert the OrderedStringList to be OrderedStringListByToken in order to faciliate future search by token\r
+ for LangNameItem in self.LanguageDef:\r
+ self.OrderedStringListByToken[LangNameItem[0]] = {}\r
+\r
+ #\r
+ # Use small token for all referred string stoken.\r
+ #\r
+ RefToken = 0\r
+ for Index in range (0, len (self.OrderedStringList[FirstLangName])):\r
+ FirstLangItem = self.OrderedStringList[FirstLangName][Index]\r
+ if FirstLangItem.Referenced == True:\r
+ for LangNameItem in self.LanguageDef:\r
+ LangName = LangNameItem[0]\r
+ OtherLangItem = self.OrderedStringList[LangName][Index]\r
+ OtherLangItem.Referenced = True\r
+ OtherLangItem.Token = RefToken\r
+ self.OrderedStringListByToken[LangName][OtherLangItem.Token] = OtherLangItem\r
+ RefToken = RefToken + 1\r
+\r
+ #\r
+ # Use big token for all unreferred string stoken.\r
+ #\r
+ UnRefToken = 0\r
+ for Index in range (0, len (self.OrderedStringList[FirstLangName])):\r
+ FirstLangItem = self.OrderedStringList[FirstLangName][Index]\r
+ if FirstLangItem.Referenced == False:\r
+ for LangNameItem in self.LanguageDef:\r
+ LangName = LangNameItem[0]\r
+ OtherLangItem = self.OrderedStringList[LangName][Index]\r
+ OtherLangItem.Token = RefToken + UnRefToken\r
+ self.OrderedStringListByToken[LangName][OtherLangItem.Token] = OtherLangItem\r
+ UnRefToken = UnRefToken + 1\r
+\r
+ #\r
+ # Show the instance itself\r
+ #\r
+ def ShowMe(self):\r
+ print self.LanguageDef\r
+ #print self.OrderedStringList\r
+ for Item in self.OrderedStringList:\r
+ print Item\r
+ for Member in self.OrderedStringList[Item]:\r
+ print str(Member)\r
+ \r
+ #\r
+ # Read content from '!include' UNI file \r
+ #\r
+ def ReadIncludeUNIfile(self, FilaPath):\r
+ if self.File:\r
+ pass\r
+ \r
+ if not os.path.exists(FilaPath) or not os.path.isfile(FilaPath):\r
+ EdkLogger.Error("Unicode File Parser", \r
+ ToolError.FILE_NOT_FOUND,\r
+ ExtraData=FilaPath)\r
+ try:\r
+ FileIn = codecs.open(FilaPath, mode='rb', encoding='utf_16').readlines()\r
+ except UnicodeError:\r
+ FileIn = codecs.open(FilaPath, mode='rb', encoding='utf_16_le').readlines()\r
+ except:\r
+ EdkLogger.Error("Unicode File Parser", ToolError.FILE_OPEN_FAILURE, ExtraData=FilaPath)\r
+ return FileIn\r
+\r
# This is an XML API that uses a syntax similar to XPath, but it is written in\r
# standard python so that no extra python packages are required to use it.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
#\r
import xml.dom.minidom\r
import re\r
+import codecs\r
from Logger.ToolError import PARSER_ERROR\r
import Logger.Log as Logger\r
\r
#\r
def XmlParseFile(FileName):\r
try:\r
- XmlFile = open(FileName)\r
+ XmlFile = codecs.open(FileName, 'rb')\r
Dom = xml.dom.minidom.parse(XmlFile)\r
XmlFile.close()\r
return Dom\r
## @file\r
# This file is used to define strings used in the UPT tool\r
#\r
-# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
MSG_VERSION_NUMBER = _("1.0")\r
MSG_VERSION = _("Intel(r) UEFI Packaging Tool (Intel(r) UEFIPT) - Revision " + \\r
MSG_VERSION_NUMBER)\r
-MSG_COPYRIGHT = _("Copyright (c) 2011 - 2013 Intel Corporation All Rights Reserved.")\r
+MSG_COPYRIGHT = _("Copyright (c) 2011 Intel Corporation All Rights Reserved.")\r
MSG_VERSION_COPYRIGHT = _("\n %s\n %s" % (MSG_VERSION, MSG_COPYRIGHT))\r
-MSG_USAGE = _("%s [options]\n%s" % ("upt.exe", MSG_VERSION_COPYRIGHT))\r
+MSG_USAGE = _("%s [options]\n%s" % ("UPT", MSG_VERSION_COPYRIGHT))\r
MSG_DESCRIPTION = _("The Intel(r) UEFIUPT is used to create, " + \\r
"install or remove a UEFI Distribution Package.")\r
\r
_("Build Option format incorrect.")\r
ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID = _(\r
"The format of binary %s item is incorrect. "\r
- "It should contain at least 2 elements.")\r
+ "It should contain at least %d elements.")\r
ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX = _(\r
"The format of binary %s item is invalid, "\r
- "it should contain not more than %d elements.") \r
+ "it should contain not more than %d elements.")\r
ERR_INF_PARSER_BINARY_ITEM_INVALID_FILETYPE = _(\r
"The Binary FileType is incorrect. It should in %s")\r
ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST = _(\r
"The Binary File: %s not exist.")\r
+ERR_INF_PARSER_BINARY_ITEM_FILENAME_NOT_EXIST = _(\r
+ "The Binary File Name item not exist")\r
ERR_INF_PARSER_BINARY_VER_TYPE = _(\r
"Only this type is allowed: \"%s\".")\r
ERR_INF_PARSER_MULTI_DEFINE_SECTION = \\r
_("Multiple define sections found. "\r
"It must be corrected before continuing.")\r
ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND = \\r
- _("More then 1 %s is defined in DEFINES section. "\r
+ _("More than 1 %s is defined in DEFINES section. "\r
"It must be corrected before continuing.")\r
ERR_INF_PARSER_DEFINE_NAME_INVALID = \\r
_("Incorrect name format for : %s")\r
ERR_INF_PARSER_DEFINE_FROMAT_INVALID = _("Incorrect format: %s")\r
ERR_INF_PARSER_FILE_NOT_EXIST = _("This file does not exist: %s")\r
ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID = \\r
- _("The file does not exist or has an incorrect file name or not in "\r
- "sub-directories of the directory containing the INF file: %s. "\r
+ _("The file does not exist or not in sub-directories "\r
+ "or has an incorrect file name of the directory containing the INF or DEC file: %s. "\r
"It must be corrected before continuing")\r
ERR_INF_PARSER_DEFINE_SHADOW_INVALID = \\r
_("The SHADOW keyword is only valid for"\r
_("The format of the section header is incorrect")\r
ERR_INF_PARSER_DEPEX_SECTION_INVALID = \\r
_("A module can't have a Depex section when its module type is %s")\r
+ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_BASE_LIBRARY_CLASS = \\r
+ _("A base type library class can't have a Depex section with module type not defined.")\r
ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_LIBRARY_CLASS = \\r
_("A library class can't have a Depex section when its supported module type list is not defined.")\r
ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_DRIVER = \\r
#\r
# Item duplicate\r
#\r
+ERR_INF_PARSER_ITEM_DUPLICATE_IN_DEC = \\r
+_('"%s" is redefined in its dependent DEC files')\r
ERR_INF_PARSER_ITEM_DUPLICATE = _("%s define duplicated! " \r
"It must be corrected before continuing.")\r
ERR_INF_PARSER_ITEM_DUPLICATE_COMMON = _("%s define duplicated! Item listed" \r
\r
ERR_ASBUILD_PCD_SECTION_TYPE = _("The AsBuilt INF file contains a PCD section type that is not permitted: %s.")\r
ERR_ASBUILD_PATCHPCD_FORMAT_INVALID = _("The AsBuilt PatchPcd entry must contain 3 elements: PcdName|Value|Offset")\r
-ERR_ASBUILD_PCDEX_FORMAT_INVALID = _("The AsBuilt PcdEx entry must contain 2 elements: PcdName|Value")\r
+ERR_ASBUILD_PCDEX_FORMAT_INVALID = _("The AsBuilt PcdEx entry must contain one element: PcdName")\r
ERR_ASBUILD_PCD_VALUE_INVALID = \\r
_("The AsBuilt PCD value %s is incorrect or not align with it's datum type %s. "\r
"It must be corrected before continuing.")\r
MSG_RELATIVE_PATH_ONLY = _("Please specify a relative path, full path is not allowed: %s")\r
MSG_NEW_PKG_PATH = _(\r
"Select package location. To quit with no input, press [Enter].")\r
-\r
+MSG_CHECK_DP_FOR_REPLACE = _("Verifying the dependency rule for replacement of distributions:\n %s replaces %s")\r
+MSG_CHECK_DP_FOR_INSTALL = _("Verifying the dependency rule for installation of distribution:\n %s")\r
+MSG_REPLACE_ALREADY_INSTALLED_DP = _("Distribution with the same GUID/Version is already installed, "\r
+ "replace would result in two instances, which is not allowed")\r
+MSG_RECOVER_START = _('An error was detected, recovery started ...')\r
+MSG_RECOVER_DONE = _('Recovery completed.')\r
+MSG_RECOVER_FAIL = _('Recovery failed.')\r
#\r
# Error related strings.\r
#\r
"This distribution package does not meet the dependency requirements")\r
ERR_UNKNOWN_FATAL_INSTALL_ERR = \\r
_("Unknown unrecoverable error when installing: %s")\r
+ERR_UNKNOWN_FATAL_REPLACE_ERR = \\r
+_("Unknown unrecoverable error during replacement of distributions: %s replaces %s")\r
ERR_OPTION_NOT_FOUND = _("Options not found")\r
ERR_INVALID_PACKAGE_NAME = _("Incorrect package name: %s. ")\r
ERR_INVALID_PACKAGE_PATH = \\r
ERR_DISTRIBUTION_NOT_INSTALLED = _(\r
"The distribution package is not installed.")\r
ERR_UNKNOWN_FATAL_REMOVING_ERR = _("Unknown error when removing package")\r
+ERR_UNKNOWN_FATAL_INVENTORYWS_ERR = _("Unknown error when inventorying WORKSPACE")\r
ERR_NOT_CONFIGURE_WORKSPACE_ENV = _(\r
"The WORKSPACE environment variable must be configured.")\r
ERR_NO_TEMPLATE_FILE = _("This package information data file is not found: %s")\r
"Not supported debug level. Use default level instead.")\r
ERR_REQUIRE_T_OPTION = _(\r
"Option -t is required during distribution creation.")\r
+ERR_REQUIRE_O_OPTION = _(\r
+ "Option -o is required during distribution replacement.")\r
+ERR_REQUIRE_U_OPTION = _(\r
+ "Option -u is required during distribution replacement.")\r
ERR_REQUIRE_I_C_R_OPTION = _(\r
"Options -i, -c and -r are mutually exclusive.")\r
ERR_I_C_EXCLUSIVE = \\r
_("Option -i and -r are mutually exclusive.")\r
ERR_C_R_EXCLUSIVE = \\r
_("Option -c and -r are mutually exclusive.")\r
+ERR_U_ICR_EXCLUSIVE = \\r
+_("Option -u and -c/-i/-r are mutually exclusive.")\r
+\r
+ERR_L_OA_EXCLUSIVE = \\r
+_("Option -l and -c/-i/-r/-u are mutually exclusive.")\r
\r
ERR_FAILED_LOAD = _("Failed to load %s\n\t%s")\r
ERR_PLACEHOLDER_DIFFERENT_REPEAT = _(\r
ERR_NOT_SUPPORTED_SA_MODULE = _("Stand-alone module distribution does not allow EDK 1 INF")\r
ERR_INSTALL_DIST_NOT_FOUND = \\r
_("Distribution file to be installed is not found in current working directory or workspace: %s")\r
+ERR_REPLACE_DIST_NOT_FOUND = \\r
+_("Distribution file for replace function was not found in the current working directory or workspace: %s")\r
+ERR_DIST_FILENAME_ONLY_FOR_REPLACE_ORIG = \\r
+_("Only a distribution file name without a path is allowed for "\r
+ "the distribution to be replaced during replace. Current given: '%s'.")\r
+ERR_UNIPARSE_DBLQUOTE_UNMATCHED = \\r
+_("Only Language entry can contain a couple of matched quote in one line")\r
+ERR_UNIPARSE_NO_SECTION_EXIST = _("No PakcageDef or ModuleDef section exists in the UNI file.")\r
+ERR_UNIPARSE_STRNAME_FORMAT_ERROR = _("The String Token Name %s must start with \"STR_\"")\r
+ERR_UNIPARSE_SEP_LANGENTRY_LINE = _("Each <LangEntry> should be in a separate line :%s.")\r
+ERR_UNIPARSE_MULTI_ENTRY_EXIST = \\r
+_("There are same entries : %s in the UNI file, every kind of entry should be only one.")\r
+ERR_UNIPARSE_ENTRY_ORDER_WRONG = \\r
+_("The string entry order in UNI file should be <AbstractStrings>, <DescriptionStrings>, \\r
+<BinaryAbstractStrings>, <BinaryDescriptionStrings>.")\r
+ERR_UNIPARSE_STRTOKEN_FORMAT_ERROR = _("The String Token Type %s must be one of the '_PROMPT', '_HELP' and '_ERR_'.") \r
+ERR_UNIPARSE_LINEFEED_UNDER_EXIST = _("Line feed should not exist under this line: %s.")\r
+ERR_UNIPARSE_LINEFEED_UP_EXIST = _("Line feed should not exist up this line: %s.")\r
+ERR_UNI_MISS_LANGENTRY = _("Language entry missed in this Entry, %s.")\r
ERR_BINARY_HEADER_ORDER = _("Binary header must follow the file header.")\r
ERR_NO_SOURCE_HEADER = _("File header statement \"## @file\" must exist at the first place.")\r
+ERR_UNI_FILE_SUFFIX_WRONG = _("The UNI file must have an extension of '.uni', '.UNI' or '.Uni'")\r
+ERR_UNI_FILE_NAME_INVALID = _("The use of '..', '../' and './' in the UNI file is prohibited.")\r
+ERR_UNI_SUBGUID_VALUE_DEFINE_DEC_NOT_FOUND = _("There are no DEC file to define the GUID value for \\r
+this GUID CName: '%s'.")\r
\r
#\r
# Expression error message\r
#\r
ERR_EXPR_RIGHT_PAREN = \\r
-_('Expected ")" in feature flag expression [%s]. Found: [%s].')\r
+_('Missing ")" in expression "%s".')\r
ERR_EXPR_FACTOR = \\r
-_('Expected HEX, integer, macro, quoted string or PcdName in '\r
- 'feature flag expression [%s]. Found: [%s].')\r
+_('"%s" is expected to be HEX, integer, macro, quoted string or PcdName in '\r
+ 'expression "%s".')\r
ERR_EXPR_STRING_ITEM = \\r
-_('Expected quoted string, macro name or PcdName in feature flag '\r
- 'expression [%s]. Found: [%s].')\r
+_('"%s" is expected to be HEX, integer, macro, quoted string or PcdName in '\r
+ 'expression [%s].')\r
ERR_EXPR_EQUALITY = \\r
-_('Expected ==, EQ, != or NE in feature flag expression [%s]. Found: [%s].')\r
+_('"%s" is expected to be ==, EQ, != or NE in expression "%s".')\r
ERR_EXPR_BOOLEAN = \\r
-_('The rest of string [%s] in feature flag ' \r
- 'expression [%s] cannot be evaluated.')\r
+_('The string "%s" in expression "%s" can not be recognized as a part of the logical expression.')\r
ERR_EXPR_EMPTY = _('Boolean value cannot be empty.')\r
+ERR_EXPRESS_EMPTY = _('Expression can not be empty.')\r
ERR_EXPR_LOGICAL = \\r
-_('The following cannot be evaluated as a logical expression: [%s].')\r
-ERR_EXPR_OR = _('The expression must be encapsulated in open "(" and close ")" '\r
+_('The following is not a valid logical expression: "%s".')\r
+ERR_EXPR_OR = _('The expression: "%s" must be encapsulated in open "(" and close ")" '\r
'parenthesis when using | or ||.')\r
+ERR_EXPR_RANGE = \\r
+_('The following is not a valid range expression: "%s".')\r
+ERR_EXPR_RANGE_FACTOR = \\r
+_('"%s" is expected to be HEX, integer in valid range expression "%s".')\r
+ERR_EXPR_RANGE_DOUBLE_PAREN_NESTED = \\r
+_('Double parentheses nested is not allowed in valid range expression: "%s".')\r
+ERR_EXPR_RANGE_EMPTY = _('Valid range can not be empty.')\r
+ERR_EXPR_LIST_EMPTY = _('Valid list can not be empty.')\r
+ERR_PAREN_NOT_USED = _('Parenthesis must be used on both sides of "OR", "AND" in valid range : %s.')\r
+ERR_EXPR_LIST = \\r
+_('The following is not a valid list expression: "%s".')\r
+\r
\r
-#\r
# DEC parser error message\r
#\r
ERR_DECPARSE_STATEMENT_EMPTY = \\r
_("Incorrect value [%s] of type [%s]. Value must be printable and in the "\r
"form of{...} for array, or ""..."" for string, or L""..."""\r
"for unicode string.")\r
+ERR_DECPARSE_PCD_VALUE_EMPTY = \\r
+_("Pcd value can not be empty.") \r
ERR_DECPARSE_PCD_BOOL = \\r
_("Invalid value [%s] of type [%s]; must be expression, TRUE, FALSE, 0 or 1.")\r
ERR_DECPARSE_PCD_INT = _("Incorrect value [%s] of type [%s]."\\r
ERR_DECPARSE_CGUID_GUIDFORMAT = \\r
_("Incorrect GUID value format, must be <GuidValueInCFormat:" \r
"{8,4,4,{2,2,2,2,2,2,2,2}}>.")\r
+ERR_DECPARSE_CGUID_NOT_FOUND = _("Unable to find the GUID value of this GUID CName : '%s'.")\r
ERR_DECPARSE_FILEOPEN = _("Unable to open: [%s].")\r
ERR_DECPARSE_SECTION_EMPTY = _("Empty sections are not allowed.")\r
ERR_DECPARSE_SECTION_UE = _("Incorrect UserExtentions format. "\r
ERR_DECPARSE_MACRO_RESOLVE = _("Macro %s in %s cannot be resolved.")\r
ERR_DECPARSE_UE_DUPLICATE = \\r
_("Duplicated UserExtensions header found.")\r
-\r
+ERR_DECPARSE_PCDERRORMSG_MISS_VALUE_SPLIT = \\r
+ _("Missing '|' between Pcd's error code and Pcd's error message.")\r
+ERR_DECPARSE_PCD_MISS_ERRORMSG = \\r
+ _("Missing Pcd's error message.")\r
+ERR_DECPARSE_PCD_UNMATCHED_ERRORCODE = \\r
+ _("There is no error message matched with this Pcd error code : %s in both DEC and UNI file.")\r
+ERR_DECPARSE_PCD_NODEFINED = _("The PCD : %s used in the Expression is undefined.")\r
#\r
# Used to print the current line content which cause error raise.\r
# Be attached to the end of every error message above.\r
WRN_DIST_NOT_FOUND = _(\r
"Distribution is not found at location %s")\r
WRN_MULTI_PCD_RANGES = _(\r
- "A PCD can only have one each of @ValidRange, @ValidList, "\r
- "and @Expression comment")\r
+ "A PCD can only have one type of @ValidRange, @ValidList, and @Expression comment")\r
+WRN_MULTI_PCD_VALIDVALUE = _(\r
+ "A PCD can only have one of @ValidList comment")\r
+WRN_MULTI_PCD_PROMPT = _(\r
+ "A PCD can only have one of @Prompt comment")\r
WRN_MISSING_USAGE = _("Missing usage")\r
WRN_INVALID_GUID_TYPE = _("This is and incorrect Guid type: %s")\r
WRN_MISSING_GUID_TYPE = _("Missing Guid Type")\r
"at the end of a file or at the end of a section.")\r
WARN_INSTALLED_PACKAGE_NOT_FOUND = \\r
_("File not found. The DEC file for a package cannot be found in GUID/Version/Install path: %s %s %s")\r
+WARN_CUSTOMPATH_OVERRIDE_USEGUIDEDPATH = \\r
+ _("option selection of --custom-path will override the option --use-guided-paths")\r
\r
#\r
# Help related strings.\r
"Specify dec file names to create package")\r
HLP_SPECIFY_INF_NAME_CREATE = _(\r
"Specify inf file names to create package")\r
+HLP_LIST_DIST_INSTALLED = _(\r
+ "List the UEFI Distribution Packages that have been installed")\r
HLP_NO_SUPPORT_GUI = _(\r
"Starting the tool in graphical mode is not supported in this version")\r
HLP_DISABLE_PROMPT = _(\r
- "Disable all user prompts")\r
+ "Disable user prompts for removing modified files. Valid only when -r is present")\r
HLP_CUSTOM_PATH_PROMPT = _(\r
"Enable user prompting for alternate installation directories")\r
HLP_SKIP_LOCK_CHECK = _(\r
"Skip the check for multiple instances")\r
+HLP_SPECIFY_PACKAGE_NAME_REPLACE = _(\r
+ "Specify the UEFI Distribution Package file name to replace the existing file name")\r
+HLP_SPECIFY_PACKAGE_NAME_TO_BE_REPLACED = _(\r
+ "Specify the UEFI Distribution Package file name to be replaced")\r
+HLP_USE_GUIDED_PATHS = _(\r
+ "Install packages to the following directory path by default: <PackageName>_<PACKAGE_GUID>_<PACKAGE_VERSION>")\r
## @file\r
# Install distribution package.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Xml.XmlParser import DistributionPackageXml\r
from Xml.IniToXml import IniToXml\r
\r
-from Library.Misc import CheckEnvVariable\r
from Library import GlobalData\r
from Library.ParserValidate import IsValidPath\r
\r
try:\r
DataBase = GlobalData.gDB \r
ContentFileClosed = True\r
- CheckEnvVariable()\r
WorkspaceDir = GlobalData.gWORKSPACE\r
\r
#\r
## @file\r
# This file is used to define common items of class object\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
'''\r
Common Object\r
'''\r
-from Library.DataType import LANGUAGE_EN_US\r
+from Library.DataType import TAB_LANGUAGE_EN_US\r
\r
## HelpTextObject\r
#\r
def GetHelpTextList(self):\r
return self.HelpTextList\r
\r
+## PromptListObject\r
+#\r
+# @param object: Inherited from object class\r
+#\r
+class PromptListObject(object):\r
+ def __init__(self):\r
+ self.PromptList = []\r
+ \r
+ def SetPromptList(self, PromptList):\r
+ self.PromptList = PromptList\r
+ \r
+ def GetPromptList(self):\r
+ return self.PromptList\r
+ \r
## CommonPropertiesObject\r
#\r
# This class defined common attribution used in Module/Platform/Package files\r
self.Usage = []\r
self.FeatureFlag = ''\r
self.SupArchList = []\r
+ self.GuidValue = ''\r
HelpTextObject.__init__(self)\r
HelpTextListObject.__init__(self)\r
\r
\r
def GetSupArchList(self):\r
return self.SupArchList\r
+ \r
+ def SetGuidValue(self, GuidValue):\r
+ self.GuidValue = GuidValue\r
+ \r
+ def GetGuidValue(self):\r
+ return self.GuidValue\r
\r
## CommonHeaderObject\r
#\r
#\r
class CommonHeaderObject(object):\r
def __init__(self):\r
- self.Abstract = ''\r
- self.Description = ''\r
- self.Copyright = ''\r
- self.License = ''\r
+ self.AbstractList = []\r
+ self.DescriptionList = []\r
+ self.CopyrightList = []\r
+ self.LicenseList = []\r
\r
def SetAbstract(self, Abstract):\r
- self.Abstract = Abstract\r
+ if isinstance(Abstract, list):\r
+ self.AbstractList = Abstract\r
+ else:\r
+ self.AbstractList.append(Abstract)\r
\r
def GetAbstract(self):\r
- return self.Abstract\r
+ return self.AbstractList\r
\r
def SetDescription(self, Description):\r
- self.Description = Description\r
+ if isinstance(Description, list):\r
+ self.DescriptionList = Description\r
+ else:\r
+ self.DescriptionList.append(Description)\r
\r
def GetDescription(self):\r
- return self.Description\r
+ return self.DescriptionList\r
\r
def SetCopyright(self, Copyright):\r
- self.Copyright = Copyright\r
+ if isinstance(Copyright, list):\r
+ self.CopyrightList = Copyright\r
+ else:\r
+ self.CopyrightList.append(Copyright)\r
\r
def GetCopyright(self):\r
- return self.Copyright\r
+ return self.CopyrightList\r
\r
def SetLicense(self, License):\r
- self.License = License\r
+ if isinstance(License, list):\r
+ self.LicenseList = License\r
+ else:\r
+ self.LicenseList.append(License)\r
\r
def GetLicense(self):\r
- return self.License\r
+ return self.LicenseList\r
\r
+## BinaryHeaderObject\r
+#\r
+# This class defined Binary header items used in Module/Platform/Package files\r
+#\r
+# @param object: Inherited from object class\r
+#\r
+class BinaryHeaderObject(object):\r
+ def __init__(self):\r
+ self.BinaryHeaderAbstractList = []\r
+ self.BinaryHeaderDescriptionList = []\r
+ self.BinaryHeaderCopyrightList = []\r
+ self.BinaryHeaderLicenseList = []\r
+\r
+ def SetBinaryHeaderAbstract(self, Abstract):\r
+ if isinstance(Abstract, list) and Abstract:\r
+ self.BinaryHeaderAbstractList = Abstract\r
+ elif isinstance(Abstract, tuple) and Abstract[1]:\r
+ self.BinaryHeaderAbstractList.append(Abstract)\r
+\r
+ def GetBinaryHeaderAbstract(self):\r
+ return self.BinaryHeaderAbstractList\r
+\r
+ def SetBinaryHeaderDescription(self, Description):\r
+ if isinstance(Description, list) and Description:\r
+ self.BinaryHeaderDescriptionList = Description\r
+ elif isinstance(Description, tuple) and Description[1]:\r
+ self.BinaryHeaderDescriptionList.append(Description)\r
+\r
+ def GetBinaryHeaderDescription(self):\r
+ return self.BinaryHeaderDescriptionList\r
+\r
+ def SetBinaryHeaderCopyright(self, Copyright):\r
+ if isinstance(Copyright, list) and Copyright:\r
+ self.BinaryHeaderCopyrightList = Copyright\r
+ elif isinstance(Copyright, tuple) and Copyright[1]:\r
+ self.BinaryHeaderCopyrightList.append(Copyright)\r
+\r
+ def GetBinaryHeaderCopyright(self):\r
+ return self.BinaryHeaderCopyrightList\r
+\r
+ def SetBinaryHeaderLicense(self, License):\r
+ if isinstance(License, list) and License:\r
+ self.BinaryHeaderLicenseList = License\r
+ elif isinstance(License, tuple) and License[1]:\r
+ self.BinaryHeaderLicenseList.append(License)\r
+\r
+ def GetBinaryHeaderLicense(self):\r
+ return self.BinaryHeaderLicenseList\r
+ \r
## ClonedRecordObject\r
#\r
# This class defined ClonedRecord items used in Module/Platform/Package files\r
#\r
class TextObject(object):\r
def __init__(self):\r
- self.Lang = LANGUAGE_EN_US\r
+ self.Lang = TAB_LANGUAGE_EN_US\r
self.String = ''\r
\r
def SetLang(self, Lang):\r
#\r
class FileObject(object):\r
def __init__(self):\r
- self.Executable = ''\r
+ self.Executable = '' \r
self.Uri = ''\r
self.OsType = ''\r
-\r
+ \r
def SetExecutable(self, Executable):\r
self.Executable = Executable\r
\r
def __init__(self):\r
self.UserID = ''\r
self.Identifier = ''\r
+ self.BinaryAbstractList = []\r
+ self.BinaryDescriptionList = []\r
+ self.BinaryCopyrightList = []\r
+ self.BinaryLicenseList = []\r
+ self.UniLangDefsList = []\r
#\r
# { Statement : Arch , ... } \r
#\r
def GetIdentifier(self):\r
return self.Identifier\r
\r
+ def SetUniLangDefsList(self, UniLangDefsList):\r
+ self.UniLangDefsList = UniLangDefsList\r
+ \r
+ def GetUniLangDefsList(self):\r
+ return self.UniLangDefsList\r
+ \r
+ def SetBinaryAbstract(self, BinaryAbstractList):\r
+ self.BinaryAbstractList = BinaryAbstractList\r
+ \r
+ def GetBinaryAbstract(self, Lang=None):\r
+ if Lang:\r
+ for (Key, Value) in self.BinaryAbstractList:\r
+ if Key == Lang:\r
+ return Value\r
+ return None\r
+ else:\r
+ return self.BinaryAbstractList\r
+ \r
+ def SetBinaryDescription(self, BinaryDescriptionList):\r
+ self.BinaryDescriptionList = BinaryDescriptionList\r
+ \r
+ def GetBinaryDescription(self, Lang=None):\r
+ if Lang:\r
+ for (Key, Value) in self.BinaryDescriptionList:\r
+ if Key == Lang:\r
+ return Value\r
+ return None\r
+ else:\r
+ return self.BinaryDescriptionList\r
+ \r
+ def SetBinaryCopyright(self, BinaryCopyrightList):\r
+ self.BinaryCopyrightList = BinaryCopyrightList\r
+ \r
+ def GetBinaryCopyright(self, Lang=None):\r
+ if Lang:\r
+ for (Key, Value) in self.BinaryCopyrightList:\r
+ if Key == Lang:\r
+ return Value\r
+ return None\r
+ else:\r
+ return self.BinaryCopyrightList\r
+ \r
+ def SetBinaryLicense(self, BinaryLicenseList):\r
+ self.BinaryLicenseList = BinaryLicenseList\r
+ \r
+ def GetBinaryLicense(self, Lang=None):\r
+ if Lang:\r
+ for (Key, Value) in self.BinaryLicenseList:\r
+ if Key == Lang:\r
+ return Value\r
+ return None\r
+ else:\r
+ return self.BinaryLicenseList\r
+ \r
def SetDefinesDict(self, DefinesDict):\r
self.DefinesDict = DefinesDict\r
\r
self.Expression = ''\r
self.ErrorNumber = ''\r
self.ErrorMessageList = []\r
+ self.TokenSpaceGuidCName = ''\r
+ self.CName = ''\r
+ self.FileLine = ''\r
+ self.LineNum = 0\r
\r
def SetValidValue(self, ValidValue):\r
self.ValidValue = ValidValue\r
def GetErrorMessageList(self):\r
return self.ErrorMessageList\r
\r
-\r
+ def SetTokenSpaceGuidCName(self, TokenSpaceGuidCName):\r
+ self.TokenSpaceGuidCName = TokenSpaceGuidCName\r
+ \r
+ def GetTokenSpaceGuidCName(self):\r
+ return self.TokenSpaceGuidCName\r
+ \r
+ def SetCName(self, CName):\r
+ self.CName = CName\r
+ \r
+ def GetCName(self):\r
+ return self.CName\r
+ \r
+ def SetFileLine(self, FileLine):\r
+ self.FileLine = FileLine\r
+ \r
+ def GetFileLine(self):\r
+ return self.FileLine\r
+ \r
+ def SetLineNum(self, LineNum):\r
+ self.LineNum = LineNum\r
+ \r
+ def GetLineNum(self):\r
+ return self.LineNum\r
+ \r
+ \r
## IncludeObject\r
#\r
# This class defined Include item used in Module/Platform/Package files\r
# @param SkuInfoList: Input value for SkuInfoList, default is {}\r
# @param SupModuleList: Input value for SupModuleList, default is []\r
#\r
-class PcdObject(CommonPropertiesObject, HelpTextListObject):\r
+class PcdObject(CommonPropertiesObject, HelpTextListObject, PromptListObject):\r
def __init__(self):\r
self.PcdCName = ''\r
self.CName = ''\r
self.SupModuleList = [] \r
CommonPropertiesObject.__init__(self)\r
HelpTextListObject.__init__(self)\r
+ PromptListObject.__init__(self)\r
\r
def SetPcdCName(self, PcdCName):\r
self.PcdCName = PcdCName\r
## @file\r
# This file is used to define a class object to describe a module\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Object.POM.CommonObject import CommonPropertiesObject\r
from Object.POM.CommonObject import IdentificationObject\r
from Object.POM.CommonObject import CommonHeaderObject\r
+from Object.POM.CommonObject import BinaryHeaderObject\r
from Object.POM.CommonObject import HelpTextListObject\r
from Object.POM.CommonObject import GuidVersionObject\r
\r
#\r
# This class defined header items used in Module file\r
# \r
-class ModuleHeaderObject(IdentificationObject, CommonHeaderObject):\r
+class ModuleHeaderObject(IdentificationObject, CommonHeaderObject, BinaryHeaderObject):\r
def __init__(self):\r
self.IsLibrary = False\r
self.IsLibraryModList = []\r
self.PcdIsDriver = ''\r
self.PiSpecificationVersion = ''\r
self.UefiSpecificationVersion = ''\r
+ self.UNIFlag = False\r
#\r
# SpecObject\r
#\r
self.SupArchList = []\r
IdentificationObject.__init__(self)\r
CommonHeaderObject.__init__(self)\r
+ BinaryHeaderObject.__init__(self)\r
\r
def SetIsLibrary(self, IsLibrary):\r
self.IsLibrary = IsLibrary\r
def __init__(self):\r
self.LibGuid = ''\r
self.LibVersion = ''\r
+ self.SupArchList = []\r
\r
def SetLibGuid(self, LibGuid):\r
self.LibGuid = LibGuid\r
def GetLibVersion(self):\r
return self.LibVersion\r
\r
+ def SetSupArchList(self, SupArchList):\r
+ self.SupArchList = SupArchList\r
+ def GetSupArchList(self):\r
+ return self.SupArchList\r
+\r
##\r
# AsBuiltObject\r
#\r
#\r
# List of BinaryBuildFlag object\r
#\r
- self.BinaryBuildFlagList = ''\r
+ self.BinaryBuildFlagList = []\r
\r
def SetPatchPcdList(self, PatchPcdList):\r
self.PatchPcdList = PatchPcdList\r
## @file\r
# This file is used to define a class object to describe a package\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Object.POM.CommonObject import CommonPropertiesObject\r
from Object.POM.CommonObject import IdentificationObject\r
from Object.POM.CommonObject import CommonHeaderObject\r
+from Object.POM.CommonObject import BinaryHeaderObject\r
from Library.Misc import Sdict\r
\r
## StandardIncludeFileObject\r
##\r
# PackageObject\r
#\r
-class PackageObject(IdentificationObject, CommonHeaderObject):\r
+class PackageObject(IdentificationObject, CommonHeaderObject, BinaryHeaderObject):\r
def __init__(self):\r
IdentificationObject.__init__(self)\r
CommonHeaderObject.__init__(self)\r
+ BinaryHeaderObject.__init__(self)\r
#\r
# LibraryClassObject\r
#\r
#\r
self.PcdList = [] \r
#\r
- # UserExtensionObject\r
+ # {(PcdTokenSpaceGuidCName, PcdErrroNumber): PcdErrorMessageList}\r
+ #\r
+ self.PcdErrorCommentDict = {}\r
#\r
+ # UserExtensionObject\r
+ # \r
self.UserExtensionList = [] \r
#\r
# MiscFileObject\r
\r
self.PcdChecks = []\r
\r
+ self.UNIFlag = False\r
+ \r
def SetLibraryClassList(self, LibraryClassList):\r
self.LibraryClassList = LibraryClassList\r
\r
# This file is used to define class objects of INF file [Binaries] section. \r
# It will consumed by InfParser. \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
self.CommonType = ''\r
self.TagName = ''\r
self.Family = ''\r
+ self.GuidValue = ''\r
InfBianryItem.__init__(self)\r
CurrentLine.__init__(self)\r
\r
self.Family = Family\r
def GetFamily(self):\r
return self.Family\r
+ \r
+ def SetGuidValue(self, GuidValue):\r
+ self.GuidValue = GuidValue\r
+ def GetGuidValue(self):\r
+ return self.GuidValue\r
\r
##\r
#\r
if len(VerContent) < 2:\r
Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (VerContent[0]),\r
+ ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (VerContent[0], 2),\r
File=VerCurrentLine.GetFileName(),\r
Line=VerCurrentLine.GetLineNo(),\r
ExtraData=VerCurrentLine.GetLineString())\r
CurrentLineOfItem = Item[2]\r
GlobalData.gINF_CURRENT_LINE = CurrentLineOfItem\r
InfBianryCommonItemObj = None\r
- if len(ItemContent) < 2:\r
- Logger.Error("InfParser",\r
- ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (ItemContent[0]),\r
- File=CurrentLineOfItem.GetFileName(),\r
- Line=CurrentLineOfItem.GetLineNo(),\r
- ExtraData=CurrentLineOfItem.GetLineString())\r
- return False\r
- if len(ItemContent) > 6:\r
+ if ItemContent[0] == 'SUBTYPE_GUID':\r
+ if len(ItemContent) < 3:\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (ItemContent[0], 3),\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
+ return False\r
+ else:\r
+ if len(ItemContent) < 2:\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (ItemContent[0], 2),\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
+ return False\r
+ \r
+ if len(ItemContent) > 7:\r
Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (ItemContent[0], 6),\r
+ ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID_MAX % (ItemContent[0], 7),\r
File=CurrentLineOfItem.GetFileName(),\r
Line=CurrentLineOfItem.GetLineNo(),\r
ExtraData=CurrentLineOfItem.GetLineString())\r
BinaryFileType = ItemContent[0].strip()\r
if BinaryFileType == 'RAW' or BinaryFileType == 'ACPI' or BinaryFileType == 'ASL':\r
BinaryFileType = 'BIN'\r
-\r
+ \r
if BinaryFileType not in DT.BINARY_FILE_TYPE_LIST:\r
Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
\r
InfBianryCommonItemObj.SetType(BinaryFileType)\r
InfBianryCommonItemObj.SetCommonType(ItemContent[0])\r
+ FileName = ''\r
+ if BinaryFileType == 'FREEFORM':\r
+ InfBianryCommonItemObj.SetGuidValue(ItemContent[1])\r
+ if len(ItemContent) >= 3:\r
+ FileName = ItemContent[2]\r
+ else:\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_BINARY_ITEM_FILENAME_NOT_EXIST,\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
+ else:\r
+ FileName = ItemContent[1]\r
#\r
# Verify File exist or not\r
#\r
FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gINF_MODULE_DIR,\r
- ItemContent[1])))\r
- if not (ValidFile(FullFileName) or ValidFile(ItemContent[1])):\r
+ FileName)))\r
+ if not (ValidFile(FullFileName) or ValidFile(FileName)):\r
Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (ItemContent[1]),\r
+ ST.ERR_INF_PARSER_BINARY_ITEM_FILE_NOT_EXIST % (FileName),\r
File=CurrentLineOfItem.GetFileName(),\r
Line=CurrentLineOfItem.GetLineNo(),\r
ExtraData=CurrentLineOfItem.GetLineString())\r
#\r
# Validate file exist/format.\r
#\r
- if IsValidPath(ItemContent[1], GlobalData.gINF_MODULE_DIR):\r
+ if IsValidPath(FileName, GlobalData.gINF_MODULE_DIR):\r
IsValidFileFlag = True\r
else:\r
Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (ItemContent[1]),\r
+ ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID % (FileName),\r
File=CurrentLineOfItem.GetFileName(),\r
Line=CurrentLineOfItem.GetLineNo(),\r
ExtraData=CurrentLineOfItem.GetLineString())\r
return False\r
if IsValidFileFlag:\r
ItemContent[0] = ConvPathFromAbsToRel(ItemContent[0], GlobalData.gINF_MODULE_DIR)\r
- InfBianryCommonItemObj.SetFileName(ItemContent[1])\r
+ InfBianryCommonItemObj.SetFileName(FileName)\r
if len(ItemContent) >= 3:\r
#\r
# Add Target information\r
#\r
- InfBianryCommonItemObj.SetTarget(ItemContent[2])\r
+ if BinaryFileType != 'FREEFORM':\r
+ InfBianryCommonItemObj.SetTarget(ItemContent[2])\r
+ \r
if len(ItemContent) >= 4:\r
#\r
# Add Family information\r
#\r
- InfBianryCommonItemObj.SetFamily(ItemContent[3])\r
+ if BinaryFileType != 'FREEFORM':\r
+ InfBianryCommonItemObj.SetFamily(ItemContent[3])\r
+ else:\r
+ InfBianryCommonItemObj.SetTarget(ItemContent[3])\r
+ \r
if len(ItemContent) >= 5:\r
#\r
# TagName entries are build system specific. If there \r
# system specific content cannot be distributed using \r
# the UDP\r
#\r
- if ItemContent[4].strip() != '':\r
- Logger.Error("InfParser",\r
- ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_TAGNAME_NOT_PERMITTED % (ItemContent[4]),\r
- File=CurrentLineOfItem.GetFileName(),\r
- Line=CurrentLineOfItem.GetLineNo(),\r
- ExtraData=CurrentLineOfItem.GetLineString())\r
- if len(ItemContent) == 6:\r
+ if BinaryFileType != 'FREEFORM':\r
+ if ItemContent[4].strip() != '':\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_TAGNAME_NOT_PERMITTED % (ItemContent[4]),\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
+ else:\r
+ InfBianryCommonItemObj.SetFamily(ItemContent[4])\r
+ \r
+ if len(ItemContent) >= 6:\r
#\r
# Add FeatureFlagExp\r
#\r
- if ItemContent[5].strip() == '':\r
+ if BinaryFileType != 'FREEFORM':\r
+ if ItemContent[5].strip() == '':\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
+ #\r
+ # Validate Feature Flag Express \r
+ #\r
+ FeatureFlagRtv = IsValidFeatureFlagExp(ItemContent[5].strip())\r
+ if not FeatureFlagRtv[0]:\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
+ InfBianryCommonItemObj.SetFeatureFlagExp(ItemContent[5])\r
+ else:\r
+ if ItemContent[5].strip() != '':\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_TAGNAME_NOT_PERMITTED % (ItemContent[5]),\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
+ \r
+ if len(ItemContent) == 7:\r
+ if ItemContent[6].strip() == '':\r
Logger.Error("InfParser",\r
- ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,\r
- File=CurrentLineOfItem.GetFileName(),\r
- Line=CurrentLineOfItem.GetLineNo(),\r
- ExtraData=CurrentLineOfItem.GetLineString())\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,\r
+ File=CurrentLineOfItem.GetFileName(),\r
+ Line=CurrentLineOfItem.GetLineNo(),\r
+ ExtraData=CurrentLineOfItem.GetLineString())\r
#\r
# Validate Feature Flag Express \r
#\r
- FeatureFlagRtv = IsValidFeatureFlagExp(ItemContent[5].strip())\r
+ FeatureFlagRtv = IsValidFeatureFlagExp(ItemContent[6].strip())\r
if not FeatureFlagRtv[0]:\r
Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
File=CurrentLineOfItem.GetFileName(),\r
Line=CurrentLineOfItem.GetLineNo(),\r
ExtraData=CurrentLineOfItem.GetLineString())\r
- InfBianryCommonItemObj.SetFeatureFlagExp(ItemContent[5])\r
+ InfBianryCommonItemObj.SetFeatureFlagExp(ItemContent[6])\r
\r
InfBianryCommonItemObj.SetSupArchList(__SupArchList)\r
\r
if len(UiContent) < 2:\r
Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (UiContent[0]),\r
+ ST.ERR_INF_PARSER_BINARY_ITEM_FORMAT_INVALID % (UiContent[0], 2),\r
File=UiCurrentLine.GetFileName(),\r
Line=UiCurrentLine.GetLineNo(),\r
ExtraData=UiCurrentLine.GetLineString())\r
# This file is used to define class objects of INF file [BuildOptions] section. \r
# It will consumed by InfParser. \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
if len(BuildOptCont) >= 1:\r
InfBuildOptionItemObj = InfBuildOptionItem()\r
InfBuildOptionItemObj.SetAsBuildList(BuildOptCont)\r
+ InfBuildOptionItemObj.SetSupArchList(ArchList)\r
self.BuildOptions.append(InfBuildOptionItemObj)\r
- \r
\r
return True\r
\r
# This file is used to define class objects of [Defines] section for INF file. \r
# It will consumed by InfParser\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.Misc import CheckGuidRegFormat\r
from Library.Misc import Sdict\r
from Library.Misc import ConvPathFromAbsToRel\r
+from Library.Misc import ValidateUNIFilePath\r
from Library.ExpressionValidate import IsValidFeatureFlagExp \r
from Library.ParserValidate import IsValidWord\r
from Library.ParserValidate import IsValidInfMoudleType \r
self.BaseName = None\r
self.FileGuid = None\r
self.ModuleType = None\r
+ self.ModuleUniFileName = None\r
self.InfVersion = None\r
self.EdkReleaseVersion = None\r
self.UefiSpecificationVersion = None\r
if self.BaseName != None: \r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_BASE_NAME),\r
LineInfo=self.CurrentLine)\r
- return False \r
- \r
+ return False \r
if not (BaseName == '' or BaseName == None):\r
if IsValidWord(BaseName) and not BaseName.startswith("_"):\r
self.BaseName = InfDefMember()\r
def GetModuleType(self):\r
return self.ModuleType\r
\r
+ ## SetModuleUniFileName\r
+ #\r
+ # @param ModuleUniFileName: ModuleUniFileName\r
+ # \r
+ def SetModuleUniFileName(self, ModuleUniFileName, Comments):\r
+ if Comments:\r
+ pass\r
+ if self.ModuleUniFileName != None:\r
+ ErrorInInf(ST.ERR_INF_PARSER_DEFINE_ITEM_MORE_THAN_ONE_FOUND%(DT.TAB_INF_DEFINES_MODULE_UNI_FILE),\r
+ LineInfo=self.CurrentLine)\r
+ self.ModuleUniFileName = ModuleUniFileName\r
+\r
+ ## GetModuleType\r
+ # \r
+ def GetModuleUniFileName(self):\r
+ return self.ModuleUniFileName\r
+ \r
## SetInfVersion\r
#\r
# @param InfVersion: InfVersion\r
# It can be a list\r
#\r
ValueList = []\r
- \r
TokenList = GetSplitValueList(EntryPoint, DT.TAB_VALUE_SPLIT)\r
ValueList[0:len(TokenList)] = TokenList \r
- \r
InfDefineEntryPointItemObj = InfDefineEntryPointItem()\r
if not IsValidCVariableName(ValueList[0]):\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%\\r
if not FeatureFlagRtv[0]:\r
ErrorInInf(ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%\\r
(FeatureFlagRtv[1]),\r
- LineInfo=self.CurrentLine)\r
- \r
+ LineInfo=self.CurrentLine) \r
InfDefineEntryPointItemObj.SetFeatureFlagExp(ValueList[1]) \r
if len(ValueList) > 2:\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(EntryPoint),\r
LineInfo=self.CurrentLine)\r
- \r
InfDefineEntryPointItemObj.Comments = Comments \r
self.EntryPoint.append(InfDefineEntryPointItemObj) \r
\r
# It can be a list\r
#\r
ValueList = []\r
- \r
TokenList = GetSplitValueList(UnloadImages, DT.TAB_VALUE_SPLIT)\r
ValueList[0:len(TokenList)] = TokenList \r
- \r
InfDefineUnloadImageItemObj = InfDefineUnloadImageItem()\r
if not IsValidCVariableName(ValueList[0]):\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),\r
if len(ValueList) > 2:\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(UnloadImages),\r
LineInfo=self.CurrentLine)\r
- \r
InfDefineUnloadImageItemObj.Comments = Comments\r
self.UnloadImages.append(InfDefineUnloadImageItemObj)\r
\r
# It can be a list\r
#\r
ValueList = []\r
- \r
TokenList = GetSplitValueList(Constructor, DT.TAB_VALUE_SPLIT)\r
ValueList[0:len(TokenList)] = TokenList \r
- \r
InfDefineConstructorItemObj = InfDefineConstructorItem()\r
if not IsValidCVariableName(ValueList[0]):\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),\r
if len(ValueList) > 3:\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Constructor),\r
LineInfo=self.CurrentLine)\r
- \r
InfDefineConstructorItemObj.Comments = Comments \r
self.Constructor.append(InfDefineConstructorItemObj) \r
\r
# It can be a list and only 1 set to TRUE\r
# \r
ValueList = []\r
- \r
TokenList = GetSplitValueList(Destructor, DT.TAB_VALUE_SPLIT)\r
ValueList[0:len(TokenList)] = TokenList \r
- \r
InfDefineDestructorItemObj = InfDefineDestructorItem()\r
if not IsValidCVariableName(ValueList[0]):\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ValueList[0]),\r
def GetShadow(self):\r
return self.Shadow\r
\r
-\r
-\r
#\r
# <Family> ::= {"MSFT"} {"GCC"}\r
# <CustomMake> ::= [<Family> "|"] <Filename>\r
else: \r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(Name),\r
LineInfo=self.CurrentLine)\r
- return False\r
- \r
+ return False \r
return True\r
\r
def GetSpecification(self):\r
#\r
# Optional Fields\r
# \r
+ DT.TAB_INF_DEFINES_MODULE_UNI_FILE : InfDefSection.SetModuleUniFileName,\r
DT.TAB_INF_DEFINES_EDK_RELEASE_VERSION : InfDefSection.SetEdkReleaseVersion,\r
DT.TAB_INF_DEFINES_UEFI_SPECIFICATION_VERSION : InfDefSection.SetUefiSpecificationVersion,\r
DT.TAB_INF_DEFINES_PI_SPECIFICATION_VERSION : InfDefSection.SetPiSpecificationVersion,\r
self.Name = Name\r
self.Value = Value\r
self.CurrentLine = CurrentLine()\r
- \r
def GetName(self):\r
return self.Name\r
def SetName(self, Name):\r
#\r
HasFoundInfVersionFalg = False\r
LineInfo = ['', -1, '']\r
- ArchListString = ' '.join(Arch)\r
- \r
+ ArchListString = ' '.join(Arch) \r
#\r
# Parse Define items.\r
#\r
ProcessFunc = None\r
Name = InfDefMemberObj.GetName()\r
Value = InfDefMemberObj.GetValue()\r
+ if Name == DT.TAB_INF_DEFINES_MODULE_UNI_FILE:\r
+ ValidateUNIFilePath(Value)\r
+ Value = os.path.join(os.path.dirname(InfDefMemberObj.CurrentLine.FileName), Value)\r
+ if not os.path.isfile(Value) or not os.path.exists(Value):\r
+ LineInfo[0] = InfDefMemberObj.CurrentLine.GetFileName()\r
+ LineInfo[1] = InfDefMemberObj.CurrentLine.GetLineNo()\r
+ LineInfo[2] = InfDefMemberObj.CurrentLine.GetLineString()\r
+ ErrorInInf(ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(Name),\r
+ LineInfo=LineInfo)\r
InfLineCommentObj = InfLineCommentObject()\r
InfLineCommentObj.SetHeaderComments(InfDefMemberObj.Comments.GetHeaderComments())\r
InfLineCommentObj.SetTailComments(InfDefMemberObj.Comments.GetTailComments())\r
RaiseError=True)\r
if Name == DT.TAB_INF_DEFINES_INF_VERSION:\r
HasFoundInfVersionFalg = True \r
- \r
if not (Name == '' or Name == None):\r
#\r
# Process "SPEC" Keyword definition.\r
#\r
if Name not in gFUNCTION_MAPPING_FOR_DEFINE_SECTION.keys():\r
ErrorInInf(ST.ERR_INF_PARSER_DEFINE_SECTION_KEYWORD_INVALID%(Name),\r
- LineInfo=LineInfo) \r
- \r
+ LineInfo=LineInfo) \r
else:\r
ProcessFunc = gFUNCTION_MAPPING_FOR_DEFINE_SECTION[Name]\r
if (ProcessFunc != None):\r
if (ProcessFunc != None):\r
ProcessFunc(DefineList, Value, InfLineCommentObj)\r
self.Defines[ArchListString] = DefineList\r
- \r
#\r
# After set, check whether INF_VERSION defined.\r
#\r
# This file is used to define class objects of INF file [Guids] section. \r
# It will consumed by InfParser. \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
# \r
if CommentItemUsage == CommentItemGuidType == PreUsage == PreGuidType == DT.ITEM_UNDEFINED:\r
CommentItemHelpText = PreHelpText + DT.END_OF_LINE + CommentItemHelpText\r
- \r
PreHelpText = CommentItemHelpText\r
\r
if BlockFlag == 4: \r
CommentItemIns.SetUsageItem(CommentItemUsage)\r
CommentItemIns.SetGuidTypeItem(CommentItemGuidType)\r
CommentItemIns.SetVariableNameItem(CommentItemVarString)\r
+ if CommentItemHelpText == '' or CommentItemHelpText.endswith(DT.END_OF_LINE):\r
+ CommentItemHelpText = CommentItemHelpText.strip(DT.END_OF_LINE)\r
CommentItemIns.SetHelpStringItem(CommentItemHelpText)\r
CommentInsList.append(CommentItemIns)\r
\r
CommentItemIns.SetUsageItem(DT.ITEM_UNDEFINED)\r
CommentItemIns.SetGuidTypeItem(DT.ITEM_UNDEFINED)\r
if PreHelpText == '' or PreHelpText.endswith(DT.END_OF_LINE):\r
- PreHelpText += DT.END_OF_LINE\r
+ PreHelpText = PreHelpText.strip(DT.END_OF_LINE)\r
CommentItemIns.SetHelpStringItem(PreHelpText)\r
CommentInsList.append(CommentItemIns)\r
#\r
CommentItemIns.SetUsageItem(CommentItemUsage)\r
CommentItemIns.SetGuidTypeItem(CommentItemGuidType)\r
CommentItemIns.SetVariableNameItem(CommentItemVarString)\r
+ if CommentItemHelpText == '' or CommentItemHelpText.endswith(DT.END_OF_LINE):\r
+ CommentItemHelpText = CommentItemHelpText.strip(DT.END_OF_LINE)\r
CommentItemIns.SetHelpStringItem(CommentItemHelpText)\r
CommentInsList.append(CommentItemIns)\r
\r
# This file is used to define class objects of INF file [LibraryClasses] section. \r
# It will consumed by InfParser. \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
#\r
LibItemObj.SetFileGuid(LibItem[0])\r
LibItemObj.SetVersion(LibItem[1])\r
+ LibItemObj.SetSupArchList(__SupArchList)\r
\r
if self.LibraryClasses.has_key((LibItemObj)):\r
LibraryList = self.LibraryClasses[LibItemObj]\r
# This file is used to define class objects of INF file [Pcds] section. \r
# It will consumed by InfParser. \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Logger import StringTable as ST\r
from Logger import ToolError\r
import Logger.Log as Logger\r
-from Library import GlobalData \r
+from Library import GlobalData\r
from Library import DataType as DT\r
\r
from Library.Misc import Sdict\r
from Library.Misc import GetHelpStringByRemoveHashKey\r
-from Library.ParserValidate import IsValidPcdType \r
+from Library.ParserValidate import IsValidPcdType\r
from Library.ParserValidate import IsValidCVariableName\r
from Library.ParserValidate import IsValidPcdValue\r
from Library.ParserValidate import IsValidArch\r
# \r
if (ArchItem == '' or ArchItem == None):\r
ArchItem = 'COMMON'\r
- \r
+\r
if PcdTypeItem1.upper != DT.TAB_INF_FEATURE_PCD.upper():\r
ArchList = GetSplitValueList(ArchItem, ' ')\r
for ArchItemNew in ArchList:\r
if not IsValidArch(ArchItemNew):\r
- Logger.Error("InfParser", \r
+ Logger.Error("InfParser",\r
ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID%(ArchItemNew), \r
+ ST.ERR_INF_PARSER_DEFINE_FROMAT_INVALID % (ArchItemNew),\r
File=GlobalData.gINF_MODULE_NAME,\r
- Line=LineNo, \r
+ Line=LineNo,\r
ExtraData=ArchItemNew)\r
- SupArchDict[PcdTypeItem1] = ArchList \r
+ SupArchDict[PcdTypeItem1] = ArchList\r
else:\r
SupArchList.append(ArchItem)\r
- \r
+\r
return SupArchList, SupArchDict\r
\r
def ParsePcdComment(CommentList, PcdTypeItem, PcdItemObj):\r
PreHelpText = ''\r
BlockFlag = -1\r
FFEHelpText = ''\r
- CommentItemHelpText = '' \r
- Count = 0 \r
+ CommentItemHelpText = ''\r
+ Count = 0\r
for CommentItem in CommentList:\r
Count = Count + 1\r
- CommentItemUsage, CommentType, CommentString, CommentItemHelpText = ParseComment(CommentItem, \r
- DT.ALL_USAGE_TOKENS, \r
- {}, \r
+ CommentItemUsage, CommentType, CommentString, CommentItemHelpText = ParseComment(CommentItem,\r
+ DT.ALL_USAGE_TOKENS,\r
+ {},\r
[],\r
False)\r
if CommentType and CommentString:\r
- pass \r
- \r
+ pass\r
+\r
if PcdTypeItem == 'FeaturePcd':\r
CommentItemUsage = DT.USAGE_ITEM_CONSUMES\r
if CommentItemHelpText == None:\r
CommentItemHelpText = ''\r
- \r
+\r
if Count == 1:\r
FFEHelpText = CommentItemHelpText\r
else:\r
FFEHelpText = FFEHelpText + DT.END_OF_LINE + CommentItemHelpText\r
- \r
+\r
if Count == len(CommentList):\r
CommentItemHelpText = FFEHelpText\r
BlockFlag = 4\r
else:\r
continue\r
- \r
+\r
if CommentItemHelpText == None:\r
CommentItemHelpText = ''\r
if Count == len(CommentList) and CommentItemUsage == DT.ITEM_UNDEFINED:\r
CommentItemHelpText = DT.END_OF_LINE\r
- \r
+\r
if Count == len(CommentList) and (BlockFlag == 1 or BlockFlag == 2):\r
if CommentItemUsage == DT.ITEM_UNDEFINED:\r
BlockFlag = 4\r
else:\r
BlockFlag = 3\r
elif BlockFlag == -1 and Count == len(CommentList):\r
- BlockFlag = 4 \r
- \r
+ BlockFlag = 4\r
+\r
if BlockFlag == -1 or BlockFlag == 1 or BlockFlag == 2:\r
if CommentItemUsage == DT.ITEM_UNDEFINED:\r
if BlockFlag == -1:\r
# \r
if CommentItemUsage == PreUsage == DT.ITEM_UNDEFINED:\r
CommentItemHelpText = PreHelpText + DT.END_OF_LINE + CommentItemHelpText\r
- \r
+\r
PreHelpText = CommentItemHelpText\r
- \r
- if BlockFlag == 4: \r
+\r
+ if BlockFlag == 4:\r
CommentItemIns = InfPcdItemCommentContent()\r
CommentItemIns.SetUsageItem(CommentItemUsage)\r
CommentItemIns.SetHelpStringItem(CommentItemHelpText)\r
CommentInsList.append(CommentItemIns)\r
- \r
+\r
BlockFlag = -1\r
PreUsage = None\r
PreHelpText = ''\r
- \r
+\r
elif BlockFlag == 3:\r
#\r
# Add previous help string\r
CommentItemIns = InfPcdItemCommentContent()\r
CommentItemIns.SetUsageItem(DT.ITEM_UNDEFINED)\r
if PreHelpText == '' or PreHelpText.endswith(DT.END_OF_LINE):\r
- PreHelpText += DT.END_OF_LINE \r
+ PreHelpText += DT.END_OF_LINE\r
CommentItemIns.SetHelpStringItem(PreHelpText)\r
CommentInsList.append(CommentItemIns)\r
#\r
CommentItemIns.SetUsageItem(CommentItemUsage)\r
CommentItemIns.SetHelpStringItem(CommentItemHelpText)\r
CommentInsList.append(CommentItemIns)\r
- \r
+\r
BlockFlag = -1\r
PreUsage = None\r
- PreHelpText = '' \r
- \r
+ PreHelpText = ''\r
+\r
else:\r
PreUsage = CommentItemUsage\r
PreHelpText = CommentItemHelpText\r
- \r
+\r
PcdItemObj.SetHelpStringList(CommentInsList)\r
- \r
- return PcdItemObj \r
+\r
+ return PcdItemObj\r
\r
class InfPcdItemCommentContent():\r
def __init__(self):\r
# Help String\r
#\r
self.HelpStringItem = ''\r
- \r
+\r
def SetUsageItem(self, UsageItem):\r
self.UsageItem = UsageItem\r
def GetUsageItem(self):\r
return self.UsageItem\r
- \r
+\r
def SetHelpStringItem(self, HelpStringItem):\r
self.HelpStringItem = HelpStringItem\r
def GetHelpStringItem(self):\r
return self.HelpStringItem\r
- \r
+\r
## InfPcdItem\r
#\r
# This class defined Pcd item used in Module files\r
self.Token = ''\r
self.TokenSpaceGuidCName = ''\r
self.TokenSpaceGuidValue = ''\r
- self.DatumType = ''\r
- self.MaxDatumSize = ''\r
- self.DefaultValue = ''\r
- self.Offset = ''\r
- self.ValidUsage = ''\r
- self.ItemType = '' \r
- self.SupModuleList = []\r
+ self.DatumType = ''\r
+ self.MaxDatumSize = ''\r
+ self.DefaultValue = ''\r
+ self.Offset = ''\r
+ self.ValidUsage = ''\r
+ self.ItemType = ''\r
+ self.SupModuleList = []\r
self.HelpStringList = []\r
self.FeatureFlagExp = ''\r
- self.SupArchList = []\r
+ self.SupArchList = []\r
self.PcdErrorsList = []\r
- \r
+\r
def SetCName(self, CName):\r
- self.CName = CName \r
+ self.CName = CName\r
def GetCName(self):\r
return self.CName\r
- \r
+\r
def SetToken(self, Token):\r
- self.Token = Token \r
+ self.Token = Token\r
def GetToken(self):\r
return self.Token\r
- \r
+\r
def SetTokenSpaceGuidCName(self, TokenSpaceGuidCName):\r
- self.TokenSpaceGuidCName = TokenSpaceGuidCName \r
+ self.TokenSpaceGuidCName = TokenSpaceGuidCName\r
def GetTokenSpaceGuidCName(self):\r
return self.TokenSpaceGuidCName\r
- \r
+\r
def SetTokenSpaceGuidValue(self, TokenSpaceGuidValue):\r
- self.TokenSpaceGuidValue = TokenSpaceGuidValue \r
+ self.TokenSpaceGuidValue = TokenSpaceGuidValue\r
def GetTokenSpaceGuidValue(self):\r
return self.TokenSpaceGuidValue\r
- \r
+\r
def SetDatumType(self, DatumType):\r
- self.DatumType = DatumType \r
+ self.DatumType = DatumType\r
def GetDatumType(self):\r
return self.DatumType\r
- \r
+\r
def SetMaxDatumSize(self, MaxDatumSize):\r
- self.MaxDatumSize = MaxDatumSize \r
+ self.MaxDatumSize = MaxDatumSize\r
def GetMaxDatumSize(self):\r
return self.MaxDatumSize\r
\r
def SetDefaultValue(self, DefaultValue):\r
- self.DefaultValue = DefaultValue \r
+ self.DefaultValue = DefaultValue\r
def GetDefaultValue(self):\r
return self.DefaultValue\r
- \r
+\r
def SetPcdErrorsList(self, PcdErrorsList):\r
- self.PcdErrorsList = PcdErrorsList \r
+ self.PcdErrorsList = PcdErrorsList\r
def GetPcdErrorsList(self):\r
return self.PcdErrorsList\r
\r
def SetItemType(self, ItemType):\r
- self.ItemType = ItemType \r
+ self.ItemType = ItemType\r
def GetItemType(self):\r
return self.ItemType\r
\r
def SetSupModuleList(self, SupModuleList):\r
- self.SupModuleList = SupModuleList \r
+ self.SupModuleList = SupModuleList\r
def GetSupModuleList(self):\r
return self.SupModuleList\r
- \r
+\r
def SetHelpStringList(self, HelpStringList):\r
self.HelpStringList = HelpStringList\r
def GetHelpStringList(self):\r
return self.HelpStringList\r
- \r
+\r
def SetFeatureFlagExp(self, FeatureFlagExp):\r
self.FeatureFlagExp = FeatureFlagExp\r
def GetFeatureFlagExp(self):\r
return self.FeatureFlagExp\r
- \r
+\r
def SetSupportArchList(self, ArchList):\r
self.SupArchList = ArchList\r
def GetSupportArchList(self):\r
return self.SupArchList\r
- \r
+\r
def SetOffset(self, Offset):\r
self.Offset = Offset\r
def GetOffset(self):\r
return self.Offset\r
\r
+ def SetValidUsage(self, ValidUsage):\r
+ self.ValidUsage = ValidUsage\r
+\r
+ def GetValidUsage(self):\r
+ return self.ValidUsage\r
+\r
##\r
#\r
#\r
def __init__(self, FileName):\r
self.Pcds = Sdict()\r
self.FileName = FileName\r
- \r
- def SetPcds(self, PcdContent, KeysList = None, PackageInfo = None):\r
- \r
+\r
+ def SetPcds(self, PcdContent, KeysList=None, PackageInfo=None):\r
+\r
if GlobalData.gIS_BINARY_INF:\r
self.SetAsBuildPcds(PcdContent, KeysList, PackageInfo)\r
return True\r
- \r
+\r
#\r
# Validate Arch\r
#\r
PcdTypeItem = ''\r
for (PcdTypeItem1, ArchItem, LineNo) in KeysList:\r
SupArchList, SupArchDict = ValidateArch(ArchItem, PcdTypeItem1, LineNo, SupArchDict, SupArchList)\r
- \r
+\r
#\r
# Validate PcdType\r
#\r
return False\r
else:\r
if not IsValidPcdType(PcdTypeItem1):\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
- ST.ERR_INF_PARSER_PCD_SECTION_TYPE_ERROR%(DT.PCD_USAGE_TYPE_LIST_OF_MODULE),\r
- File=GlobalData.gINF_MODULE_NAME, \r
- Line=LineNo, \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_PCD_SECTION_TYPE_ERROR % (DT.PCD_USAGE_TYPE_LIST_OF_MODULE),\r
+ File=GlobalData.gINF_MODULE_NAME,\r
+ Line=LineNo,\r
ExtraData=PcdTypeItem1)\r
return False\r
- \r
+\r
PcdTypeItem = PcdTypeItem1\r
- \r
+\r
for PcdItem in PcdContent:\r
PcdItemObj = InfPcdItem()\r
CommentList = PcdItem[1]\r
CurrentLineOfPcdItem = PcdItem[2]\r
PcdItem = PcdItem[0]\r
- \r
+\r
if CommentList != None and len(CommentList) != 0:\r
PcdItemObj = ParsePcdComment(CommentList, PcdTypeItem, PcdItemObj)\r
else:\r
CommentItemIns = InfPcdItemCommentContent()\r
CommentItemIns.SetUsageItem(DT.ITEM_UNDEFINED)\r
PcdItemObj.SetHelpStringList([CommentItemIns])\r
- \r
+\r
if len(PcdItem) >= 1 and len(PcdItem) <= 3:\r
PcdItemObj = SetPcdName(PcdItem, CurrentLineOfPcdItem, PcdItemObj)\r
- \r
+\r
if len(PcdItem) >= 2 and len(PcdItem) <= 3:\r
#\r
# Contain PcdName and Value, validate value.\r
if IsValidPcdValue(PcdItem[1]) or PcdItem[1].strip() == "":\r
PcdItemObj.SetDefaultValue(PcdItem[1])\r
else:\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
ST.ERR_INF_PARSER_PCD_VALUE_INVALID,\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=PcdItem[1])\r
- \r
+\r
if len(PcdItem) == 3:\r
#\r
# Contain PcdName, value, and FeatureFlag express\r
# Validate Feature Flag Express\r
#\r
if PcdItem[2].strip() == '':\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_MISSING,\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=CurrentLineOfPcdItem[0])\r
#\r
# Validate FFE \r
#\r
FeatureFlagRtv = IsValidFeatureFlagExp(PcdItem[2].strip())\r
if not FeatureFlagRtv[0]:\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
- ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID%(FeatureFlagRtv[1]),\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_FEATURE_FLAG_EXP_SYNTAX_INVLID % (FeatureFlagRtv[1]),\r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=CurrentLineOfPcdItem[0])\r
PcdItemObj.SetFeatureFlagExp(PcdItem[2])\r
- \r
+\r
if len(PcdItem) < 1 or len(PcdItem) > 3:\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
ST.ERR_INF_PARSER_PCD_SECTION_CONTENT_ERROR,\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=CurrentLineOfPcdItem[0])\r
- return False \r
- \r
+ return False\r
+\r
if PcdTypeItem.upper != DT.TAB_INF_FEATURE_PCD.upper():\r
PcdItemObj.SetSupportArchList(SupArchDict[PcdTypeItem])\r
else:\r
PcdItemObj.SetSupportArchList(SupArchList)\r
- \r
- if self.Pcds.has_key((PcdTypeItem, PcdItemObj)): \r
+\r
+ if self.Pcds.has_key((PcdTypeItem, PcdItemObj)):\r
PcdsList = self.Pcds[PcdTypeItem, PcdItemObj]\r
PcdsList.append(PcdItemObj)\r
self.Pcds[PcdTypeItem, PcdItemObj] = PcdsList\r
PcdsList = []\r
PcdsList.append(PcdItemObj)\r
self.Pcds[PcdTypeItem, PcdItemObj] = PcdsList\r
- \r
+\r
return True\r
- \r
- def SetAsBuildPcds(self, PcdContent, KeysList = None, PackageInfo = None):\r
+\r
+ def SetAsBuildPcds(self, PcdContent, KeysList=None, PackageInfo=None):\r
for PcdItem in PcdContent:\r
PcdItemObj = InfPcdItem()\r
CommentList = PcdItem[1]\r
CurrentLineOfPcdItem = PcdItem[2]\r
PcdItem = PcdItem[0]\r
CommentString = ''\r
- for CommmentLine in CommentList:\r
- CommentString += GetHelpStringByRemoveHashKey(CommmentLine)\r
- \r
- PcdItemObj.SetHelpStringList(CommentString)\r
+\r
+ for CommentLine in CommentList:\r
+ CommentString = GetHelpStringByRemoveHashKey(CommentLine)\r
+ CommentItemIns = InfPcdItemCommentContent()\r
+ CommentItemIns.SetHelpStringItem(CommentString)\r
+ CommentItemIns.SetUsageItem(CommentString)\r
+ PcdItemObj.SetHelpStringList(PcdItemObj.GetHelpStringList() + [CommentItemIns])\r
+ if PcdItemObj.GetValidUsage():\r
+ PcdItemObj.SetValidUsage(PcdItemObj.GetValidUsage() + DT.TAB_VALUE_SPLIT + CommentString)\r
+ else:\r
+ PcdItemObj.SetValidUsage(CommentString)\r
+\r
PcdItemObj.SetItemType(KeysList[0][0])\r
#\r
# Set PcdTokenSpaceCName and CName\r
#\r
- PcdItemObj = SetPcdName(PcdItem, CurrentLineOfPcdItem, PcdItemObj) \r
+ PcdItemObj = SetPcdName(PcdItem, CurrentLineOfPcdItem, PcdItemObj)\r
#\r
- # Set Value/DatumType/MaxDatumSize/Token\r
+ # Set Value/DatumType/OffSet/Token\r
#\r
- PcdItemObj = SetValueDatumTypeMaxSizeToken(PcdItem, \r
- CurrentLineOfPcdItem, \r
+ PcdItemObj = SetValueDatumTypeMaxSizeToken(PcdItem,\r
+ CurrentLineOfPcdItem,\r
PcdItemObj,\r
KeysList[0][1],\r
PackageInfo)\r
- \r
+\r
PcdTypeItem = KeysList[0][0]\r
- if self.Pcds.has_key((PcdTypeItem, PcdItemObj)): \r
+ if self.Pcds.has_key((PcdTypeItem, PcdItemObj)):\r
PcdsList = self.Pcds[PcdTypeItem, PcdItemObj]\r
PcdsList.append(PcdItemObj)\r
self.Pcds[PcdTypeItem, PcdItemObj] = PcdsList\r
else:\r
PcdsList = []\r
PcdsList.append(PcdItemObj)\r
- self.Pcds[PcdTypeItem, PcdItemObj] = PcdsList \r
- \r
+ self.Pcds[PcdTypeItem, PcdItemObj] = PcdsList\r
+\r
def GetPcds(self):\r
return self.Pcds\r
\r
def ParserPcdInfoInDec(String):\r
ValueList = GetSplitValueList(String, DT.TAB_VALUE_SPLIT, 3)\r
- \r
+\r
#\r
# DatumType, Token\r
#\r
return ValueList[2], ValueList[3]\r
\r
-def SetValueDatumTypeMaxSizeToken(PcdItem, CurrentLineOfPcdItem, PcdItemObj, Arch, PackageInfo = None):\r
+def SetValueDatumTypeMaxSizeToken(PcdItem, CurrentLineOfPcdItem, PcdItemObj, Arch, PackageInfo=None):\r
#\r
# Package information not been generated currently, we need to parser INF file to get information. \r
#\r
# Open DEC file to get information\r
#\r
FullFileName = os.path.normpath(os.path.realpath(os.path.join(GlobalData.gWORKSPACE, PackageName)))\r
- \r
- DecParser = Dec(FullFileName)\r
+\r
+ DecParser = None\r
+ if FullFileName not in GlobalData.gPackageDict:\r
+ DecParser = Dec(FullFileName)\r
+ GlobalData.gPackageDict[FullFileName] = DecParser\r
+ else:\r
+ DecParser = GlobalData.gPackageDict[FullFileName]\r
+\r
#\r
# Find PCD information. \r
#\r
PcdItemObj.SetToken(PcdInDec.TokenValue)\r
PcdItemObj.SetDatumType(PcdInDec.DatumType)\r
PcdItemObj.SetSupportArchList([Arch])\r
- \r
+ PcdItemObj.SetDefaultValue(PcdInDec.DefaultValue)\r
+\r
if (Key[0] == 'PCDSPATCHABLEINMODULE' and PcdItemObj.GetItemType() == 'PatchPcd') and \\r
(Key[1] == 'COMMON' or Key[1] == Arch):\r
for PcdInDec in DecPcdsDict[Key]:\r
PcdInDec.TokenSpaceGuidCName == PcdItemObj.TokenSpaceGuidCName:\r
PcdItemObj.SetToken(PcdInDec.TokenValue)\r
PcdItemObj.SetDatumType(PcdInDec.DatumType)\r
- PcdItemObj.SetSupportArchList([Arch]) \r
- \r
+ PcdItemObj.SetSupportArchList([Arch])\r
+\r
if PcdItemObj.GetDatumType() == 'VOID*':\r
- PcdItemObj.SetMaxDatumSize('%s'%(len(GetSplitValueList(PcdItem[1], DT.TAB_COMMA_SPLIT))))\r
- \r
+ if len(PcdItem) > 1:\r
+ PcdItemObj.SetMaxDatumSize('%s' % (len(GetSplitValueList(PcdItem[1], DT.TAB_COMMA_SPLIT))))\r
+\r
DecGuidsDict = DecParser.GetGuidSectionObject().ValueDict\r
for Key in DecGuidsDict.keys():\r
if Key == 'COMMON' or Key == Arch:\r
if GuidInDec.GuidCName == PcdItemObj.TokenSpaceGuidCName:\r
PcdItemObj.SetTokenSpaceGuidValue(GuidInDec.GuidString)\r
\r
- #\r
- # Validate Value.\r
- #\r
- if ValidatePcdValueOnDatumType(PcdItem[1], PcdItemObj.GetDatumType()): \r
- PcdItemObj.SetDefaultValue(PcdItem[1])\r
- else:\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
- ST.ERR_ASBUILD_PCD_VALUE_INVALID%("\"" + PcdItem[1] + "\"", "\"" + \r
- PcdItemObj.GetDatumType() + "\""),\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
- ExtraData=CurrentLineOfPcdItem[0]) \r
- #\r
- # validate offset\r
- #\r
if PcdItemObj.GetItemType().upper() == DT.TAB_INF_PATCH_PCD.upper():\r
- if not IsHexDigitUINT32(PcdItem[2]):\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
- ST.ERR_ASBUILD_PCD_OFFSET_FORMAT_INVALID%("\"" + PcdItem[2] + "\""),\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
- ExtraData=CurrentLineOfPcdItem[0]) \r
- PcdItemObj.SetOffset(PcdItem[2])\r
- \r
+ #\r
+ # Validate Value.\r
+ #\r
+ # convert the value from a decimal 0 to a formatted hex value.\r
+ if PcdItem[1] == "0":\r
+ DatumType = PcdItemObj.GetDatumType()\r
+ if DatumType == "UINT8":\r
+ PcdItem[1] = "0x00"\r
+ if DatumType == "UINT16":\r
+ PcdItem[1] = "0x0000"\r
+ if DatumType == "UINT32":\r
+ PcdItem[1] = "0x00000000"\r
+ if DatumType == "UINT64":\r
+ PcdItem[1] = "0x0000000000000000"\r
+\r
+ if ValidatePcdValueOnDatumType(PcdItem[1], PcdItemObj.GetDatumType()):\r
+ PcdItemObj.SetDefaultValue(PcdItem[1])\r
+ else:\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_ASBUILD_PCD_VALUE_INVALID % ("\"" + PcdItem[1] + "\"", "\"" +\r
+ PcdItemObj.GetDatumType() + "\""),\r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
+ ExtraData=CurrentLineOfPcdItem[0])\r
+ #\r
+ # validate offset\r
+ #\r
+ if PcdItemObj.GetItemType().upper() == DT.TAB_INF_PATCH_PCD.upper():\r
+ if not IsHexDigitUINT32(PcdItem[2]):\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_ASBUILD_PCD_OFFSET_FORMAT_INVALID % ("\"" + PcdItem[2] + "\""),\r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
+ ExtraData=CurrentLineOfPcdItem[0])\r
+ PcdItemObj.SetOffset(PcdItem[2])\r
+\r
if PcdItemObj.GetToken() == '' or PcdItemObj.GetDatumType() == '':\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
- ST.ERR_ASBUILD_PCD_DECLARITION_MISS%("\"" + PcdItem[0] + "\""),\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
+ ST.ERR_ASBUILD_PCD_DECLARITION_MISS % ("\"" + PcdItem[0] + "\""),\r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=CurrentLineOfPcdItem[0])\r
- \r
+\r
return PcdItemObj\r
\r
def ValidatePcdValueOnDatumType(Value, Type):\r
- \r
+\r
Value = Value.strip()\r
#\r
# Boolean type only allow 0x00 or 0x01 as value per INF spec\r
#\r
if Type == 'BOOLEAN':\r
if not (Value == '0x00' or Value == '0x01'):\r
- return False \r
+ return False\r
elif Type == 'VOID*':\r
if not Value.startswith("{"):\r
return False\r
#\r
# Strip "{" at head and "}" at tail.\r
#\r
- Value = Value[1:-1] \r
+ Value = Value[1:-1]\r
ValueList = GetSplitValueList(Value, DT.TAB_COMMA_SPLIT)\r
- \r
+\r
ReIsValidHexByte = re.compile("^0x[0-9a-f]{1,2}$", re.IGNORECASE)\r
for ValueItem in ValueList:\r
if not ReIsValidHexByte.match(ValueItem):\r
return False\r
- \r
+\r
elif Type == 'UINT8' or Type == 'UINT16' or Type == 'UINT32' or Type == 'UINT64':\r
- \r
+\r
ReIsValidUint8z = re.compile('^0[x|X][a-fA-F0-9]{2}$')\r
ReIsValidUint16z = re.compile('^0[x|X][a-fA-F0-9]{4}$')\r
ReIsValidUint32z = re.compile('^0[x|X][a-fA-F0-9]{8}$')\r
ReIsValidUint64z = re.compile('^0[x|X][a-fA-F0-9]{16}$')\r
- \r
+\r
if not ReIsValidUint8z.match(Value) and Type == 'UINT8':\r
- return False \r
+ return False\r
elif not ReIsValidUint16z.match(Value) and Type == 'UINT16':\r
return False\r
elif not ReIsValidUint32z.match(Value) and Type == 'UINT32':\r
# Since we assume the DEC file always correct, should never go to here.\r
#\r
pass\r
- \r
- return True \r
- \r
+\r
+ return True\r
+\r
def SetPcdName(PcdItem, CurrentLineOfPcdItem, PcdItemObj):\r
#\r
# Only PCD Name specified \r
# <PcdName> ::= <TokenSpaceGuidCName> "." <TokenCName>\r
#\r
PcdId = GetSplitValueList(PcdItem[0], DT.TAB_SPLIT)\r
- if len(PcdId) != 2: \r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
+ if len(PcdId) != 2:\r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
ST.ERR_INF_PARSER_PCD_NAME_FORMAT_ERROR,\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=CurrentLineOfPcdItem[0])\r
else:\r
#\r
# Validate PcdTokenSpaceGuidCName\r
#\r
if not IsValidCVariableName(PcdId[0]):\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
ST.ERR_INF_PARSER_PCD_CVAR_GUID,\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=PcdId[0])\r
if not IsValidCVariableName(PcdId[1]):\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID, \r
+ Logger.Error("InfParser",\r
+ ToolError.FORMAT_INVALID,\r
ST.ERR_INF_PARSER_PCD_CVAR_PCDCNAME,\r
- File=CurrentLineOfPcdItem[2], \r
- Line=CurrentLineOfPcdItem[1], \r
+ File=CurrentLineOfPcdItem[2],\r
+ Line=CurrentLineOfPcdItem[1],\r
ExtraData=PcdId[1])\r
PcdItemObj.SetTokenSpaceGuidCName(PcdId[0])\r
PcdItemObj.SetCName(PcdId[1])\r
- \r
- return PcdItemObj
\ No newline at end of file
+\r
+ return PcdItemObj\r
## @file\r
# This file is used to parse DEC file. It will consumed by DecParser\r
#\r
-# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.String import GetSplitValueList\r
from Library.String import gMACRO_PATTERN\r
from Library.String import ConvertSpecialChar\r
+from Library.CommentParsing import ParsePcdErrorCode\r
\r
##\r
# _DecBase class for parsing\r
def GetDataObject(self):\r
return self.ItemObject\r
\r
+ def GetLocalMacro(self):\r
+ return self._LocalMacro\r
+ \r
## BlockStart\r
#\r
# Called if a new section starts\r
self._LocalMacro[TokenList[0]] = ''\r
else:\r
self._LocalMacro[TokenList[0]] = self._ReplaceMacro(TokenList[1])\r
- \r
+\r
## _ParseItem\r
#\r
# Parse specified item, this function must be derived by subclass\r
DT.TAB_DEC_DEFINES_PACKAGE_NAME : self._SetPackageName,\r
DT.TAB_DEC_DEFINES_PACKAGE_GUID : self._SetPackageGuid,\r
DT.TAB_DEC_DEFINES_PACKAGE_VERSION : self._SetPackageVersion,\r
+ DT.TAB_DEC_DEFINES_PKG_UNI_FILE : self._SetPackageUni,\r
}\r
\r
def BlockStart(self):\r
Line = self._RawData.CurrentLine\r
TokenList = GetSplitValueList(Line, DT.TAB_EQUAL_SPLIT, 1)\r
if TokenList[0] == DT.TAB_DEC_DEFINES_PKG_UNI_FILE:\r
- pass\r
+ self.DefineValidation[TokenList[0]](TokenList[1])\r
elif len(TokenList) < 2:\r
self._LoggerError(ST.ERR_DECPARSE_DEFINE_FORMAT)\r
elif TokenList[0] not in self.DefineValidation:\r
self.DefineValidation[TokenList[0]](TokenList[1])\r
\r
DefineItem = DecDefineItemObject()\r
- if TokenList[0] != DT.TAB_DEC_DEFINES_PKG_UNI_FILE:\r
- DefineItem.Key = TokenList[0]\r
- DefineItem.Value = TokenList[1]\r
- self.ItemObject.AddItem(DefineItem, self._RawData.CurrentScope)\r
+ DefineItem.Key = TokenList[0]\r
+ DefineItem.Value = TokenList[1]\r
+ self.ItemObject.AddItem(DefineItem, self._RawData.CurrentScope)\r
return DefineItem\r
\r
def _SetDecSpecification(self, Token):\r
else:\r
if not DT.TAB_SPLIT in Token:\r
Token = Token + '.0'\r
- self.ItemObject._PkgVersion = Token\r
+ self.ItemObject.SetPackageVersion(Token)\r
+ \r
+ def _SetPackageUni(self, Token):\r
+ if self.ItemObject.GetPackageUniFile():\r
+ self._LoggerError(ST.ERR_DECPARSE_DEFINE_DEFINED % DT.TAB_DEC_DEFINES_PKG_UNI_FILE)\r
+ self.ItemObject.SetPackageUniFile(Token)\r
\r
## _DecInclude\r
#\r
class Dec(_DecBase, _DecComments): \r
def __init__(self, DecFile, Parse = True): \r
try:\r
- Content = ConvertSpecialChar(open(DecFile, 'rb').readlines())\r
+ Content = ConvertSpecialChar(open(DecFile, 'rb').readlines())\r
except BaseException:\r
Logger.Error(TOOL_NAME, FILE_OPEN_FAILURE, File=DecFile,\r
ExtraData=ST.ERR_DECPARSE_FILEOPEN % DecFile)\r
_DecComments.__init__(self)\r
_DecBase.__init__(self, RawData)\r
\r
- self.BinaryHeadComment = [] \r
+ self.BinaryHeadComment = []\r
+ self.PcdErrorCommentDict = {}\r
+ \r
self._Define = _DecDefine(RawData)\r
self._Include = _DecInclude(RawData)\r
self._Guid = _DecGuid(RawData)\r
if not SectionParser.CheckRequiredFields():\r
return False\r
return True\r
- \r
+\r
##\r
# Parse DEC file\r
#\r
IsBinaryHeader = False\r
FileHeaderLineIndex = -1\r
BinaryHeaderLineIndex = -1\r
+ TokenSpaceGuidCName = ''\r
+ \r
+ #\r
+ # Parse PCD error comment section\r
+ #\r
while not self._RawData.IsEndOfFile():\r
- Line, Comment = CleanString(self._RawData.GetNextLine())\r
+ self._RawData.CurrentLine = self._RawData.GetNextLine()\r
+ if self._RawData.CurrentLine.startswith(DT.TAB_COMMENT_SPLIT) and \\r
+ DT.TAB_SECTION_START in self._RawData.CurrentLine and \\r
+ DT.TAB_SECTION_END in self._RawData.CurrentLine:\r
+ self._RawData.CurrentLine = self._RawData.CurrentLine.replace(DT.TAB_COMMENT_SPLIT, '').strip()\r
\r
+ if self._RawData.CurrentLine[0] == DT.TAB_SECTION_START and \\r
+ self._RawData.CurrentLine[-1] == DT.TAB_SECTION_END:\r
+ RawSection = self._RawData.CurrentLine[1:-1].strip()\r
+ if RawSection.upper().startswith(DT.TAB_PCD_ERROR.upper()+'.'):\r
+ TokenSpaceGuidCName = RawSection.split(DT.TAB_PCD_ERROR+'.')[1].strip()\r
+ continue\r
+\r
+ if TokenSpaceGuidCName and self._RawData.CurrentLine.startswith(DT.TAB_COMMENT_SPLIT):\r
+ self._RawData.CurrentLine = self._RawData.CurrentLine.replace(DT.TAB_COMMENT_SPLIT, '').strip()\r
+ if self._RawData.CurrentLine != '':\r
+ if DT.TAB_VALUE_SPLIT not in self._RawData.CurrentLine:\r
+ self._LoggerError(ST.ERR_DECPARSE_PCDERRORMSG_MISS_VALUE_SPLIT) \r
+ \r
+ PcdErrorNumber, PcdErrorMsg = GetSplitValueList(self._RawData.CurrentLine, DT.TAB_VALUE_SPLIT, 1)\r
+ PcdErrorNumber = ParsePcdErrorCode(PcdErrorNumber, self._RawData.Filename, self._RawData.LineIndex)\r
+ if not PcdErrorMsg.strip():\r
+ self._LoggerError(ST.ERR_DECPARSE_PCD_MISS_ERRORMSG)\r
+ \r
+ self.PcdErrorCommentDict[(TokenSpaceGuidCName, PcdErrorNumber)] = PcdErrorMsg.strip()\r
+ else:\r
+ TokenSpaceGuidCName = ''\r
+\r
+ self._RawData.LineIndex = 0\r
+ self._RawData.CurrentLine = ''\r
+ self._RawData.NextLine = ''\r
+\r
+ while not self._RawData.IsEndOfFile():\r
+ Line, Comment = CleanString(self._RawData.GetNextLine())\r
+ \r
#\r
# Header must be pure comment\r
#\r
self._LoggerError(ST.ERR_BINARY_HEADER_ORDER)\r
\r
if FileHeaderLineIndex == -1:\r
+# self._LoggerError(ST.ERR_NO_SOURCE_HEADER)\r
Logger.Error(TOOL_NAME, FORMAT_INVALID, \r
ST.ERR_NO_SOURCE_HEADER,\r
- File=self._RawData.Filename) \r
+ File=self._RawData.Filename)\r
return\r
\r
def _StopCurrentParsing(self, Line):\r
self._SectionHeaderParser()\r
if len(self._RawData.CurrentScope) == 0:\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_EMPTY)\r
-\r
SectionObj = self._SectionParser[self._RawData.CurrentScope[0][0]]\r
-\r
SectionObj.BlockStart()\r
SectionObj.Parse()\r
- \r
return SectionObj.GetDataObject()\r
\r
def _UserExtentionSectionParser(self):\r
self._RawData.CurrentScope = []\r
ArchList = set()\r
Section = self._RawData.CurrentLine[1:-1]\r
- \r
Par = ParserHelper(Section, self._RawData.Filename)\r
while not Par.End():\r
#\r
if Token.upper() != DT.TAB_USER_EXTENSIONS.upper():\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_UE)\r
UserExtension = Token.upper()\r
-\r
- Par.AssertChar(DT.TAB_SPLIT, ST.ERR_DECPARSE_SECTION_UE, self._RawData.LineIndex)\r
+ Par.AssertChar(DT.TAB_SPLIT, ST.ERR_DECPARSE_SECTION_UE, self._RawData.LineIndex) \r
+ \r
#\r
# UserID\r
#\r
if not IsValidUserId(Token):\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_UE_USERID)\r
UserId = Token\r
- \r
Par.AssertChar(DT.TAB_SPLIT, ST.ERR_DECPARSE_SECTION_UE, self._RawData.LineIndex)\r
#\r
# IdString\r
if not IsValidIdString(Token):\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_UE_IDSTRING)\r
IdString = Token\r
- \r
Arch = 'COMMON'\r
if Par.Expect(DT.TAB_SPLIT):\r
Token = Par.GetToken()\r
if not IsValidArch(Arch):\r
self._LoggerError(ST.ERR_DECPARSE_ARCH)\r
ArchList.add(Arch)\r
- \r
if [UserExtension, UserId, IdString, Arch] not in \\r
self._RawData.CurrentScope:\r
self._RawData.CurrentScope.append(\r
[UserExtension, UserId, IdString, Arch]\r
)\r
- \r
if not Par.Expect(DT.TAB_COMMA_SPLIT):\r
break\r
elif Par.End():\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_COMMA)\r
- \r
Par.AssertEnd(ST.ERR_DECPARSE_SECTION_UE, self._RawData.LineIndex)\r
- \r
if 'COMMON' in ArchList and len(ArchList) > 1:\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_COMMON)\r
\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_IDENTIFY)\r
\r
RawSection = self._RawData.CurrentLine[1:-1].strip().upper()\r
- \r
#\r
# Check defines section which is only allowed to occur once and\r
# no arch can be followed\r
if RawSection.startswith(DT.TAB_DEC_DEFINES.upper()):\r
if RawSection != DT.TAB_DEC_DEFINES.upper():\r
self._LoggerError(ST.ERR_DECPARSE_DEFINE_SECNAME)\r
- \r
#\r
# Check user extension section\r
#\r
if RawSection.startswith(DT.TAB_USER_EXTENSIONS.upper()):\r
return self._UserExtentionSectionParser()\r
- \r
self._RawData.CurrentScope = []\r
SectionNames = []\r
ArchList = set()\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_SUBEMPTY % self._RawData.CurrentLine)\r
\r
ItemList = GetSplitValueList(Item, DT.TAB_SPLIT)\r
-\r
#\r
# different types of PCD are permissible in one section\r
#\r
SectionName = ItemList[0]\r
if SectionName not in self._SectionParser:\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_UNKNOW % SectionName)\r
- \r
if SectionName not in SectionNames:\r
SectionNames.append(SectionName)\r
- \r
#\r
# In DEC specification, all section headers have at most two part:\r
# SectionName.Arch except UserExtention\r
#\r
if 'COMMON' in ArchList and len(ArchList) > 1:\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_COMMON)\r
- \r
if len(SectionNames) == 0:\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_SUBEMPTY % self._RawData.CurrentLine)\r
if len(SectionNames) != 1:\r
if not Sec.startswith(DT.TAB_PCDS.upper()):\r
self._LoggerError(ST.ERR_DECPARSE_SECTION_NAME % str(SectionNames))\r
\r
+ def GetDefineSectionMacro(self):\r
+ return self._Define.GetLocalMacro()\r
def GetDefineSectionObject(self):\r
return self._Define.GetDataObject()\r
- \r
def GetIncludeSectionObject(self):\r
return self._Include.GetDataObject()\r
- \r
def GetGuidSectionObject(self):\r
return self._Guid.GetGuidObject()\r
- \r
def GetProtocolSectionObject(self):\r
return self._Guid.GetProtocolObject()\r
- \r
def GetPpiSectionObject(self):\r
return self._Guid.GetPpiObject()\r
- \r
def GetLibraryClassSectionObject(self):\r
return self._LibClass.GetDataObject()\r
- \r
def GetPcdSectionObject(self):\r
return self._Pcd.GetDataObject()\r
- \r
def GetUserExtensionSectionObject(self):\r
return self._UserEx.GetDataObject()\r
- \r
def GetPackageSpecification(self):\r
- return self._Define.GetDataObject().GetPackageSpecification()\r
- \r
+ return self._Define.GetDataObject().GetPackageSpecification() \r
def GetPackageName(self):\r
- return self._Define.GetDataObject().GetPackageName()\r
- \r
+ return self._Define.GetDataObject().GetPackageName() \r
def GetPackageGuid(self):\r
- return self._Define.GetDataObject().GetPackageGuid()\r
- \r
+ return self._Define.GetDataObject().GetPackageGuid() \r
def GetPackageVersion(self):\r
return self._Define.GetDataObject().GetPackageVersion()\r
- \r
def GetPackageUniFile(self):\r
return self._Define.GetDataObject().GetPackageUniFile()\r
## @file\r
# This file is used to define helper class and function for DEC parser\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.DataType import TAB_COMMENT_EDK1_SPLIT\r
from Library.ExpressionValidate import IsValidBareCString\r
from Library.ParserValidate import IsValidCFormatGuid\r
+from Library.ExpressionValidate import IsValidFeatureFlagExp\r
from Library.ExpressionValidate import IsValidLogicalExpr\r
from Library.ExpressionValidate import IsValidStringTest\r
from Library.Misc import CheckGuidRegFormat\r
return Line, Comment\r
\r
\r
-## IsValidHexByte\r
+## IsValidNumValUint8\r
#\r
-# Check if Token is HexByte: <HexByte> ::= 0x <HexDigit>{1,2}\r
+# Check if Token is NumValUint8: <NumValUint8> ::= {<ShortNum>} {<UINT8>} {<Expression>}\r
#\r
# @param Token: Token to be checked\r
#\r
-def IsValidHexByte(Token):\r
+def IsValidNumValUint8(Token):\r
+ Valid = True\r
+ Cause = ""\r
+ TokenValue = None\r
Token = Token.strip()\r
- if not Token.lower().startswith('0x') or not (len(Token) < 5 and len(Token) > 2):\r
- return False\r
+ if Token.lower().startswith('0x'):\r
+ Base = 16\r
+ else:\r
+ Base = 10\r
try:\r
- Token = long(Token, 0)\r
+ TokenValue = long(Token, Base)\r
except BaseException:\r
+ Valid, Cause = IsValidLogicalExpr(Token, True)\r
+ if Cause:\r
+ pass\r
+ if not Valid:\r
return False\r
- return True\r
+ if TokenValue and (TokenValue < 0 or TokenValue > 0xFF):\r
+ return False\r
+ else:\r
+ return True\r
\r
## IsValidNList\r
#\r
-# Check if Value has the format of <HexByte> ["," <HexByte>]{0,}\r
-# <HexByte> ::= "0x" <HexDigit>{1,2}\r
+# Check if Value has the format of <NumValUint8> ["," <NumValUint8>]{0,}\r
+# <NumValUint8> ::= {<ShortNum>} {<UINT8>} {<Expression>}\r
#\r
# @param Value: Value to be checked\r
#\r
if Par.End():\r
return False\r
while not Par.End():\r
- Token = Par.GetToken(',\t ')\r
- if not IsValidHexByte(Token):\r
+ Token = Par.GetToken(',')\r
+ if not IsValidNumValUint8(Token):\r
return False\r
if Par.Expect(','):\r
if Par.End():\r
if Par.End():\r
return False\r
while not Par.End():\r
- Token = Par.GetToken(',}\t ')\r
+ Token = Par.GetToken(',}')\r
#\r
- # 0xa, 0xaa\r
+ # ShortNum, UINT8, Expression\r
#\r
- if not IsValidHexByte(Token):\r
+ if not IsValidNumValUint8(Token):\r
return False\r
if Par.Expect(','):\r
if Par.End():\r
# @param Value: The pcd Value\r
#\r
def IsValidPcdDatum(Type, Value):\r
+ if not Value:\r
+ return False, ST.ERR_DECPARSE_PCD_VALUE_EMPTY\r
+ Valid = True\r
+ Cause = ""\r
if Type not in ["UINT8", "UINT16", "UINT32", "UINT64", "VOID*", "BOOLEAN"]:\r
return False, ST.ERR_DECPARSE_PCD_TYPE\r
if Type == "VOID*":\r
if Value in ['TRUE', 'FALSE', 'true', 'false', 'True', 'False',\r
'0x1', '0x01', '1', '0x0', '0x00', '0']:\r
return True, ""\r
- Valid, Cause = IsValidStringTest(Value)\r
+ Valid, Cause = IsValidStringTest(Value, True)\r
if not Valid:\r
- Valid, Cause = IsValidLogicalExpr(Value)\r
+ Valid, Cause = IsValidFeatureFlagExp(Value, True)\r
if not Valid:\r
return False, Cause\r
else:\r
if TypeLenMap[Type] < len(HexStr) - 3:\r
return False, ST.ERR_DECPARSE_PCD_INT_EXCEED % (StrVal, Type)\r
except BaseException:\r
- return False, ST.ERR_DECPARSE_PCD_INT % (Value, Type)\r
-\r
+ Valid, Cause = IsValidLogicalExpr(Value, True)\r
+ if not Valid:\r
+ return False, Cause\r
+ \r
return True, ""\r
\r
## ParserHelper\r
## @file\r
# This file is used to provide method for process AsBuilt INF file. It will consumed by InfParser\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
import os\r
import re\r
from Library import GlobalData\r
-\r
import Logger.Log as Logger\r
from Logger import StringTable as ST\r
from Logger import ToolError\r
if VersionMatchedObj:\r
Guid = GuidMatchedObj.group().strip()\r
Version = VersionMatchedObj.group().strip()\r
- return GetGuidVerFormLibInstance(Guid, Version, WorkSpace, CurrentInfFileName)\r
+ return Guid, Version\r
\r
#\r
# To deal with library instance specified by file name\r
# @param WorkSpace. The WorkSpace directory used to combined with INF file path.\r
#\r
# @return GUID, Version\r
-def GetPackageListInfo(FileNameString, WorkSpace, LineNo): \r
+def GetPackageListInfo(FileNameString, WorkSpace, LineNo):\r
PackageInfoList = []\r
DefineSectionMacros = {}\r
PackageSectionMacros = {}\r
- \r
+\r
FileLinesList = GetFileLineContent(FileNameString, WorkSpace, LineNo, '')\r
- \r
+\r
RePackageHeader = re.compile('^\s*\[Packages.*\].*$')\r
ReDefineHeader = re.compile('^\s*\[Defines].*$')\r
- \r
+\r
PackageHederFlag = False\r
DefineHeaderFlag = False\r
LineNo = -1\r
for Line in FileLinesList:\r
LineNo += 1\r
Line = Line.strip()\r
- \r
+\r
if Line.startswith('['):\r
PackageHederFlag = False\r
- DefineHeaderFlag = False \r
- \r
+ DefineHeaderFlag = False\r
+\r
if Line.startswith("#"):\r
continue\r
- \r
+\r
if not Line:\r
- continue \r
- \r
+ continue\r
+\r
#\r
# Found [Packages] section \r
#\r
if RePackageHeader.match(Line):\r
PackageHederFlag = True\r
continue\r
- \r
+\r
#\r
# Found [Define] section\r
#\r
if ReDefineHeader.match(Line):\r
DefineHeaderFlag = True\r
continue\r
- \r
+\r
if DefineHeaderFlag:\r
#\r
# Find Macro\r
Name, Value = MacroParser((Line, LineNo),\r
FileNameString,\r
DT.MODEL_META_DATA_HEADER,\r
- DefineSectionMacros) \r
- \r
+ DefineSectionMacros)\r
+\r
if Name != None:\r
- DefineSectionMacros[Name] = Value \r
+ DefineSectionMacros[Name] = Value\r
continue\r
- \r
+\r
if PackageHederFlag:\r
\r
#\r
DT.MODEL_META_DATA_PACKAGE,\r
DefineSectionMacros)\r
if Name != None:\r
- PackageSectionMacros[Name] = Value \r
+ PackageSectionMacros[Name] = Value\r
continue\r
- \r
+\r
#\r
# Replace with Local section Macro and [Defines] section Macro.\r
# \r
Line = InfExpandMacro(Line, (FileNameString, Line, LineNo), DefineSectionMacros, PackageSectionMacros, True)\r
- \r
+\r
Line = GetSplitValueList(Line, "#", 1)[0]\r
Line = GetSplitValueList(Line, "|", 1)[0]\r
PackageInfoList.append(Line)\r
- \r
- return PackageInfoList \r
- \r
+\r
+ return PackageInfoList\r
+\r
def GetFileLineContent(FileName, WorkSpace, LineNo, OriginalString):\r
- \r
+\r
if not LineNo:\r
LineNo = -1\r
\r
#\r
FullFileName = os.path.normpath(os.path.realpath(os.path.join(WorkSpace, FileName)))\r
if not (ValidFile(FullFileName)):\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID,\r
- ST.ERR_FILELIST_EXIST%(FileName),\r
- File=GlobalData.gINF_MODULE_NAME,\r
- Line=LineNo, \r
- ExtraData=OriginalString)\r
- \r
+ return []\r
+\r
#\r
# Validate file exist/format.\r
#\r
if not IsValidPath(FileName, WorkSpace):\r
- Logger.Error("InfParser", \r
- ToolError.FORMAT_INVALID,\r
- ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(FileName),\r
- File=GlobalData.gINF_MODULE_NAME, \r
- Line=LineNo, \r
- ExtraData=OriginalString)\r
- \r
+ return []\r
+\r
FileLinesList = []\r
- \r
+\r
try:\r
FullFileName = FullFileName.replace('\\', '/')\r
Inputfile = open(FullFileName, "rb", 0)\r
ToolError.FILE_READ_FAILURE,\r
ST.ERR_FILE_OPEN_FAILURE,\r
File=FullFileName)\r
- \r
+\r
FileLinesList = ProcessLineExtender(FileLinesList)\r
- \r
+\r
return FileLinesList\r
\r
##\r
## @file\r
# This file contained the parser for [Binaries] sections in INF file \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
CurrentLineObj))\r
else:\r
if len(ValueList) == 2:\r
- TokenList = GetSplitValueList(ValueList[1], \r
- DT.TAB_VALUE_SPLIT, \r
- 4)\r
+ if ValueList[0].strip() == 'SUBTYPE_GUID':\r
+ TokenList = GetSplitValueList(ValueList[1], \r
+ DT.TAB_VALUE_SPLIT, \r
+ 5)\r
+ else:\r
+ TokenList = GetSplitValueList(ValueList[1], \r
+ DT.TAB_VALUE_SPLIT, \r
+ 4)\r
+ \r
NewValueList = []\r
NewValueList.append(ValueList[0])\r
for Item in TokenList:\r
ComBinaryList.append((NewValueList, \r
LineComment, \r
CurrentLineObj))\r
+ elif len(ValueList) == 1:\r
+ NewValueList = []\r
+ NewValueList.append(ValueList[0])\r
+ ComBinaryList.append((NewValueList, \r
+ LineComment, \r
+ CurrentLineObj))\r
+ \r
+ \r
+ \r
\r
ValueList = []\r
LineComment = None\r
## @file\r
# This file contained the parser for [Libraries] sections in INF file \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
# Macro defined in this section \r
#\r
SectionMacros = {}\r
- ValueList = []\r
- LibraryList = []\r
- LibStillCommentFalg = False\r
- LibHeaderComments = []\r
- LibLineComment = None \r
+ ValueList = []\r
+ LibraryList = []\r
+ LibStillCommentFalg = False\r
+ LibHeaderComments = []\r
+ LibLineComment = None\r
#\r
# Parse section content\r
#\r
for Line in SectionString:\r
LibLineContent = Line[0]\r
- LibLineNo = Line[1]\r
- \r
+ LibLineNo = Line[1]\r
+\r
if LibLineContent.strip() == '':\r
continue\r
- \r
+\r
#\r
# Found Header Comments \r
#\r
continue\r
else:\r
LibStillCommentFalg = False\r
- \r
+\r
if len(LibHeaderComments) >= 1:\r
LibLineComment = InfLineCommentObject()\r
LineCommentContent = ''\r
for Item in LibHeaderComments:\r
LineCommentContent += Item[0] + DT.END_OF_LINE\r
LibLineComment.SetHeaderComments(LineCommentContent)\r
- \r
+\r
#\r
# Find Tail comment.\r
#\r
LibLineContent = LibLineContent[:LibLineContent.find(DT.TAB_COMMENT_SPLIT)]\r
if LibLineComment == None:\r
LibLineComment = InfLineCommentObject()\r
- LibLineComment.SetTailComments(LibTailComments) \r
- \r
+ LibLineComment.SetTailComments(LibTailComments)\r
+\r
#\r
# Find Macro\r
#\r
if Name != None:\r
SectionMacros[Name] = Value\r
LibLineComment = None\r
- LibHeaderComments = [] \r
+ LibHeaderComments = []\r
continue\r
- \r
+\r
TokenList = GetSplitValueList(LibLineContent, DT.TAB_VALUE_SPLIT, 1)\r
ValueList[0:len(TokenList)] = TokenList\r
- \r
+\r
#\r
# Replace with Local section Macro and [Defines] section Macro.\r
# \r
- ValueList = [InfExpandMacro(Value, (FileName, LibLineContent, LibLineNo), \r
+ ValueList = [InfExpandMacro(Value, (FileName, LibLineContent, LibLineNo),\r
self.FileLocalMacros, SectionMacros, True)\r
for Value in ValueList]\r
- \r
- LibraryList.append((ValueList, LibLineComment, \r
+\r
+ LibraryList.append((ValueList, LibLineComment,\r
(LibLineContent, LibLineNo, FileName)))\r
ValueList = []\r
LibLineComment = None\r
LibTailComments = ''\r
LibHeaderComments = []\r
- \r
+\r
continue\r
- \r
+\r
#\r
# Current section archs\r
# \r
for Item in self.LastSectionHeaderContent:\r
if (Item[1], Item[2]) not in KeyList:\r
KeyList.append((Item[1], Item[2]))\r
- \r
- if not InfSectionObject.SetLibraryClasses(LibraryList, KeyList = KeyList):\r
- Logger.Error('InfParser', \r
+\r
+ if not InfSectionObject.SetLibraryClasses(LibraryList, KeyList=KeyList):\r
+ Logger.Error('InfParser',\r
FORMAT_INVALID,\r
ST.ERR_INF_PARSER_MODULE_SECTION_TYPE_ERROR % ("[Library]"),\r
- File=FileName, \r
+ File=FileName,\r
Line=Item[3])\r
#\r
# For Binary INF\r
#\r
else:\r
self.InfAsBuiltLibraryParser(SectionString, InfSectionObject, FileName)\r
- \r
+\r
def InfAsBuiltLibraryParser(self, SectionString, InfSectionObject, FileName):\r
LibraryList = []\r
LibInsFlag = False\r
for Line in SectionString:\r
LineContent = Line[0]\r
- LineNo = Line[1]\r
- \r
+ LineNo = Line[1]\r
+\r
if LineContent.strip() == '':\r
LibInsFlag = False\r
continue\r
- \r
+\r
if not LineContent.strip().startswith("#"):\r
- Logger.Error('InfParser', \r
+ Logger.Error('InfParser',\r
FORMAT_INVALID,\r
- ST.ERR_LIB_CONTATIN_ASBUILD_AND_COMMON, \r
- File=FileName, \r
- Line=LineNo, \r
+ ST.ERR_LIB_CONTATIN_ASBUILD_AND_COMMON,\r
+ File=FileName,\r
+ Line=LineNo,\r
ExtraData=LineContent)\r
\r
if IsLibInstanceInfo(LineContent):\r
if LibGuid != '':\r
if (LibGuid, LibVer) not in LibraryList:\r
LibraryList.append((LibGuid, LibVer))\r
- else:\r
- Logger.Error('InfParser',\r
- FORMAT_INVALID,\r
- ST.ERR_LIB_INSTANCE_MISS_GUID,\r
- File=FileName,\r
- Line=LineNo,\r
- ExtraData=LineContent)\r
\r
#\r
# Current section archs\r
for Item in self.LastSectionHeaderContent:\r
if (Item[1], Item[2]) not in KeyList:\r
KeyList.append((Item[1], Item[2]))\r
- \r
- if not InfSectionObject.SetLibraryClasses(LibraryList, KeyList = KeyList):\r
- Logger.Error('InfParser', \r
+\r
+ if not InfSectionObject.SetLibraryClasses(LibraryList, KeyList=KeyList):\r
+ Logger.Error('InfParser',\r
FORMAT_INVALID,\r
ST.ERR_INF_PARSER_MODULE_SECTION_TYPE_ERROR % ("[Library]"),\r
- File=FileName, \r
- Line=Item[3])
\ No newline at end of file
+ File=FileName,\r
+ Line=Item[3])\r
## @file\r
# This file contained the parser for INF file\r
#\r
-# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
SectionLines.append((Line, LineNo))\r
HeaderCommentStart = True\r
continue \r
- \r
+\r
#\r
# Collect Header content.\r
#\r
HeaderCommentEnd = True\r
BinaryHeaderCommentStart = False \r
BinaryHeaderCommentEnd = False\r
- HeaderCommentStart = False\r
+ HeaderCommentStart = False \r
if Line.find(DT.TAB_BINARY_HEADER_COMMENT) > -1:\r
self.InfHeaderParser(SectionLines, self.InfHeader, self.FileName) \r
SectionLines = []\r
else:\r
SectionLines.append((Line, LineNo))\r
- #\r
- # Call Header comment parser.\r
- #\r
- self.InfHeaderParser(SectionLines, self.InfHeader, self.FileName)\r
- SectionLines = []\r
- continue\r
+ #\r
+ # Call Header comment parser.\r
+ #\r
+ self.InfHeaderParser(SectionLines, self.InfHeader, self.FileName)\r
+ SectionLines = []\r
+ continue\r
\r
#\r
# check whether binary header comment section started\r
BinaryHeaderStarLineNo = LineNo\r
SectionLines.append((Line, LineNo))\r
BinaryHeaderCommentStart = True\r
- HeaderCommentEnd = True \r
- continue \r
- \r
+ HeaderCommentEnd = True\r
+ continue \r
+ \r
#\r
# check whether there are more than one binary header exist\r
#\r
SectionLines.append((Line, LineNo))\r
if not LastSectionFalg:\r
continue\r
- \r
+\r
#\r
# Encountered a section. start with '[' and end with ']'\r
#\r
if (Line.startswith(DT.TAB_SECTION_START) and \\r
- Line.find(DT.TAB_SECTION_END) > -1) or LastSectionFalg: \r
+ Line.find(DT.TAB_SECTION_END) > -1) or LastSectionFalg: \r
\r
HeaderCommentEnd = True \r
BinaryHeaderCommentEnd = True \r
File=self.FullPath,\r
Line=LineNo, \r
ExtraData=Line) \r
- \r
+\r
#\r
# Keep last time section header content for section parser\r
# usage.\r
#\r
self.LastSectionHeaderContent = deepcopy(self.SectionHeaderContent)\r
- \r
+\r
#\r
# TailComments in section define.\r
#\r
# Compare the new section name with current\r
#\r
self.SectionHeaderParser(Line, self.FileName, LineNo)\r
- \r
+\r
self._CheckSectionHeaders(Line, LineNo)\r
\r
SectionType = _ConvertSecNameToType(self.SectionHeaderContent[0][0])\r
- \r
+\r
if not FirstSectionStartFlag:\r
CurrentSection = SectionType\r
FirstSectionStartFlag = True\r
else:\r
SectionLines.append((Line, LineNo))\r
continue\r
- \r
+\r
if LastSectionFalg:\r
SectionLines, CurrentSection = self._ProcessLastSection(SectionLines, Line, LineNo, CurrentSection)\r
- \r
+\r
#\r
# End of section content collect.\r
# Parser the section content collected previously.\r
\r
if HeaderStarLineNo == -1:\r
Logger.Error("InfParser", \r
- FORMAT_INVALID, \r
- ST.ERR_NO_SOURCE_HEADER, \r
- File=self.FullPath)\r
+ FORMAT_INVALID,\r
+ ST.ERR_NO_SOURCE_HEADER,\r
+ File=self.FullPath) \r
if BinaryHeaderStarLineNo > -1 and HeaderStarLineNo > -1 and HeaderStarLineNo > BinaryHeaderStarLineNo:\r
Logger.Error("InfParser", \r
FORMAT_INVALID,\r
## @file\r
# This file contained the miscellaneous functions for INF parser \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
LineContent = LineInfo[1]\r
LineNo = LineInfo[2]\r
\r
+ # Don't expand macros in comments\r
+ if LineContent.strip().startswith("#"):\r
+ return Content\r
+\r
NewLineInfo = (FileName, LineNo, LineContent)\r
\r
#\r
## @file\r
# This file contained the parser for [Pcds] sections in INF file \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
ExtraData=LineContent)\r
# \r
elif KeysList[0][0].upper() == DT.TAB_INF_PCD_EX.upper():\r
- if len(TokenList) != 2:\r
+ if len(TokenList) != 1:\r
Logger.Error('InfParser', \r
FORMAT_INVALID, \r
ST.ERR_ASBUILD_PCDEX_FORMAT_INVALID,\r
File=FileName,\r
Line=LineNo,\r
- ExtraData=LineContent) \r
+ ExtraData=LineContent)\r
ValueList[0:len(TokenList)] = TokenList\r
if len(ValueList) >= 1: \r
PcdList.append((ValueList, CommentsList, (LineContent, LineNo, FileName))) \r
## @file\r
# This file contained the parser for sections in INF file \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
self.InfSmmDepexSection = InfDepexObject()\r
self.InfBinariesSection = InfBinariesObject()\r
self.InfHeader = InfHeaderObject()\r
+ self.InfBinaryHeader = InfHeaderObject()\r
self.InfSpecialCommentSection = InfSpecialCommentObject()\r
\r
#\r
#\r
# File Header content parser\r
# \r
- def InfHeaderParser(self, Content, InfHeaderObject2, FileName):\r
- (Abstract, Description, Copyright, License) = ParseHeaderCommentSection(Content, FileName)\r
+ def InfHeaderParser(self, Content, InfHeaderObject2, FileName, IsBinaryHeader = False):\r
+ if IsBinaryHeader:\r
+ (Abstract, Description, Copyright, License) = ParseHeaderCommentSection(Content, FileName, True)\r
+ if not Abstract or not Description or not Copyright or not License:\r
+ Logger.Error('Parser',\r
+ FORMAT_INVALID,\r
+ ST.ERR_INVALID_BINARYHEADER_FORMAT,\r
+ File=FileName)\r
+ else:\r
+ (Abstract, Description, Copyright, License) = ParseHeaderCommentSection(Content, FileName)\r
#\r
# Not process file name now, for later usage.\r
#\r
## @file DecPomAlignment.py\r
# This file contained the adapter for convert INF parser object to POM Object\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from os import sep\r
import platform\r
\r
+import re\r
import Logger.Log as Logger\r
from Logger import StringTable as ST\r
from Logger.ToolError import UPT_MUL_DEC_ERROR\r
+from Logger.ToolError import FORMAT_INVALID\r
\r
from Library.Parsing import NormPath\r
from Library.DataType import ARCH_LIST\r
from Library.DataType import TAB_DEC_DEFINES_PACKAGE_GUID\r
from Library.DataType import TAB_DEC_DEFINES_PACKAGE_VERSION\r
from Library.DataType import TAB_DEC_DEFINES_DEC_SPECIFICATION\r
+from Library.DataType import TAB_DEC_DEFINES_PKG_UNI_FILE\r
from Library.DataType import TAB_ARCH_COMMON\r
-from Library.CommentParsing import ParseHeaderCommentSection\r
from Library.DataType import TAB_INCLUDES\r
-from Library.CommentParsing import ParseGenericComment\r
from Library.DataType import TAB_LIBRARY_CLASSES\r
from Library.DataType import TAB_PCDS\r
from Library.DataType import TAB_PCDS_FIXED_AT_BUILD_NULL\r
from Library.DataType import TAB_PCDS_DYNAMIC_NULL\r
from Library.DataType import TAB_PTR_TYPE_PCD\r
from Library.DataType import ITEM_UNDEFINED\r
+from Library.DataType import TAB_DEC_BINARY_ABSTRACT\r
+from Library.DataType import TAB_DEC_BINARY_DESCRIPTION\r
+from Library.DataType import TAB_LANGUAGE_EN_US\r
+from Library.DataType import TAB_BINARY_HEADER_IDENTIFIER\r
+from Library.DataType import TAB_BINARY_HEADER_USERID\r
+from Library.DataType import TAB_LANGUAGE_EN_X\r
+from Library.DataType import TAB_LANGUAGE_EN\r
+from Library.DataType import TAB_STR_TOKENCNAME\r
+from Library.DataType import TAB_STR_TOKENPROMPT\r
+from Library.DataType import TAB_STR_TOKENHELP\r
+from Library.DataType import TAB_STR_TOKENERR\r
+from Library.DataType import TAB_HEX_START\r
+from Library.DataType import TAB_SPLIT\r
+from Library.CommentParsing import ParseHeaderCommentSection\r
+from Library.CommentParsing import ParseGenericComment\r
from Library.CommentParsing import ParseDecPcdGenericComment\r
from Library.CommentParsing import ParseDecPcdTailComment\r
from Library.Misc import GetFiles\r
from Library.Misc import Sdict\r
+from Library.Misc import GetRelativePath\r
+from Library.Misc import PathClass\r
+from Library.Misc import ValidateUNIFilePath\r
+from Library.UniClassObject import UniFileClassObject\r
+from Library.UniClassObject import ConvertSpecialUnicodes\r
+from Library.UniClassObject import GetLanguageCode1766\r
+from Library.ParserValidate import IsValidPath\r
from Parser.DecParser import Dec\r
-\r
from Object.POM.PackageObject import PackageObject\r
from Object.POM.CommonObject import UserExtensionObject\r
from Object.POM.CommonObject import IncludeObject\r
from Object.POM.CommonObject import LibraryClassObject\r
from Object.POM.CommonObject import PcdObject\r
from Object.POM.CommonObject import TextObject\r
+from Object.POM.CommonObject import MiscFileObject\r
+from Object.POM.CommonObject import FileObject\r
\r
\r
## DecPomAlignment\r
self.SupArchList = ARCH_LIST\r
self.CheckMulDec = CheckMulDec\r
self.DecParser = None\r
+ self.UniFileClassObject = None\r
+ self.PcdDefaultValueDict = {}\r
\r
#\r
# Load Dec file\r
self.SetFullPath(Filename)\r
self.SetRelaPath(Path)\r
self.SetFileName(Name)\r
- self.SetPackagePath(Path[Path.upper().find(self.WorkspaceDir.upper()) + len(self.WorkspaceDir) + 1:])\r
- self.SetCombinePath(Filename[Filename.upper().find(self.WorkspaceDir.upper()) + len(self.WorkspaceDir) + 1:])\r
+ self.SetPackagePath(GetRelativePath(Path, self.WorkspaceDir)) \r
+ self.SetCombinePath(GetRelativePath(Filename, self.WorkspaceDir))\r
\r
self.DecParser = Dec(Filename)\r
\r
# Generate user extensions\r
#\r
self.GenUserExtensions()\r
- \r
- ## Generate user extention\r
+ \r
+ ## Generate user extension\r
#\r
#\r
def GenUserExtensions(self):\r
Identifier = Item.IdString\r
if Identifier.startswith('"') and Identifier.endswith('"'):\r
Identifier = Identifier[1:-1]\r
+ #\r
+ # Generate miscellaneous files of DEC file\r
+ #\r
+ if UserId == 'TianoCore' and Identifier == 'ExtraFiles':\r
+ self.GenMiscFiles(Item.UserString)\r
UserExtension.SetIdentifier(Identifier)\r
UserExtension.SetStatement(Item.UserString)\r
UserExtension.SetSupArchList(\r
self.SetUserExtensionList(\r
self.GetUserExtensionList() + [UserExtension]\r
)\r
- \r
+ \r
+ ## Generate miscellaneous files on DEC file\r
+ #\r
+ #\r
+ def GenMiscFiles(self, Content):\r
+ MiscFileObj = MiscFileObject()\r
+ for Line in Content.splitlines():\r
+ FileName = ''\r
+ if '#' in Line:\r
+ FileName = Line[:Line.find('#')]\r
+ else:\r
+ FileName = Line\r
+ if FileName:\r
+ if IsValidPath(FileName, self.GetRelaPath()):\r
+ FileObj = FileObject()\r
+ FileObj.SetURI(FileName)\r
+ MiscFileObj.SetFileList(MiscFileObj.GetFileList()+[FileObj])\r
+ else:\r
+ Logger.Error("InfParser", \r
+ FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(Line),\r
+ File=self.GetFileName(),\r
+ ExtraData=Line) \r
+ self.SetMiscFileList(self.GetMiscFileList()+[MiscFileObj]) \r
+ \r
## Generate Package Header\r
#\r
# Gen Package Header of Dec as <Key> = <Value>\r
# put items into Dict except for PackageName, Guid, Version, DEC_SPECIFICATION\r
#\r
SkipItemList = [TAB_DEC_DEFINES_PACKAGE_NAME, \\r
- TAB_DEC_DEFINES_PACKAGE_GUID, TAB_DEC_DEFINES_PACKAGE_VERSION, TAB_DEC_DEFINES_DEC_SPECIFICATION]\r
+ TAB_DEC_DEFINES_PACKAGE_GUID, TAB_DEC_DEFINES_PACKAGE_VERSION, \\r
+ TAB_DEC_DEFINES_DEC_SPECIFICATION, TAB_DEC_DEFINES_PKG_UNI_FILE]\r
if Item.Key in SkipItemList:\r
continue\r
DefinesDict['%s = %s' % (Item.Key, Item.Value)] = TAB_ARCH_COMMON\r
# DefObj.GetPackageVersion())\r
self.SetName(os.path.splitext(self.GetFileName())[0])\r
self.SetGuid(DefObj.GetPackageGuid())\r
+ if DefObj.GetPackageUniFile():\r
+ ValidateUNIFilePath(DefObj.GetPackageUniFile())\r
+ self.UniFileClassObject = \\r
+ UniFileClassObject([PathClass(os.path.join(DefObj.GetPackagePath(), DefObj.GetPackageUniFile()))])\r
+ else:\r
+ self.UniFileClassObject = None\r
\r
if DefinesDict:\r
UserExtension = UserExtensionObject()\r
)\r
\r
#\r
- # Get All header comment section information\r
+ # Get File header information\r
#\r
+ if self.UniFileClassObject:\r
+ Lang = TAB_LANGUAGE_EN_X\r
+ else:\r
+ Lang = TAB_LANGUAGE_EN_US\r
Abstract, Description, Copyright, License = \\r
ParseHeaderCommentSection(self.DecParser.GetHeadComment(),\r
ContainerFile)\r
- self.SetAbstract(Abstract)\r
- self.SetDescription(Description)\r
- self.SetCopyright(Copyright)\r
- self.SetLicense(License)\r
+ if Abstract:\r
+ self.SetAbstract((Lang, Abstract))\r
+ if Description:\r
+ self.SetDescription((Lang, Description))\r
+ if Copyright:\r
+ self.SetCopyright(('', Copyright))\r
+ if License:\r
+ self.SetLicense(('', License))\r
\r
+ #\r
+ # Get Binary header information\r
+ #\r
+ if self.DecParser.BinaryHeadComment:\r
+ Abstract, Description, Copyright, License = \\r
+ ParseHeaderCommentSection(self.DecParser.BinaryHeadComment,\r
+ ContainerFile, True)\r
+ \r
+ if not Abstract or not Description or not Copyright or not License:\r
+ Logger.Error('MkPkg',\r
+ FORMAT_INVALID,\r
+ ST.ERR_INVALID_BINARYHEADER_FORMAT,\r
+ ContainerFile)\r
+ else:\r
+ self.SetBinaryHeaderAbstract((Lang, Abstract))\r
+ self.SetBinaryHeaderDescription((Lang, Description))\r
+ self.SetBinaryHeaderCopyright(('', Copyright))\r
+ self.SetBinaryHeaderLicense(('', License))\r
+\r
+ BinaryAbstractList = []\r
+ BinaryDescriptionList = []\r
+ \r
+ #Get Binary header from UNI file\r
+ # Initialize the UniStrDict dictionary, top keys are language codes\r
+ UniStrDict = {}\r
+ if self.UniFileClassObject:\r
+ UniStrDict = self.UniFileClassObject.OrderedStringList\r
+ for Lang in UniStrDict:\r
+ for StringDefClassObject in UniStrDict[Lang]:\r
+ Lang = GetLanguageCode1766(Lang)\r
+ if StringDefClassObject.StringName == TAB_DEC_BINARY_ABSTRACT:\r
+ if (Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)) \\r
+ not in self.GetBinaryHeaderAbstract():\r
+ BinaryAbstractList.append((Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+ if StringDefClassObject.StringName == TAB_DEC_BINARY_DESCRIPTION:\r
+ if (Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)) \\r
+ not in self.GetBinaryHeaderDescription():\r
+ BinaryDescriptionList.append((Lang, \r
+ ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+ #Combine Binary header from DEC file and UNI file\r
+ BinaryAbstractList = self.GetBinaryHeaderAbstract() + BinaryAbstractList\r
+ BinaryDescriptionList = self.GetBinaryHeaderDescription() + BinaryDescriptionList\r
+ BinaryCopyrightList = self.GetBinaryHeaderCopyright()\r
+ BinaryLicenseList = self.GetBinaryHeaderLicense()\r
+ #Generate the UserExtensionObject for TianoCore."BinaryHeader"\r
+ if BinaryAbstractList or BinaryDescriptionList or BinaryCopyrightList or BinaryLicenseList:\r
+ BinaryUserExtension = UserExtensionObject()\r
+ BinaryUserExtension.SetBinaryAbstract(BinaryAbstractList)\r
+ BinaryUserExtension.SetBinaryDescription(BinaryDescriptionList)\r
+ BinaryUserExtension.SetBinaryCopyright(BinaryCopyrightList)\r
+ BinaryUserExtension.SetBinaryLicense(BinaryLicenseList)\r
+ BinaryUserExtension.SetIdentifier(TAB_BINARY_HEADER_IDENTIFIER)\r
+ BinaryUserExtension.SetUserID(TAB_BINARY_HEADER_USERID)\r
+ self.SetUserExtensionList(self.GetUserExtensionList() + [BinaryUserExtension])\r
+ \r
+ \r
## GenIncludes\r
#\r
# Gen Includes of Dec\r
IncObj = self.DecParser.GetIncludeSectionObject()\r
for Item in IncObj.GetAllIncludes():\r
IncludePath = os.path.normpath(Item.File)\r
- if platform.system() != 'Windows':\r
+ if platform.system() != 'Windows' and platform.system() != 'Microsoft':\r
IncludePath = IncludePath.replace('\\', '/')\r
if IncludePath in IncludesDict:\r
if Item.GetArchList() == [TAB_ARCH_COMMON] or IncludesDict[IncludePath] == [TAB_ARCH_COMMON]:\r
ListObject.SetGuid(Value)\r
ListObject.SetSupArchList(Item.GetArchList())\r
if HelpTxt:\r
+ if self.UniFileClassObject:\r
+ HelpTxt.SetLang(TAB_LANGUAGE_EN_X)\r
ListObject.SetHelpTextList([HelpTxt])\r
\r
DeclarationsList.append(ListObject)\r
HelpTxt = ParseGenericComment(Item.GetHeadComment() + \\r
Item.GetTailComment(), None, '@libraryclass')\r
if HelpTxt:\r
+ if self.UniFileClassObject:\r
+ HelpTxt.SetLang(TAB_LANGUAGE_EN_X)\r
LibraryClass.SetHelpTextList([HelpTxt])\r
LibraryClassDeclarations.append(LibraryClass)\r
\r
#\r
def GenPcds(self, ContainerFile):\r
Logger.Debug(2, "Generate %s ..." % TAB_PCDS)\r
- \r
PcdObj = self.DecParser.GetPcdSectionObject()\r
#\r
# Get all Pcds\r
(TAB_PCDS_FEATURE_FLAG_NULL, 'FeaturePcd'),\r
(TAB_PCDS_DYNAMIC_EX_NULL, 'PcdEx'), \r
(TAB_PCDS_DYNAMIC_NULL, 'Pcd')]\r
+ \r
+ PromptStrList = []\r
+ HelpStrList = []\r
+ PcdErrStrList = []\r
+ # Initialize UniStrDict dictionary, top keys are language codes\r
+ UniStrDict = {}\r
+ StrList = []\r
+ \r
+ Language = ''\r
+ if self.UniFileClassObject:\r
+ Language = TAB_LANGUAGE_EN_X\r
+ else:\r
+ Language = TAB_LANGUAGE_EN_US\r
+ \r
+ if self.UniFileClassObject:\r
+ UniStrDict = self.UniFileClassObject.OrderedStringList\r
+ for Lang in UniStrDict:\r
+ for StringDefClassObject in UniStrDict[Lang]:\r
+ StrList = StringDefClassObject.StringName.split('_')\r
+ # StringName format is STR_<TOKENSPACECNAME>_<PCDCNAME>_PROMPT\r
+ if len(StrList) == 4 and StrList[0] == TAB_STR_TOKENCNAME and StrList[3] == TAB_STR_TOKENPROMPT:\r
+ PromptStrList.append((GetLanguageCode1766(Lang), StringDefClassObject.StringName, \\r
+ StringDefClassObject.StringValue))\r
+ # StringName format is STR_<TOKENSPACECNAME>_<PCDCNAME>_HELP\r
+ if len(StrList) == 4 and StrList[0] == TAB_STR_TOKENCNAME and StrList[3] == TAB_STR_TOKENHELP:\r
+ HelpStrList.append((GetLanguageCode1766(Lang), StringDefClassObject.StringName, \\r
+ StringDefClassObject.StringValue))\r
+ # StringName format is STR_<TOKENSPACECNAME>_ERR_##\r
+ if len(StrList) == 4 and StrList[0] == TAB_STR_TOKENCNAME and StrList[2] == TAB_STR_TOKENERR:\r
+ PcdErrStrList.append((GetLanguageCode1766(Lang), StringDefClassObject.StringName, \\r
+ StringDefClassObject.StringValue))\r
#\r
# For each PCD type\r
#\r
ContainerFile,\r
(Item.TokenSpaceGuidCName, Item.TokenCName,\r
Item.DefaultValue, Item.DatumType, Item.TokenValue,\r
- Type, Item.GetHeadComment(), Item.GetTailComment(),\r
- '')\r
- )\r
+ Type, Item.GetHeadComment(), Item.GetTailComment(),''),\r
+ Language,\r
+ self.DecParser.GetDefineSectionMacro()\r
+ )\r
PcdDeclaration.SetSupArchList(Item.GetArchListOfType(PcdType))\r
+ \r
+ #\r
+ # Get PCD error message from PCD error comment section in DEC file\r
+ #\r
+ for PcdErr in PcdDeclaration.GetPcdErrorsList():\r
+ if (PcdDeclaration.GetTokenSpaceGuidCName(), PcdErr.GetErrorNumber()) \\r
+ in self.DecParser.PcdErrorCommentDict:\r
+ Key = (PcdDeclaration.GetTokenSpaceGuidCName(), PcdErr.GetErrorNumber())\r
+ PcdErr.SetErrorMessageList(PcdErr.GetErrorMessageList() + \\r
+ [(Language, self.DecParser.PcdErrorCommentDict[Key])])\r
+ \r
+ for Index in range(0, len(PromptStrList)):\r
+ StrNameList = PromptStrList[Index][1].split('_')\r
+ if StrNameList[1].lower() == Item.TokenSpaceGuidCName.lower() and \\r
+ StrNameList[2].lower() == Item.TokenCName.lower():\r
+ TxtObj = TextObject()\r
+ TxtObj.SetLang(PromptStrList[Index][0])\r
+ TxtObj.SetString(PromptStrList[Index][2])\r
+ for Prompt in PcdDeclaration.GetPromptList():\r
+ if Prompt.GetLang() == TxtObj.GetLang() and \\r
+ Prompt.GetString() == TxtObj.GetString():\r
+ break\r
+ else:\r
+ PcdDeclaration.SetPromptList(PcdDeclaration.GetPromptList() + [TxtObj])\r
+ \r
+ for Index in range(0, len(HelpStrList)):\r
+ StrNameList = HelpStrList[Index][1].split('_')\r
+ if StrNameList[1].lower() == Item.TokenSpaceGuidCName.lower() and \\r
+ StrNameList[2].lower() == Item.TokenCName.lower():\r
+ TxtObj = TextObject()\r
+ TxtObj.SetLang(HelpStrList[Index][0])\r
+ TxtObj.SetString(HelpStrList[Index][2])\r
+ for HelpStrObj in PcdDeclaration.GetHelpTextList():\r
+ if HelpStrObj.GetLang() == TxtObj.GetLang() and \\r
+ HelpStrObj.GetString() == TxtObj.GetString():\r
+ break\r
+ else:\r
+ PcdDeclaration.SetHelpTextList(PcdDeclaration.GetHelpTextList() + [TxtObj])\r
+\r
+ #\r
+ # Get PCD error message from UNI file\r
+ #\r
+ for Index in range(0, len(PcdErrStrList)):\r
+ StrNameList = PcdErrStrList[Index][1].split('_')\r
+ if StrNameList[1].lower() == Item.TokenSpaceGuidCName.lower() and \\r
+ StrNameList[2].lower() == TAB_STR_TOKENERR.lower():\r
+ for PcdErr in PcdDeclaration.GetPcdErrorsList():\r
+ if PcdErr.GetErrorNumber().lower() == (TAB_HEX_START + StrNameList[3]).lower() and \\r
+ (PcdErrStrList[Index][0], PcdErrStrList[Index][2]) not in PcdErr.GetErrorMessageList():\r
+ PcdErr.SetErrorMessageList(PcdErr.GetErrorMessageList() + \\r
+ [(PcdErrStrList[Index][0], PcdErrStrList[Index][2])])\r
+ \r
+ #\r
+ # Check to prevent missing error message if a Pcd has the error code.\r
+ #\r
+ for PcdErr in PcdDeclaration.GetPcdErrorsList():\r
+ if PcdErr.GetErrorNumber().strip():\r
+ if not PcdErr.GetErrorMessageList():\r
+ Logger.Error('UPT',\r
+ FORMAT_INVALID,\r
+ ST.ERR_DECPARSE_PCD_UNMATCHED_ERRORCODE % PcdErr.GetErrorNumber(),\r
+ ContainerFile,\r
+ PcdErr.GetLineNum(),\r
+ PcdErr.GetFileLine()) \r
+ \r
PcdDeclarations.append(PcdDeclaration)\r
- \r
self.SetPcdList(self.GetPcdList() + PcdDeclarations)\r
+ self.CheckPcdValue()\r
+ \r
+ ##\r
+ # Get error message via language\r
+ # @param ErrorMessageList: Error message tuple list the language and its message\r
+ # @param Lang: the language of setting\r
+ # @return: the error message described in the related UNI file\r
+ def GetEnErrorMessage(self, ErrorMessageList):\r
+ if self.FullPath:\r
+ pass\r
+ Lang = TAB_LANGUAGE_EN_US\r
+ for (Language, Message) in ErrorMessageList:\r
+ if Language == Lang:\r
+ return Message\r
+ for (Language, Message) in ErrorMessageList:\r
+ if Language.find(TAB_LANGUAGE_EN) >= 0:\r
+ return Message\r
+ else:\r
+ try:\r
+ return ErrorMessageList[0][1]\r
+ except IndexError:\r
+ return ''\r
+ return '' \r
+ \r
+ ##\r
+ # Replace the strings for Python eval function.\r
+ # @param ReplaceValue: The string that needs to be replaced. \r
+ # @return: The string was replaced, then eval function is always making out it. \r
+ def ReplaceForEval(self, ReplaceValue, IsRange=False, IsExpr=False):\r
+ if self.FullPath:\r
+ pass\r
+ #\r
+ # deal with "NOT EQ", "NOT LT", "NOT GT", "NOT LE", "NOT GE", "NOT NOT" \r
+ #\r
+ NOTNOT_Pattern = '[\t\s]*NOT[\t\s]+NOT[\t\s]*'\r
+ NOTGE_Pattern = '[\t\s]*NOT[\t\s]+GE[\t\s]*'\r
+ NOTLE_Pattern = '[\t\s]*NOT[\t\s]+LE[\t\s]*'\r
+ NOTGT_Pattern = '[\t\s]*NOT[\t\s]+GT[\t\s]*'\r
+ NOTLT_Pattern = '[\t\s]*NOT[\t\s]+LT[\t\s]*'\r
+ NOTEQ_Pattern = '[\t\s]*NOT[\t\s]+EQ[\t\s]*'\r
+ ReplaceValue = re.compile(NOTNOT_Pattern).sub('', ReplaceValue)\r
+ ReplaceValue = re.compile(NOTLT_Pattern).sub('x >= ', ReplaceValue)\r
+ ReplaceValue = re.compile(NOTGT_Pattern).sub('x <= ', ReplaceValue)\r
+ ReplaceValue = re.compile(NOTLE_Pattern).sub('x > ', ReplaceValue)\r
+ ReplaceValue = re.compile(NOTGE_Pattern).sub('x < ', ReplaceValue)\r
+ ReplaceValue = re.compile(NOTEQ_Pattern).sub('x != ', ReplaceValue)\r
+ \r
+ if IsRange:\r
+ ReplaceValue = ReplaceValue.replace('EQ', 'x ==')\r
+ ReplaceValue = ReplaceValue.replace('LT', 'x <')\r
+ ReplaceValue = ReplaceValue.replace('LE', 'x <=')\r
+ ReplaceValue = ReplaceValue.replace('GT', 'x >')\r
+ ReplaceValue = ReplaceValue.replace('GE', 'x >=')\r
+ ReplaceValue = ReplaceValue.replace('XOR', 'x ^')\r
+ elif IsExpr:\r
+ ReplaceValue = ReplaceValue.replace('EQ', '==')\r
+ ReplaceValue = ReplaceValue.replace('NE', '!=')\r
+ ReplaceValue = ReplaceValue.replace('LT', '<')\r
+ ReplaceValue = ReplaceValue.replace('LE', '<=')\r
+ ReplaceValue = ReplaceValue.replace('GT', '>')\r
+ ReplaceValue = ReplaceValue.replace('GE', '>=') \r
+ ReplaceValue = ReplaceValue.replace('XOR', '^') \r
+ \r
+ ReplaceValue = ReplaceValue.replace('AND', 'and')\r
+ ReplaceValue = ReplaceValue.replace('&&', ' and ')\r
+ ReplaceValue = ReplaceValue.replace('xor', '^')\r
+ ReplaceValue = ReplaceValue.replace('OR', 'or')\r
+ ReplaceValue = ReplaceValue.replace('||', ' or ')\r
+ ReplaceValue = ReplaceValue.replace('NOT', 'not')\r
+ if ReplaceValue.find('!') >= 0 and ReplaceValue[ReplaceValue.index('!') + 1] != '=':\r
+ ReplaceValue = ReplaceValue.replace('!', ' not ') \r
+ if '.' in ReplaceValue:\r
+ Pattern = '[a-zA-Z0-9]{1,}\.[a-zA-Z0-9]{1,}'\r
+ MatchedList = re.findall(Pattern, ReplaceValue)\r
+ for MatchedItem in MatchedList:\r
+ if MatchedItem not in self.PcdDefaultValueDict:\r
+ Logger.Error("Dec File Parser", FORMAT_INVALID, Message=ST.ERR_DECPARSE_PCD_NODEFINED % MatchedItem,\r
+ File=self.FullPath)\r
+ \r
+ ReplaceValue = ReplaceValue.replace(MatchedItem, self.PcdDefaultValueDict[MatchedItem])\r
+\r
+ return ReplaceValue\r
+\r
+ ##\r
+ # Check pcd's default value according to the pcd's description\r
+ #\r
+ def CheckPcdValue(self):\r
+ for Pcd in self.GetPcdList():\r
+ self.PcdDefaultValueDict[TAB_SPLIT.join((Pcd.GetTokenSpaceGuidCName(), Pcd.GetCName())).strip()] = \\r
+ Pcd.GetDefaultValue()\r
+ \r
+ for Pcd in self.GetPcdList():\r
+ ValidationExpressions = []\r
+ PcdGuidName = TAB_SPLIT.join((Pcd.GetTokenSpaceGuidCName(), Pcd.GetCName()))\r
+ Valids = Pcd.GetPcdErrorsList()\r
+ for Valid in Valids:\r
+ Expression = Valid.GetExpression()\r
+ if Expression:\r
+ #\r
+ # Delete the 'L' prefix of a quoted string, this operation is for eval()\r
+ #\r
+ QUOTED_PATTERN = '[\t\s]*L?"[^"]*"'\r
+ QuotedMatchedObj = re.search(QUOTED_PATTERN, Expression)\r
+ if QuotedMatchedObj:\r
+ MatchedStr = QuotedMatchedObj.group().strip()\r
+ if MatchedStr.startswith('L'):\r
+ Expression = Expression.replace(MatchedStr, MatchedStr[1:].strip()) \r
+\r
+ Expression = self.ReplaceForEval(Expression, IsExpr=True)\r
+ Expression = Expression.replace(PcdGuidName, 'x')\r
+ Message = self.GetEnErrorMessage(Valid.GetErrorMessageList())\r
+ ValidationExpressions.append((Expression, Message)) \r
+ \r
+ ValidList = Valid.GetValidValue()\r
+ if ValidList:\r
+ ValidValue = 'x in %s' % [eval(v) for v in ValidList.split(' ') if v]\r
+ Message = self.GetEnErrorMessage(Valid.GetErrorMessageList())\r
+ ValidationExpressions.append((ValidValue, Message))\r
+ \r
+ ValidValueRange = Valid.GetValidValueRange() \r
+ if ValidValueRange:\r
+ ValidValueRange = self.ReplaceForEval(ValidValueRange, IsRange=True)\r
+ if ValidValueRange.find('-') >= 0:\r
+ ValidValueRange = ValidValueRange.replace('-', '<= x <=')\r
+ elif not ValidValueRange.startswith('x ') and not ValidValueRange.startswith('not ') \\r
+ and not ValidValueRange.startswith('not(') and not ValidValueRange.startswith('('):\r
+ ValidValueRange = 'x %s' % ValidValueRange\r
+ Message = self.GetEnErrorMessage(Valid.GetErrorMessageList())\r
+ ValidationExpressions.append((ValidValueRange, Message))\r
+ \r
+ DefaultValue = self.PcdDefaultValueDict[PcdGuidName.strip()]\r
+ #\r
+ # Delete the 'L' prefix of a quoted string, this operation is for eval()\r
+ #\r
+ QUOTED_PATTERN = '[\t\s]*L?"[^"]*"'\r
+ QuotedMatchedObj = re.search(QUOTED_PATTERN, DefaultValue)\r
+ if QuotedMatchedObj:\r
+ MatchedStr = QuotedMatchedObj.group().strip()\r
+ if MatchedStr.startswith('L'):\r
+ DefaultValue = DefaultValue.replace(MatchedStr, MatchedStr[1:].strip())\r
+ \r
+ try:\r
+ DefaultValue = eval(DefaultValue.replace('TRUE', 'True').replace('true', 'True')\r
+ .replace('FALSE', 'False').replace('false', 'False'))\r
+ except BaseException:\r
+ pass\r
+\r
+ for (Expression, Msg) in ValidationExpressions:\r
+ try:\r
+ if not eval(Expression, {'x':DefaultValue}):\r
+ Logger.Error("Dec File Parser", FORMAT_INVALID, ExtraData='%s, value = %s' %\\r
+ (PcdGuidName, DefaultValue), Message=Msg, File=self.FullPath)\r
+ except TypeError:\r
+ Logger.Error("Dec File Parser", FORMAT_INVALID, ExtraData=PcdGuidName, \\r
+ Message=Msg, File=self.FullPath)\r
\r
- \r
## GenModuleFileList\r
#\r
def GenModuleFileList(self, ContainerFile): \r
# @param PcdInfo: Pcd information, of format (TokenGuidCName, \r
# TokenName, Value, DatumType, Token, Type, \r
# GenericComment, TailComment, Arch)\r
+# @param Language: The language of HelpText, Prompt \r
# \r
-def GenPcdDeclaration(ContainerFile, PcdInfo):\r
+def GenPcdDeclaration(ContainerFile, PcdInfo, Language, MacroReplaceDict):\r
HelpStr = ''\r
+ PromptStr = ''\r
TailHelpStr = ''\r
TokenGuidCName, TokenName, Value, DatumType, Token, Type, \\r
GenericComment, TailComment, Arch = PcdInfo\r
Pcd.SetSupArchList(SupArchList)\r
\r
if GenericComment:\r
- HelpStr, PcdErr = ParseDecPcdGenericComment(GenericComment, \r
- ContainerFile)\r
- if PcdErr:\r
- Pcd.SetPcdErrorsList([PcdErr])\r
+ HelpStr, PcdErrList, PromptStr = ParseDecPcdGenericComment(GenericComment, \r
+ ContainerFile, \r
+ TokenGuidCName, \r
+ TokenName,\r
+ MacroReplaceDict)\r
+ if PcdErrList:\r
+ Pcd.SetPcdErrorsList(PcdErrList)\r
\r
if TailComment:\r
SupModuleList, TailHelpStr = ParseDecPcdTailComment(TailComment, \r
HelpStr += '\n'\r
HelpStr += TailHelpStr\r
if HelpStr:\r
- HelpTxtObj = TextObject() \r
+ HelpTxtObj = TextObject()\r
+ HelpTxtObj.SetLang(Language) \r
HelpTxtObj.SetString(HelpStr)\r
Pcd.SetHelpTextList([HelpTxtObj])\r
+ if PromptStr:\r
+ TxtObj = TextObject()\r
+ TxtObj.SetLang(Language)\r
+ TxtObj.SetString(PromptStr)\r
+ Pcd.SetPromptList([TxtObj])\r
\r
return Pcd\r
## @file InfPomAlignment.py\r
# This file contained the adapter for convert INF parser object to POM Object\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
# Import modules\r
#\r
import os.path\r
-\r
from Logger import StringTable as ST\r
import Logger.Log as Logger\r
-\r
from Library.String import FORMAT_INVALID\r
from Library.String import PARSER_ERROR\r
from Library.String import NormPath\r
from Library.Misc import ConvertVersionToDecimal\r
from Library.Misc import GetHelpStringByRemoveHashKey\r
from Library.Misc import ConvertArchList\r
+from Library.Misc import GetRelativePath\r
+from Library.Misc import PathClass\r
from Library.Parsing import GetPkgInfoFromDec\r
+from Library.UniClassObject import UniFileClassObject\r
+from Library.UniClassObject import ConvertSpecialUnicodes\r
+from Library.UniClassObject import GetLanguageCode1766\r
from Library import DataType as DT\r
from Library import GlobalData\r
-\r
+from Library.ParserValidate import IsValidPath\r
from Object.POM import CommonObject\r
from Object.POM.ModuleObject import ModuleObject\r
from Object.POM.ModuleObject import ExternObject\r
from PomAdapter.InfPomAlignmentMisc import GenModuleHeaderUserExt\r
from PomAdapter.InfPomAlignmentMisc import GenBinaryData\r
from Parser import InfParser\r
-\r
+from PomAdapter.DecPomAlignment import DecPomAlignment\r
\r
\r
## InfPomAlignment\r
#\r
def __init__(self, FileName, WorkSpace=None, PackagePath='', Skip=False):\r
ModuleObject.__init__(self)\r
-\r
self.Parser = None\r
self.FileName = FileName\r
self.WorkSpace = WorkSpace\r
self.ModulePath = ''\r
self.WorkspaceDir = " "\r
self.CustomMakefile = []\r
-\r
+ self.UniFileClassObject = None\r
self.SetPackagePath(PackagePath)\r
#\r
# Call GenInfPomObjects function to fill POM object.\r
if Skip:\r
OrigConfig = Logger.SUPRESS_ERROR\r
Logger.SUPRESS_ERROR = True\r
- self._GenInfPomObjects(Skip)\r
- Logger.SUPRESS_ERROR = OrigConfig\r
+ try:\r
+ self._GenInfPomObjects(Skip)\r
+ finally:\r
+ Logger.SUPRESS_ERROR = OrigConfig\r
else:\r
self._GenInfPomObjects(Skip)\r
\r
self._GenGuidProtocolPpis(DT.TAB_PROTOCOLS)\r
self._GenGuidProtocolPpis(DT.TAB_PPIS)\r
self._GenDepexes()\r
- self._GenMiscFiles(self.FullPath, Skip)\r
\r
## Convert [Defines] section content to InfDefObject\r
#\r
ArchList = GetSplitValueList(ArchString, ' ')\r
ArchList = ConvertArchList(ArchList)\r
HasCalledFlag = False\r
-\r
#\r
# Get data from Sdict()\r
#\r
# ModuleSurfaceArea.Header.Name element\r
#\r
self.SetName(os.path.splitext(os.path.basename(self.FileName))[0])\r
-\r
self.WorkspaceDir = " "\r
#\r
# CombinePath and ModulePath\r
#\r
- PathCount = self.FullPath.upper().find(self.WorkSpace.upper()) + len(self.WorkSpace) + 1\r
- CombinePath = self.FullPath[PathCount:]\r
+ CombinePath = GetRelativePath(self.FullPath, self.WorkSpace)\r
self.SetCombinePath(CombinePath)\r
-\r
ModulePath = os.path.split(CombinePath)[0]\r
ModuleRelativePath = ModulePath\r
if self.GetPackagePath() != '':\r
- ModuleRelativePath = ModulePath[ModulePath.find(self.GetPackagePath()) + len(self.GetPackagePath()) + 1:]\r
+ ModuleRelativePath = GetRelativePath(ModulePath, self.GetPackagePath())\r
self.SetModulePath(ModuleRelativePath)\r
-\r
#\r
# For Define Seciton Items.\r
#\r
DefineObj = ValueList\r
-\r
#\r
# Convert UEFI/PI version to decimal number\r
#\r
__PiVersion = ConvertVersionToDecimal(__PiVersion)\r
\r
self.SetPiSpecificationVersion(str(__PiVersion))\r
-\r
SpecList = DefineObj.GetSpecification()\r
NewSpecList = []\r
for SpecItem in SpecList:\r
ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("BASE_NAME"), File=self.FullPath)\r
else:\r
self.SetBaseName(DefineObj.GetBaseName().GetValue())\r
+ if DefineObj.GetModuleUniFileName():\r
+ self.UniFileClassObject = UniFileClassObject([PathClass(DefineObj.GetModuleUniFileName())])\r
+ else:\r
+ self.UniFileClassObject = None\r
if DefineObj.GetInfVersion() == None:\r
Logger.Error("InfParser", FORMAT_INVALID,\r
ST.ERR_INF_PARSER_DEFINE_SECTION_MUST_ITEM_NOT_EXIST % ("INF_VERSION"), File=self.FullPath)\r
#\r
Logger.Error("Parser", PARSER_ERROR, ST.ERR_INF_PARSER_NOT_SUPPORT_EDKI_INF, ExtraData=self.FullPath,\r
RaiseError=Logger.IS_RAISE_ERROR)\r
-\r
#\r
# if there is Shadow, Should judge the MODULE_TYPE in \r
# SEC, PEI_CORE and PEIM\r
\r
if DefineObj.GetPcdIsDriver() != None:\r
self.SetPcdIsDriver(DefineObj.GetPcdIsDriver().GetValue())\r
-\r
#\r
# LIBRARY_CLASS\r
#\r
self._GenModuleHeaderLibClass(DefineObj, ArchList)\r
-\r
#\r
# CUSTOM_MAKEFILE\r
#\r
if not HasCalledFlag:\r
self._GenModuleHeaderExterns(DefineObj)\r
HasCalledFlag = True\r
-\r
#\r
# each module has only one module header\r
#\r
# put all define statement into user-extension sections\r
# \r
DefinesDictNew = GenModuleHeaderUserExt(DefineObj, ArchString)\r
-\r
if DefinesDictNew:\r
UserExtension = CommonObject.UserExtensionObject()\r
UserExtension.SetDefinesDict(DefinesDictNew)\r
UserExtension.SetIdentifier('DefineModifiers')\r
UserExtension.SetUserID('EDK2')\r
self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])\r
-\r
#\r
# Get all meta-file header information\r
# the record is list of items formated: \r
# [LineValue, Arch, StartLine, ID, Third]\r
#\r
-\r
InfHeaderObj = self.Parser.InfHeader\r
#\r
# Put header information into POM object\r
#\r
- self.SetAbstract(InfHeaderObj.GetAbstract())\r
- self.SetDescription(InfHeaderObj.GetDescription())\r
- self.SetCopyright(InfHeaderObj.GetCopyright())\r
- self.SetLicense(InfHeaderObj.GetLicense())\r
+ if self.UniFileClassObject:\r
+ Lang = DT.TAB_LANGUAGE_EN_X\r
+ else:\r
+ Lang = DT.TAB_LANGUAGE_EN_US\r
+ if InfHeaderObj.GetAbstract():\r
+ self.SetAbstract((Lang, InfHeaderObj.GetAbstract()))\r
+ if InfHeaderObj.GetDescription():\r
+ self.SetDescription((Lang, InfHeaderObj.GetDescription()))\r
+ if InfHeaderObj.GetCopyright():\r
+ self.SetCopyright(('', InfHeaderObj.GetCopyright()))\r
+ if InfHeaderObj.GetLicense():\r
+ self.SetLicense(('', InfHeaderObj.GetLicense()))\r
+ #\r
+ # Put Binary header information into POM object\r
+ #\r
+ InfBinaryHeaderObj = self.Parser.InfBinaryHeader\r
+ if InfBinaryHeaderObj.GetAbstract():\r
+ self.SetBinaryHeaderAbstract((Lang, InfBinaryHeaderObj.GetAbstract()))\r
+ if InfBinaryHeaderObj.GetDescription():\r
+ self.SetBinaryHeaderDescription((Lang, InfBinaryHeaderObj.GetDescription()))\r
+ if InfBinaryHeaderObj.GetCopyright():\r
+ self.SetBinaryHeaderCopyright(('', InfBinaryHeaderObj.GetCopyright()))\r
+ if InfBinaryHeaderObj.GetLicense():\r
+ self.SetBinaryHeaderLicense(('', InfBinaryHeaderObj.GetLicense()))\r
\r
## GenModuleHeaderLibClass\r
#\r
Hob.SetSupArchList(Item.GetSupArchList())\r
if Item.GetHelpString():\r
HelpTextObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
HelpTextObj.SetString(Item.GetHelpString())\r
Hob.SetHelpTextList([HelpTextObj])\r
HobList.append(Hob)\r
Event.SetUsage(Item.GetUsage())\r
if Item.GetHelpString():\r
HelpTextObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
HelpTextObj.SetString(Item.GetHelpString())\r
Event.SetHelpTextList([HelpTextObj])\r
EventList.append(Event)\r
BootMode.SetUsage(Item.GetUsage())\r
if Item.GetHelpString():\r
HelpTextObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
HelpTextObj.SetString(Item.GetHelpString())\r
BootMode.SetHelpTextList([HelpTextObj])\r
BootModeList.append(BootMode)\r
BuildOptionsList = self.Parser.InfBuildOptionSection.GetBuildOptions()\r
if not GlobalData.gIS_BINARY_INF:\r
BuildOptionDict = {}\r
-\r
for BuildOptionObj in BuildOptionsList:\r
ArchList = BuildOptionObj.GetSupArchList()\r
ArchList = ConvertArchList(ArchList)\r
BuildOptionsContent = BuildOptionObj.GetContent()\r
ArchString = ' '.join(ArchList)\r
-\r
if not BuildOptionsContent:\r
continue\r
-\r
BuildOptionDict[ArchString] = BuildOptionsContent\r
-\r
if not BuildOptionDict:\r
return\r
UserExtension = CommonObject.UserExtensionObject()\r
#\r
LibClassObj = self.Parser.InfLibraryClassSection.LibraryClasses\r
Keys = LibClassObj.keys()\r
-\r
for Key in Keys:\r
LibraryClassData = LibClassObj[Key]\r
for Item in LibraryClassData:\r
LibraryClass.SetSupArchList(ConvertArchList(Item.GetSupArchList()))\r
LibraryClass.SetSupModuleList(Item.GetSupModuleList())\r
HelpStringObj = Item.GetHelpString()\r
-\r
if HelpStringObj != None:\r
CommentString = GetHelpStringByRemoveHashKey(HelpStringObj.HeaderComments +\r
HelpStringObj.TailComments)\r
HelpTextHeaderObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextHeaderObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
HelpTextHeaderObj.SetString(CommentString)\r
LibraryClass.SetHelpTextList([HelpTextHeaderObj])\r
-\r
self.SetLibraryClassList(self.GetLibraryClassList() + [LibraryClass])\r
\r
## GenPackages\r
# Get all Packages\r
#\r
PackageObj = self.Parser.InfPackageSection.Packages\r
-\r
#\r
# Go through each arch\r
#\r
def _GenPcds(self):\r
if not GlobalData.gIS_BINARY_INF:\r
Logger.Debug(2, "Generate %s ..." % DT.TAB_PCDS)\r
-\r
#\r
# Get all Pcds\r
#\r
PcdObj = self.Parser.InfPcdSection.Pcds\r
KeysList = PcdObj.keys()\r
-\r
#\r
# Go through each arch\r
#\r
Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())\r
Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))\r
HelpTextObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
HelpTextObj.SetString(CommentItem.GetHelpStringItem())\r
Pcd.SetHelpTextList([HelpTextObj])\r
PcdList = self.GetPcdList()\r
Identifier = UserExtensionDataObj.GetIdString()\r
if Identifier.startswith('"') and Identifier.endswith('"'):\r
Identifier = Identifier[1:-1]\r
+ #\r
+ # Generate miscellaneous files on INF file\r
+ #\r
+ if UserId == 'TianoCore' and Identifier == 'ExtraFiles':\r
+ self._GenMiscFiles(UserExtensionDataObj.GetContent())\r
UserExtension.SetIdentifier(Identifier)\r
UserExtension.SetStatement(UserExtensionDataObj.GetContent())\r
UserExtension.SetSupArchList(ConvertArchList(UserExtensionDataObj.GetSupArchList()))\r
self.SetUserExtensionList(self.GetUserExtensionList() + [UserExtension])\r
-\r
+ \r
+ #\r
+ # Gen UserExtensions of TianoCore."BinaryHeader"\r
+ #\r
+ \r
+ #Get Binary header from INF file\r
+ BinaryAbstractList = self.BinaryHeaderAbstractList\r
+ BinaryDescriptionList = self.BinaryHeaderDescriptionList\r
+ BinaryCopyrightList = self.BinaryHeaderCopyrightList\r
+ BinaryLicenseList = self.BinaryHeaderLicenseList\r
+ #Get Binary header from UNI file\r
+ # Initialize UniStrDict, the top keys are language codes\r
+ UniStrDict = {}\r
+ if self.UniFileClassObject:\r
+ UniStrDict = self.UniFileClassObject.OrderedStringList\r
+ for Lang in UniStrDict:\r
+ for StringDefClassObject in UniStrDict[Lang]:\r
+ Lang = GetLanguageCode1766(Lang)\r
+ if StringDefClassObject.StringName == DT.TAB_INF_BINARY_ABSTRACT:\r
+ BinaryAbstractList.append((Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+ if StringDefClassObject.StringName == DT.TAB_INF_BINARY_DESCRIPTION:\r
+ BinaryDescriptionList.append((Lang, ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+ if BinaryAbstractList or BinaryDescriptionList or BinaryCopyrightList or BinaryLicenseList:\r
+ BinaryUserExtension = CommonObject.UserExtensionObject()\r
+ BinaryUserExtension.SetBinaryAbstract(BinaryAbstractList)\r
+ BinaryUserExtension.SetBinaryDescription(BinaryDescriptionList)\r
+ BinaryUserExtension.SetBinaryCopyright(BinaryCopyrightList)\r
+ BinaryUserExtension.SetBinaryLicense(BinaryLicenseList)\r
+ BinaryUserExtension.SetIdentifier(DT.TAB_BINARY_HEADER_IDENTIFIER)\r
+ BinaryUserExtension.SetUserID(DT.TAB_BINARY_HEADER_USERID)\r
+ self.SetUserExtensionList(self.GetUserExtensionList() + [BinaryUserExtension])\r
+ \r
def _GenDepexesList(self, SmmDepexList, DxeDepexList, PeiDepexList):\r
if SmmDepexList:\r
self.SetSmmDepex(SmmDepexList)\r
ModuleType = Depex.GetModuleType()\r
ModuleTypeList = []\r
if IsLibraryClass:\r
- if not self.GetIsLibraryModList():\r
+ if self.GetModuleType() == 'BASE' and not ModuleType:\r
+ Logger.Error("\nMkPkg", PARSER_ERROR,\r
+ ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_BASE_LIBRARY_CLASS,\r
+ self.GetFullPath(), RaiseError=True)\r
+ if self.GetModuleType() != 'BASE' and not self.GetIsLibraryModList():\r
Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_INVALID_FOR_LIBRARY_CLASS,\r
self.GetFullPath(), RaiseError=True)\r
- if ModuleType and ModuleType not in self.GetIsLibraryModList():\r
+ if self.GetModuleType() != 'BASE' and ModuleType and ModuleType not in self.GetIsLibraryModList():\r
Logger.Error("\nMkPkg", PARSER_ERROR, ST.ERR_INF_PARSER_DEPEX_SECTION_NOT_DETERMINED,\r
self.GetFullPath(), RaiseError=True)\r
if ModuleType:\r
DepexIns.SetFeatureFlag(Depex.GetFeatureFlagExp())\r
if Depex.HelpString:\r
HelpIns = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpIns.SetLang(DT.TAB_LANGUAGE_EN_X)\r
HelpIns.SetString(GetHelpStringByRemoveHashKey(Depex.HelpString))\r
DepexIns.SetHelpText(HelpIns)\r
\r
AsBuildLibIns = AsBuildLibraryClassObject()\r
AsBuildLibIns.SetLibGuid(LibItem.GetFileGuid())\r
AsBuildLibIns.SetLibVersion(LibItem.GetVersion())\r
+ AsBuildLibIns.SetSupArchList(LibItem.GetSupArchList())\r
AsBuildLibraryClassList.append(AsBuildLibIns)\r
AsBuildIns.SetLibraryInstancesList(AsBuildLibraryClassList)\r
\r
# BuildOption AsBuild Info\r
# \r
for BuildOptionItem in self.Parser.InfBuildOptionSection.GetBuildOptions():\r
- AsBuildBuildOptionList += BuildOptionItem.GetAsBuildList()\r
+ AsBuildBuildOptionList.append(BuildOptionItem)\r
AsBuildIns.SetBuildFlagsList(AsBuildBuildOptionList)\r
\r
#\r
#\r
AsBuildIns = self._GenAsBuiltPcds(self.Parser.InfPcdSection.GetPcds(), AsBuildIns)\r
\r
+ #\r
+ # Parse the DEC file that contains the GUID value of the GUID CName which is used by\r
+ # SUBTYPE_GUID type binary file in the Binaries section in the INF file\r
+ #\r
+ DecObjList = []\r
+ if not self.PackagePath:\r
+ WorkSpace = os.path.normpath(self.WorkSpace)\r
+ TempPath = ModulePath = os.path.normpath(self.ModulePath)\r
+ while ModulePath:\r
+ TempPath = ModulePath\r
+ ModulePath = os.path.dirname(ModulePath)\r
+ PackageName = TempPath\r
+ DecFilePath = os.path.normpath(os.path.join(WorkSpace, PackageName)) \r
+ if DecFilePath:\r
+ for File in os.listdir(DecFilePath):\r
+ if File.upper().endswith('.DEC'):\r
+ DecFileFullPath = os.path.normpath(os.path.join(DecFilePath, File))\r
+ DecObjList.append(DecPomAlignment(DecFileFullPath, self.WorkSpace))\r
+ \r
+ \r
BinariesDict, AsBuildIns, BinaryFileObjectList = GenBinaryData(BinaryData, BinaryObj,\r
BinariesDict,\r
AsBuildIns,\r
BinaryFileObjectList,\r
self.GetSupArchList(),\r
- self.BinaryModule)\r
-\r
+ self.BinaryModule,\r
+ DecObjList)\r
+ \r
BinariesDict2 = {}\r
for Key in BinariesDict:\r
ValueList = BinariesDict[Key]\r
Pcd.SetItemType(PcdItem[0])\r
Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())\r
Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))\r
- HelpTextObj = CommonObject.TextObject()\r
- HelpTextObj.SetString(PcdItemObj.GetHelpStringList())\r
- Pcd.SetHelpTextList([HelpTextObj])\r
+ Pcd.SetValidUsage(PcdItemObj.GetValidUsage())\r
+ for CommentItem in PcdItemObj.GetHelpStringList():\r
+ HelpTextObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
+ HelpTextObj.SetString(CommentItem.GetHelpStringItem())\r
+ Pcd.SetHelpTextList(Pcd.GetHelpTextList() + [HelpTextObj])\r
AsBuildPatchPcdList.append(Pcd)\r
else:\r
PcdItemObj = PcdItem[1]\r
Pcd.SetItemType(PcdItem[0])\r
Pcd.SetFeatureFlag(PcdItemObj.GetFeatureFlagExp())\r
Pcd.SetSupArchList(ConvertArchList(PcdItemObj.GetSupportArchList()))\r
- HelpTextObj = CommonObject.TextObject()\r
- HelpTextObj.SetString(PcdItemObj.GetHelpStringList())\r
- Pcd.SetHelpTextList([HelpTextObj])\r
+ Pcd.SetValidUsage(PcdItemObj.GetValidUsage())\r
+ for CommentItem in PcdItemObj.GetHelpStringList():\r
+ HelpTextObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
+ HelpTextObj.SetString(CommentItem.GetHelpStringItem())\r
+ Pcd.SetHelpTextList(Pcd.GetHelpTextList() + [HelpTextObj])\r
AsBuildPcdExList.append(Pcd)\r
AsBuildIns.SetPatchPcdList(AsBuildPatchPcdList)\r
AsBuildIns.SetPcdExList(AsBuildPcdExList)\r
ListObject.SetSupArchList(ConvertArchList(Item.GetSupArchList()))\r
ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())\r
HelpString = GuidComentItem.GetHelpStringItem()\r
- HelpTxtTailObj = CommonObject.TextObject()\r
- HelpTxtTailObj.SetString(HelpString)\r
-\r
- ListObject.SetHelpTextList([HelpTxtTailObj])\r
-\r
+ if HelpString.strip():\r
+ HelpTxtTailObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTxtTailObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
+ HelpTxtTailObj.SetString(HelpString)\r
+ ListObject.SetHelpTextList([HelpTxtTailObj])\r
+ \r
GuidProtocolPpiList.append(ListObject)\r
elif Type == DT.TAB_PROTOCOLS:\r
ProtocolData = ProtocolObj.keys()\r
ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())\r
ListObject.SetNotify(CommentItem.GetNotify())\r
ListObject.SetUsage(CommentItem.GetUsageItem())\r
- HelpTxtObj = CommonObject.TextObject()\r
HelpString = CommentItem.GetHelpStringItem()\r
- HelpTxtObj.SetString(HelpString)\r
- ListObject.SetHelpTextList([HelpTxtObj])\r
+ if HelpString.strip():\r
+ HelpTxtObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTxtObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
+ HelpTxtObj.SetString(HelpString)\r
+ ListObject.SetHelpTextList([HelpTxtObj])\r
GuidProtocolPpiList.append(ListObject)\r
elif Type == DT.TAB_PPIS:\r
PpiData = PpisObj.keys()\r
ListObject.SetFeatureFlag(Item.GetFeatureFlagExp())\r
ListObject.SetNotify(CommentItem.GetNotify())\r
ListObject.SetUsage(CommentItem.GetUsage())\r
- HelpTextObj = CommonObject.TextObject()\r
HelpString = CommentItem.GetHelpStringItem()\r
- HelpTextObj.SetString(HelpString)\r
- ListObject.SetHelpTextList([HelpTextObj])\r
+ if HelpString.strip():\r
+ HelpTextObj = CommonObject.TextObject()\r
+ if self.UniFileClassObject:\r
+ HelpTextObj.SetLang(DT.TAB_LANGUAGE_EN_X)\r
+ HelpTextObj.SetString(HelpString)\r
+ ListObject.SetHelpTextList([HelpTextObj])\r
GuidProtocolPpiList.append(ListObject)\r
\r
if Type == DT.TAB_GUIDS:\r
#\r
# @param ContainerFile: The Inf file full path\r
#\r
- def _GenMiscFiles(self, ContainerFile, Skip):\r
- pass\r
-\r
+ def _GenMiscFiles(self, Content):\r
+ MiscFileObj = CommonObject.MiscFileObject()\r
+ for Line in Content.splitlines():\r
+ FileName = ''\r
+ if '#' in Line:\r
+ FileName = Line[:Line.find('#')]\r
+ else:\r
+ FileName = Line\r
+ if FileName:\r
+ if IsValidPath(FileName, GlobalData.gINF_MODULE_DIR):\r
+ FileObj = CommonObject.FileObject()\r
+ FileObj.SetURI(FileName)\r
+ MiscFileObj.SetFileList(MiscFileObj.GetFileList()+[FileObj])\r
+ else:\r
+ Logger.Error("InfParser", \r
+ FORMAT_INVALID,\r
+ ST.ERR_INF_PARSER_FILE_NOT_EXIST_OR_NAME_INVALID%(Line),\r
+ File=GlobalData.gINF_MODULE_NAME,\r
+ ExtraData=Line) \r
+ self.SetMiscFileList(self.GetMiscFileList()+[MiscFileObj]) \r
+ \r
## @file InfPomAlignmentMisc.py\r
# This file contained the routines for InfPomAlignment\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.Misc import ConvertArchList\r
from Object.POM.ModuleObject import BinaryFileObject\r
from Object.POM import CommonObject\r
+from Library.String import FORMAT_INVALID\r
+from Library.Misc import CheckGuidRegFormat\r
+from Logger import StringTable as ST\r
+\r
\r
## GenModuleHeaderUserExt\r
#\r
## GenBinaryData\r
#\r
#\r
-def GenBinaryData(BinaryData, BinaryObj, BinariesDict, AsBuildIns, BinaryFileObjectList, SupArchList, BinaryModule):\r
+def GenBinaryData(BinaryData, BinaryObj, BinariesDict, AsBuildIns, BinaryFileObjectList, \\r
+ SupArchList, BinaryModule, DecObjList=None):\r
if BinaryModule:\r
pass\r
OriSupArchList = SupArchList\r
else:\r
TagName = ''\r
Family = ''\r
+ \r
FFE = ItemObj.GetFeatureFlagExp()\r
\r
#\r
FileNameObj.SetFileType(ItemObj.GetType())\r
FileNameObj.SetFilename(ItemObj.GetFileName())\r
FileNameObj.SetFeatureFlag(FFE)\r
+ #\r
+ # Get GUID value of the GUID CName in the DEC file\r
+ #\r
+ if ItemObj.GetType() == DT.SUBTYPE_GUID_BINARY_FILE_TYPE: \r
+ if not CheckGuidRegFormat(ItemObj.GetGuidValue()):\r
+ if not DecObjList:\r
+ if DT.TAB_HORIZON_LINE_SPLIT in ItemObj.GetGuidValue() or \\r
+ DT.TAB_COMMA_SPLIT in ItemObj.GetGuidValue():\r
+ Logger.Error("\nMkPkg",\r
+ FORMAT_INVALID,\r
+ ST.ERR_DECPARSE_DEFINE_PKGGUID,\r
+ ExtraData=ItemObj.GetGuidValue(),\r
+ RaiseError=True)\r
+ else:\r
+ Logger.Error("\nMkPkg",\r
+ FORMAT_INVALID,\r
+ ST.ERR_UNI_SUBGUID_VALUE_DEFINE_DEC_NOT_FOUND % \\r
+ (ItemObj.GetGuidValue()),\r
+ RaiseError=True)\r
+ else:\r
+ for DecObj in DecObjList:\r
+ for GuidObj in DecObj.GetGuidList():\r
+ if GuidObj.GetCName() == ItemObj.GetGuidValue():\r
+ FileNameObj.SetGuidValue(GuidObj.GetGuid())\r
+ break\r
+\r
+ if not FileNameObj.GetGuidValue(): \r
+ Logger.Error("\nMkPkg",\r
+ FORMAT_INVALID,\r
+ ST.ERR_DECPARSE_CGUID_NOT_FOUND % \\r
+ (ItemObj.GetGuidValue()),\r
+ RaiseError=True) \r
+ else:\r
+ FileNameObj.SetGuidValue(ItemObj.GetGuidValue().strip())\r
+\r
FileNameObj.SetSupArchList(SupArchList)\r
FileNameList = [FileNameObj]\r
\r
--- /dev/null
+## @file\r
+# Replace distribution package.\r
+#\r
+# Copyright (c) 2014, 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
+Replace a distribution package\r
+"""\r
+##\r
+# Import Modules\r
+#\r
+from shutil import rmtree\r
+from traceback import format_exc\r
+from platform import python_version\r
+from sys import platform\r
+from Logger import StringTable as ST\r
+from Logger.ToolError import UNKNOWN_ERROR\r
+from Logger.ToolError import FatalError\r
+from Logger.ToolError import ABORT_ERROR\r
+from Logger.ToolError import CODE_ERROR\r
+from Logger.ToolError import UPT_ALREADY_INSTALLED_ERROR\r
+import Logger.Log as Logger\r
+\r
+from Core.DependencyRules import DependencyRules\r
+from Library import GlobalData\r
+from InstallPkg import UnZipDp\r
+from InstallPkg import InstallDp\r
+from RmPkg import GetInstalledDpInfo\r
+from RmPkg import RemoveDist\r
+\r
+## Tool entrance method\r
+#\r
+# This method mainly dispatch specific methods per the command line options.\r
+# If no error found, return zero value so the caller of this tool can know\r
+# if it's executed successfully or not.\r
+#\r
+# @param Options: command Options\r
+#\r
+def Main(Options = None):\r
+ ContentZipFile, DistFile = None, None\r
+ try:\r
+ DataBase = GlobalData.gDB\r
+ WorkspaceDir = GlobalData.gWORKSPACE\r
+ Dep = DependencyRules(DataBase)\r
+ DistPkg, ContentZipFile, DpPkgFileName, DistFile = UnZipDp(WorkspaceDir, Options.PackFileToReplace)\r
+ \r
+ StoredDistFile, OrigDpGuid, OrigDpVersion = GetInstalledDpInfo(Options.PackFileToBeReplaced, \\r
+ Dep, DataBase, WorkspaceDir)\r
+ \r
+ #\r
+ # check dependency\r
+ #\r
+ CheckReplaceDpx(Dep, DistPkg, OrigDpGuid, OrigDpVersion)\r
+ \r
+ #\r
+ # Remove the old distribution\r
+ #\r
+ RemoveDist(OrigDpGuid, OrigDpVersion, StoredDistFile, DataBase, WorkspaceDir, Options.Yes)\r
+ \r
+ #\r
+ # Install the new distribution\r
+ #\r
+ InstallDp(DistPkg, DpPkgFileName, ContentZipFile, Options, Dep, WorkspaceDir, DataBase)\r
+ ReturnCode = 0\r
+ \r
+ except FatalError, XExcept:\r
+ ReturnCode = XExcept.args[0]\r
+ if Logger.GetLevel() <= Logger.DEBUG_9:\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
+ platform) + format_exc())\r
+ except KeyboardInterrupt:\r
+ ReturnCode = ABORT_ERROR\r
+ if Logger.GetLevel() <= Logger.DEBUG_9:\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
+ platform) + format_exc())\r
+ except:\r
+ ReturnCode = CODE_ERROR\r
+ Logger.Error(\r
+ "\nReplacePkg",\r
+ CODE_ERROR,\r
+ ST.ERR_UNKNOWN_FATAL_REPLACE_ERR % (Options.PackFileToReplace, Options.PackFileToBeReplaced),\r
+ ExtraData=ST.MSG_SEARCH_FOR_HELP,\r
+ RaiseError=False\r
+ )\r
+ Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(),\r
+ platform) + format_exc())\r
+\r
+ finally:\r
+ Logger.Quiet(ST.MSG_REMOVE_TEMP_FILE_STARTED)\r
+ if DistFile:\r
+ DistFile.Close()\r
+ if ContentZipFile:\r
+ ContentZipFile.Close()\r
+ if GlobalData.gUNPACK_DIR:\r
+ rmtree(GlobalData.gUNPACK_DIR)\r
+ GlobalData.gUNPACK_DIR = None\r
+ Logger.Quiet(ST.MSG_REMOVE_TEMP_FILE_DONE) \r
+\r
+ if ReturnCode == 0:\r
+ Logger.Quiet(ST.MSG_FINISH)\r
+ \r
+ return ReturnCode\r
+\r
+def CheckReplaceDpx(Dep, DistPkg, OrigDpGuid, OrigDpVersion):\r
+ NewDpPkgList = []\r
+ for PkgInfo in DistPkg.PackageSurfaceArea:\r
+ Guid, Version = PkgInfo[0], PkgInfo[1]\r
+ NewDpPkgList.append((Guid, Version))\r
+\r
+ NewDpInfo = "%s %s" % (DistPkg.Header.GetGuid(), DistPkg.Header.GetVersion())\r
+ OrigDpInfo = "%s %s" % (OrigDpGuid, OrigDpVersion)\r
+\r
+ #\r
+ # check whether new distribution is already installed and not replacing itself\r
+ #\r
+ if (NewDpInfo != OrigDpInfo):\r
+ if Dep.CheckDpExists(DistPkg.Header.GetGuid(), DistPkg.Header.GetVersion()):\r
+ Logger.Error("\nReplacePkg", UPT_ALREADY_INSTALLED_ERROR,\r
+ ST.WRN_DIST_PKG_INSTALLED,\r
+ ExtraData=ST.MSG_REPLACE_ALREADY_INSTALLED_DP) \r
+\r
+ #\r
+ # check whether the original distribution could be replaced by new distribution\r
+ # \r
+ Logger.Verbose(ST.MSG_CHECK_DP_FOR_REPLACE%(NewDpInfo, OrigDpInfo))\r
+ DepInfoResult = Dep.CheckDpDepexForReplace(OrigDpGuid, OrigDpVersion, NewDpPkgList)\r
+ Replaceable = DepInfoResult[0]\r
+ if not Replaceable:\r
+ Logger.Error("\nReplacePkg", UNKNOWN_ERROR,\r
+ ST.ERR_PACKAGE_NOT_MATCH_DEPENDENCY)\r
+ \r
+ #\r
+ # check whether new distribution could be installed by dependency rule\r
+ #\r
+ Logger.Verbose(ST.MSG_CHECK_DP_FOR_INSTALL%str(NewDpInfo))\r
+ if not Dep.ReplaceCheckNewDpDepex(DistPkg, OrigDpGuid, OrigDpVersion):\r
+ Logger.Error("\nReplacePkg", UNKNOWN_ERROR,\r
+ ST.ERR_PACKAGE_NOT_MATCH_DEPENDENCY,\r
+ ExtraData=DistPkg.Header.Name)\r
+\r
## @file\r
# Install distribution package.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from sys import platform\r
\r
from Core.DependencyRules import DependencyRules\r
-from Library.Misc import CheckEnvVariable\r
from Library import GlobalData\r
from Logger import StringTable as ST\r
import Logger.Log as Logger\r
Logger.Error("RmPkg", \r
OPTION_MISSING, \r
ExtraData=ST.ERR_SPECIFY_PACKAGE)\r
- CheckEnvVariable()\r
WorkspaceDir = GlobalData.gWORKSPACE\r
#\r
# Prepare check dependency\r
#\r
Dep = DependencyRules(DataBase)\r
\r
- if Options.DistributionFile:\r
- (Guid, Version, NewDpFileName) = \\r
- DataBase.GetDpByName(os.path.split(Options.DistributionFile)[1])\r
- if not Guid:\r
- Logger.Error("RmPkg", UNKNOWN_ERROR, ST.ERR_PACKAGE_NOT_INSTALLED % Options.DistributionFile)\r
- else:\r
- Guid = Options.PackageGuid\r
- Version = Options.PackageVersion\r
- #\r
- # Check Dp existing\r
- #\r
- if not Dep.CheckDpExists(Guid, Version):\r
- Logger.Error("RmPkg", UNKNOWN_ERROR, ST.ERR_DISTRIBUTION_NOT_INSTALLED)\r
#\r
- # Check for Distribution files existence in /conf/upt, if not exist, \r
- # Warn user and go on.\r
+ # Get the Dp information\r
#\r
- StoredDistFile = os.path.normpath(os.path.join(WorkspaceDir, GlobalData.gUPT_DIR, NewDpFileName))\r
- if not os.path.isfile(StoredDistFile):\r
- Logger.Warn("RmPkg", ST.WRN_DIST_NOT_FOUND%StoredDistFile)\r
- StoredDistFile = None\r
- \r
+ StoredDistFile, Guid, Version = GetInstalledDpInfo(Options.DistributionFile, Dep, DataBase, WorkspaceDir)\r
+\r
# \r
# Check Dp depex\r
#\r
CheckDpDepex(Dep, Guid, Version, WorkspaceDir)\r
\r
+ # \r
+ # remove distribution\r
#\r
- # Get Current File List\r
- #\r
- NewFileList = GetCurrentFileList(DataBase, Guid, Version, WorkspaceDir)\r
-\r
- #\r
- # Remove all files\r
- #\r
- MissingFileList = []\r
- for (Path, Md5Sum) in DataBase.GetDpFileList(Guid, Version):\r
- if os.path.isfile(Path):\r
- if Path in NewFileList:\r
- NewFileList.remove(Path)\r
- if not Options.Yes:\r
- #\r
- # check whether modified by users\r
- #\r
- Md5Sigature = md5.new(open(str(Path), 'rb').read())\r
- if Md5Sum != Md5Sigature.hexdigest():\r
- Logger.Info(ST.MSG_CONFIRM_REMOVE2 % Path)\r
- Input = stdin.readline()\r
- Input = Input.replace('\r', '').replace('\n', '')\r
- if Input.upper() != 'Y':\r
- continue\r
- RemovePath(Path)\r
- else:\r
- MissingFileList.append(Path)\r
- \r
- for Path in NewFileList:\r
- if os.path.isfile(Path):\r
- if (not Options.Yes) and (not os.path.split(Path)[1].startswith('.')):\r
- Logger.Info(ST.MSG_CONFIRM_REMOVE3 % Path)\r
- Input = stdin.readline()\r
- Input = Input.replace('\r', '').replace('\n', '')\r
- if Input.upper() != 'Y':\r
- continue\r
- RemovePath(Path)\r
-\r
- #\r
- # Remove distribution files in /Conf/.upt\r
- #\r
- if StoredDistFile is not None:\r
- os.remove(StoredDistFile)\r
+ RemoveDist(Guid, Version, StoredDistFile, DataBase, WorkspaceDir, Options.Yes)\r
\r
- #\r
- # update database\r
- #\r
- Logger.Quiet(ST.MSG_UPDATE_PACKAGE_DATABASE)\r
- DataBase.RemoveDpObj(Guid, Version)\r
Logger.Quiet(ST.MSG_FINISH)\r
\r
ReturnCode = 0\r
format_exc())\r
ReturnCode = CODE_ERROR\r
return ReturnCode\r
- \r
\r
+## GetInstalledDpInfo method\r
+#\r
+# Get the installed distribution information\r
+#\r
+# @param DistributionFile: the name of the distribution\r
+# @param Dep: the instance of DependencyRules\r
+# @param DataBase: the internal database\r
+# @param WorkspaceDir: work space directory\r
+# @retval StoredDistFile: the distribution file that backed up\r
+# @retval Guid: the Guid of the distribution\r
+# @retval Version: the Version of distribution\r
+#\r
+def GetInstalledDpInfo(DistributionFile, Dep, DataBase, WorkspaceDir):\r
+ (Guid, Version, NewDpFileName) = DataBase.GetDpByName(os.path.split(DistributionFile)[1])\r
+ if not Guid:\r
+ Logger.Error("RmPkg", UNKNOWN_ERROR, ST.ERR_PACKAGE_NOT_INSTALLED % DistributionFile)\r
+\r
+ #\r
+ # Check Dp existing\r
+ #\r
+ if not Dep.CheckDpExists(Guid, Version):\r
+ Logger.Error("RmPkg", UNKNOWN_ERROR, ST.ERR_DISTRIBUTION_NOT_INSTALLED)\r
+ #\r
+ # Check for Distribution files existence in /conf/upt, if not exist, \r
+ # Warn user and go on.\r
+ #\r
+ StoredDistFile = os.path.normpath(os.path.join(WorkspaceDir, GlobalData.gUPT_DIR, NewDpFileName))\r
+ if not os.path.isfile(StoredDistFile):\r
+ Logger.Warn("RmPkg", ST.WRN_DIST_NOT_FOUND%StoredDistFile)\r
+ StoredDistFile = None\r
+\r
+ return StoredDistFile, Guid, Version\r
+\r
+## RemoveDist method\r
+#\r
+# remove a distribution\r
+#\r
+# @param Guid: the Guid of the distribution\r
+# @param Version: the Version of distribution\r
+# @param StoredDistFile: the distribution file that backed up\r
+# @param DataBase: the internal database\r
+# @param WorkspaceDir: work space directory\r
+# @param ForceRemove: whether user want to remove file even it is modified\r
+#\r
+def RemoveDist(Guid, Version, StoredDistFile, DataBase, WorkspaceDir, ForceRemove):\r
+ #\r
+ # Get Current File List\r
+ #\r
+ NewFileList = GetCurrentFileList(DataBase, Guid, Version, WorkspaceDir)\r
+\r
+ #\r
+ # Remove all files\r
+ #\r
+ MissingFileList = []\r
+ for (Path, Md5Sum) in DataBase.GetDpFileList(Guid, Version):\r
+ if os.path.isfile(Path):\r
+ if Path in NewFileList:\r
+ NewFileList.remove(Path)\r
+ if not ForceRemove:\r
+ #\r
+ # check whether modified by users\r
+ #\r
+ Md5Sigature = md5.new(open(str(Path), 'rb').read())\r
+ if Md5Sum != Md5Sigature.hexdigest():\r
+ Logger.Info(ST.MSG_CONFIRM_REMOVE2 % Path)\r
+ Input = stdin.readline()\r
+ Input = Input.replace('\r', '').replace('\n', '')\r
+ if Input.upper() != 'Y':\r
+ continue\r
+ RemovePath(Path)\r
+ else:\r
+ MissingFileList.append(Path)\r
+ \r
+ for Path in NewFileList:\r
+ if os.path.isfile(Path):\r
+ if (not ForceRemove) and (not os.path.split(Path)[1].startswith('.')):\r
+ Logger.Info(ST.MSG_CONFIRM_REMOVE3 % Path)\r
+ Input = stdin.readline()\r
+ Input = Input.replace('\r', '').replace('\n', '')\r
+ if Input.upper() != 'Y':\r
+ continue\r
+ RemovePath(Path)\r
+\r
+ #\r
+ # Remove distribution files in /Conf/.upt\r
+ #\r
+ if StoredDistFile is not None:\r
+ os.remove(StoredDistFile)\r
+\r
+ #\r
+ # update database\r
+ #\r
+ Logger.Quiet(ST.MSG_UPDATE_PACKAGE_DATABASE)\r
+ DataBase.RemoveDpObj(Guid, Version)\r
#\r
# This file is the main entry for UPT \r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
\r
## import modules\r
#\r
+from Core import FileHook\r
import sys\r
import os.path\r
-from os import environ\r
from sys import platform\r
+import platform as pf\r
from optparse import OptionParser\r
from traceback import format_exc\r
from platform import python_version\r
from Logger.ToolError import FILE_TYPE_MISMATCH\r
from Logger.ToolError import OPTION_CONFLICT\r
from Logger.ToolError import FatalError\r
+\r
import MkPkg\r
import InstallPkg\r
import RmPkg\r
-from Library.Misc import CheckEnvVariable\r
+import InventoryWs\r
+import ReplacePkg\r
+from Library.Misc import GetWorkspace\r
from Library import GlobalData\r
from Core.IpiDb import IpiDatabase\r
from BuildVersion import gBUILD_VERSION\r
# CheckConflictOption\r
#\r
def CheckConflictOption(Opt):\r
- if (Opt.PackFileToCreate and Opt.PackFileToInstall and Opt.PackFileToRemove):\r
+ if (Opt.PackFileToCreate or Opt.PackFileToInstall or Opt.PackFileToRemove or Opt.PackFileToReplace) \\r
+ and Opt.InventoryWs:\r
+ Logger.Error("UPT", OPTION_CONFLICT, ExtraData=ST.ERR_L_OA_EXCLUSIVE)\r
+ elif Opt.PackFileToReplace and (Opt.PackFileToCreate or Opt.PackFileToInstall or Opt.PackFileToRemove):\r
+ Logger.Error("UPT", OPTION_CONFLICT, ExtraData=ST.ERR_U_ICR_EXCLUSIVE)\r
+ elif (Opt.PackFileToCreate and Opt.PackFileToInstall and Opt.PackFileToRemove):\r
Logger.Error("UPT", OPTION_CONFLICT, ExtraData=ST.ERR_REQUIRE_I_C_R_OPTION)\r
elif Opt.PackFileToCreate and Opt.PackFileToInstall:\r
Logger.Error("UPT", OPTION_CONFLICT, ExtraData=ST.ERR_I_C_EXCLUSIVE)\r
elif Opt.PackFileToCreate and Opt.PackFileToRemove:\r
Logger.Error("UPT", OPTION_CONFLICT, ExtraData=ST.ERR_C_R_EXCLUSIVE)\r
\r
+ if Opt.CustomPath and Opt.UseGuidedPkgPath:\r
+ Logger.Warn("UPT", ST.WARN_CUSTOMPATH_OVERRIDE_USEGUIDEDPATH)\r
+ Opt.UseGuidedPkgPath = False\r
+\r
## SetLogLevel\r
#\r
def SetLogLevel(Opt):\r
Parser.add_option("-m", "--inf-filename", action="append", type="string", dest="EDK2_INF_Filename",\r
help=ST.HLP_SPECIFY_INF_NAME_CREATE)\r
\r
+ Parser.add_option("-l", "--list", action="store_true", dest="List_Dist_Installed",\r
+ help=ST.HLP_LIST_DIST_INSTALLED)\r
+\r
Parser.add_option("-f", "--force", action="store_true", dest="Yes", help=ST.HLP_DISABLE_PROMPT)\r
\r
Parser.add_option("-n", "--custom-path", action="store_true", dest="CustomPath", help=ST.HLP_CUSTOM_PATH_PROMPT)\r
\r
Parser.add_option("-x", "--free-lock", action="store_true", dest="SkipLock", help=ST.HLP_SKIP_LOCK_CHECK)\r
\r
+ Parser.add_option("-u", "--replace", action="store", type="string", dest="Replace_Distribution_Package_File",\r
+ help=ST.HLP_SPECIFY_PACKAGE_NAME_REPLACE)\r
+\r
+ Parser.add_option("-o", "--original", action="store", type="string", dest="Original_Distribution_Package_File",\r
+ help=ST.HLP_SPECIFY_PACKAGE_NAME_TO_BE_REPLACED)\r
+\r
+ Parser.add_option("--use-guided-paths", action="store_true", dest="Use_Guided_Paths", help=ST.HLP_USE_GUIDED_PATHS)\r
+\r
Opt = Parser.parse_args()[0]\r
\r
Var2Var = [\r
("PackFileToCreate", Opt.Create_Distribution_Package_File),\r
("PackFileToRemove", Opt.Remove_Distribution_Package_File),\r
("PackageFileList", Opt.EDK2_DEC_Filename),\r
- ("ModuleFileList", Opt.EDK2_INF_Filename)\r
+ ("ModuleFileList", Opt.EDK2_INF_Filename),\r
+ ("InventoryWs", Opt.List_Dist_Installed),\r
+ ("PackFileToReplace", Opt.Replace_Distribution_Package_File),\r
+ ("PackFileToBeReplaced", Opt.Original_Distribution_Package_File),\r
+ ("UseGuidedPkgPath", Opt.Use_Guided_Paths),\r
]\r
+\r
for Var in Var2Var:\r
setattr(Opt, Var[0], Var[1])\r
\r
try:\r
- CheckEnvVariable()\r
+ GlobalData.gWORKSPACE = GetWorkspace()\r
except FatalError, XExcept:\r
if Logger.GetLevel() <= Logger.DEBUG_9:\r
Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(), platform) + format_exc())\r
return XExcept.args[0]\r
\r
- GlobalData.gWORKSPACE = os.path.normpath(environ["WORKSPACE"])\r
+ # Start *********************************************\r
+ # Support WORKSPACE is a long path\r
+ # Only work well on windows\r
+ # Linux Solution TBD\r
+ if pf.system() == 'Windows':\r
+ os.system('@echo off\nsubst b: /D')\r
+ os.system('subst b: "%s"' % GlobalData.gWORKSPACE)\r
+ GlobalData.gWORKSPACE = 'B:\\'\r
+ # End ***********************************************\r
+\r
WorkspaceDir = GlobalData.gWORKSPACE\r
\r
SetLogLevel(Opt)\r
\r
- GlobalData.gDB = IpiDatabase(os.path.normpath(os.path.join(WorkspaceDir, "Conf/DistributionPackageDatabase.db")))\r
+ Mgr = FileHook.RecoverMgr(WorkspaceDir)\r
+ FileHook.SetRecoverMgr(Mgr)\r
+\r
+ GlobalData.gDB = IpiDatabase(os.path.normpath(os.path.join(WorkspaceDir, \\r
+ "Conf/DistributionPackageDatabase.db")), WorkspaceDir)\r
GlobalData.gDB.InitDatabase(Opt.SkipLock)\r
\r
#\r
elif Opt.PackFileToInstall:\r
if not Opt.PackFileToInstall.endswith('.dist'):\r
Logger.Error("InstallPkg", FILE_TYPE_MISMATCH, ExtraData=ST.ERR_DIST_EXT_ERROR % Opt.PackFileToInstall)\r
- \r
- #\r
- # check file existence, if not absolute path, then try current working directory, then $(WORKSPACE) \r
- #\r
- Existed = True\r
- if os.path.isabs(Opt.PackFileToInstall):\r
- if not (os.path.exists(Opt.PackFileToInstall) and os.path.isfile(Opt.PackFileToInstall)):\r
- Existed = False\r
- else:\r
- AbsPath = os.path.normpath(os.path.join(os.getcwd(), Opt.PackFileToInstall))\r
- if not (os.path.exists(AbsPath) and os.path.isfile(AbsPath)):\r
- AbsPath = os.path.normpath(os.path.join(WorkspaceDir, Opt.PackFileToInstall))\r
- if not (os.path.exists(AbsPath) and os.path.isfile(AbsPath)):\r
- Existed = False\r
- \r
- if Existed:\r
- Opt.PackFileToInstall = AbsPath\r
- \r
- if not Existed:\r
+\r
+ AbsPath = GetFullPathDist(Opt.PackFileToInstall, WorkspaceDir)\r
+ if not AbsPath:\r
Logger.Error("InstallPkg", FILE_NOT_FOUND, ST.ERR_INSTALL_DIST_NOT_FOUND % Opt.PackFileToInstall)\r
\r
+ Opt.PackFileToInstall = AbsPath\r
setattr(Opt, 'PackageFile', Opt.PackFileToInstall)\r
RunModule = InstallPkg.Main\r
\r
\r
setattr(Opt, 'DistributionFile', Opt.PackFileToRemove)\r
RunModule = RmPkg.Main\r
+ elif Opt.InventoryWs:\r
+ RunModule = InventoryWs.Main\r
+\r
+ elif Opt.PackFileToBeReplaced and not Opt.PackFileToReplace:\r
+ Logger.Error("ReplacePkg", OPTION_MISSING, ExtraData=ST.ERR_REQUIRE_U_OPTION)\r
+\r
+ elif Opt.PackFileToReplace:\r
+ if not Opt.PackFileToReplace.endswith('.dist'):\r
+ Logger.Error("ReplacePkg", FILE_TYPE_MISMATCH, ExtraData=ST.ERR_DIST_EXT_ERROR % Opt.PackFileToReplace)\r
+ if not Opt.PackFileToBeReplaced:\r
+ Logger.Error("ReplacePkg", OPTION_MISSING, ExtraData=ST.ERR_REQUIRE_O_OPTION)\r
+ if not Opt.PackFileToBeReplaced.endswith('.dist'):\r
+ Logger.Error("ReplacePkg",\r
+ FILE_TYPE_MISMATCH,\r
+ ExtraData=ST.ERR_DIST_EXT_ERROR % Opt.PackFileToBeReplaced)\r
+\r
+ head, tail = os.path.split(Opt.PackFileToBeReplaced)\r
+ if head or not tail:\r
+ Logger.Error("ReplacePkg",\r
+ FILE_TYPE_MISMATCH,\r
+ ExtraData=ST.ERR_DIST_FILENAME_ONLY_FOR_REPLACE_ORIG % Opt.PackFileToBeReplaced)\r
+\r
+ AbsPath = GetFullPathDist(Opt.PackFileToReplace, WorkspaceDir)\r
+ if not AbsPath:\r
+ Logger.Error("ReplacePkg", FILE_NOT_FOUND, ST.ERR_REPLACE_DIST_NOT_FOUND % Opt.PackFileToReplace)\r
+\r
+ Opt.PackFileToReplace = AbsPath\r
+ RunModule = ReplacePkg.Main\r
+\r
else:\r
Parser.print_usage()\r
return OPTION_MISSING\r
Logger.Quiet(ST.MSG_PYTHON_ON % (python_version(), platform) + \\r
format_exc())\r
finally:\r
+ try:\r
+ if ReturnCode != 0:\r
+ Logger.Quiet(ST.MSG_RECOVER_START)\r
+ GlobalData.gDB.RollBack()\r
+ Mgr.rollback()\r
+ Logger.Quiet(ST.MSG_RECOVER_DONE)\r
+ else:\r
+ GlobalData.gDB.Commit()\r
+ Mgr.commit()\r
+ except StandardError:\r
+ Logger.Quiet(ST.MSG_RECOVER_FAIL)\r
GlobalData.gDB.CloseDb()\r
+ if pf.system() == 'Windows':\r
+ os.system('subst b: /D')\r
\r
return ReturnCode\r
\r
+## GetFullPathDist\r
+#\r
+# This function will check DistFile existence, if not absolute path, then try current working directory,\r
+# then $(WORKSPACE),and return the AbsPath. If file doesn't find, then return None\r
+#\r
+# @param DistFile: The distribution file in either relative path or absolute path\r
+# @param WorkspaceDir: Workspace Directory\r
+# @return AbsPath: The Absolute path of the distribution file if existed, None else\r
+#\r
+def GetFullPathDist(DistFile, WorkspaceDir):\r
+ if os.path.isabs(DistFile):\r
+ if not (os.path.exists(DistFile) and os.path.isfile(DistFile)):\r
+ return None\r
+ else:\r
+ return DistFile\r
+ else:\r
+ AbsPath = os.path.normpath(os.path.join(os.getcwd(), DistFile))\r
+ if not (os.path.exists(AbsPath) and os.path.isfile(AbsPath)):\r
+ AbsPath = os.path.normpath(os.path.join(WorkspaceDir, DistFile))\r
+ if not (os.path.exists(AbsPath) and os.path.isfile(AbsPath)):\r
+ return None\r
+\r
+ return AbsPath\r
+\r
if __name__ == '__main__':\r
RETVAL = Main()\r
#\r
## @file\r
# This file contain unit test for CommentParsing\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
\r
from Library.String import GetSplitValueList\r
from Library.DataType import TAB_SPACE_SPLIT\r
-from Library.DataType import LANGUAGE_EN_US\r
+from Library.DataType import TAB_LANGUAGE_EN_US\r
+from Library.DataType import TAB_LANGUAGE_ENG\r
from Library.DataType import ITEM_UNDEFINED\r
from Library.DataType import TAB_INF_FEATURE_PCD\r
from Library import GlobalData\r
def testNormalCase1(self):\r
HelpStr = 'Hello world'\r
HelpTextObj = TextObject()\r
- HelpTextObj.SetLang(LANGUAGE_EN_US)\r
+ HelpTextObj.SetLang(TAB_LANGUAGE_EN_US)\r
HelpTextObj.SetString(HelpStr)\r
\r
HelpTextList = [HelpTextObj]\r
def testNormalCase2(self):\r
HelpStr = 'Hello world'\r
HelpTextObj = TextObject()\r
- HelpTextObj.SetLang('eng')\r
+ HelpTextObj.SetLang(TAB_LANGUAGE_ENG)\r
HelpTextObj.SetString(HelpStr)\r
\r
HelpTextList = [HelpTextObj]\r
\r
ExpectedStr = 'Hello world1'\r
HelpTextObj = TextObject()\r
- HelpTextObj.SetLang(LANGUAGE_EN_US)\r
+ HelpTextObj.SetLang(TAB_LANGUAGE_EN_US)\r
HelpTextObj.SetString(ExpectedStr) \r
\r
HelpTextList.append(HelpTextObj)\r
\r
ExpectedStr = 'Hello world1'\r
HelpTextObj = TextObject()\r
- HelpTextObj.SetLang('eng')\r
+ HelpTextObj.SetLang(TAB_LANGUAGE_ENG)\r
HelpTextObj.SetString(ExpectedStr) \r
\r
HelpTextList.append(HelpTextObj)\r
\r
ExpectedStr = 'Hello world1'\r
HelpTextObj = TextObject()\r
- HelpTextObj.SetLang('eng')\r
+ HelpTextObj.SetLang(TAB_LANGUAGE_ENG)\r
HelpTextObj.SetString(ExpectedStr) \r
HelpTextList = [HelpTextObj]\r
\r
\r
ExpectedStr = 'Hello world1'\r
HelpTextObj = TextObject()\r
- HelpTextObj.SetLang(LANGUAGE_EN_US)\r
+ HelpTextObj.SetLang(TAB_LANGUAGE_EN_US)\r
HelpTextObj.SetString(ExpectedStr) \r
HelpTextList = [HelpTextObj]\r
\r
## @file\r
# This file contain unit test for CommentParsing\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.CommentParsing import _IsCopyrightLine\r
from Library.String import GetSplitValueList\r
from Library.DataType import TAB_SPACE_SPLIT\r
-from Library.DataType import LANGUAGE_EN_US\r
+from Library.DataType import TAB_LANGUAGE_EN_US\r
\r
#\r
# Test ParseHeaderCommentSection\r
HelptxtObj = ParseGenericComment(TestCommentLinesList, 'testNormalCase1')\r
self.failIf(not HelptxtObj)\r
self.assertEqual(HelptxtObj.GetString(), 'hello world')\r
- self.assertEqual(HelptxtObj.GetLang(), LANGUAGE_EN_US)\r
+ self.assertEqual(HelptxtObj.GetLang(), TAB_LANGUAGE_EN_US)\r
\r
#\r
# Normal case2: multiple lines of comment\r
self.failIf(not HelptxtObj)\r
self.assertEqual(HelptxtObj.GetString(), \r
'hello world\n' + 'second line')\r
- self.assertEqual(HelptxtObj.GetLang(), LANGUAGE_EN_US)\r
+ self.assertEqual(HelptxtObj.GetLang(), TAB_LANGUAGE_EN_US)\r
\r
#\r
# Normal case3: multiple lines of comment, non comment lines will be skipped\r
self.failIf(not HelptxtObj)\r
self.assertEqual(HelptxtObj.GetString(), \r
'hello world\n\n')\r
- self.assertEqual(HelptxtObj.GetLang(), LANGUAGE_EN_US)\r
+ self.assertEqual(HelptxtObj.GetLang(), TAB_LANGUAGE_EN_US)\r
\r
#\r
# Test ParseDecPcdGenericComment\r
## @file\r
# This file is used to parse a PCD file of .PKG file\r
#\r
-# Copyright (c) 2011 - 2013, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Library.Xml.XmlRoutines import XmlNode\r
from Library.Xml.XmlRoutines import XmlList\r
from Library.Xml.XmlRoutines import CreateXmlElement\r
+from Library.UniClassObject import ConvertSpecialUnicodes\r
+from Library.UniClassObject import GetLanguageCode1766\r
from Object.POM.CommonObject import FileObject\r
from Object.POM.CommonObject import MiscFileObject\r
from Object.POM.CommonObject import UserExtensionObject\r
from Object.POM.ModuleObject import ModuleObject\r
from Xml.XmlParserMisc import IsRequiredItemListNull\r
from Xml.XmlParserMisc import GetHelpTextList\r
-\r
import Library.DataType as DataType\r
\r
##\r
def FromXml(self, Item, Key):\r
self.GUID = XmlElement(Item, '%s/GUID' % Key)\r
self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')\r
-\r
if self.GUID == '' and self.Version == '':\r
return None\r
-\r
ClonedFrom = ClonedRecordObject()\r
ClonedFrom.SetPackageGuid(self.GUID)\r
ClonedFrom.SetPackageVersion(self.Version)\r
-\r
return ClonedFrom\r
\r
def ToXml(self, ClonedFrom, Key):\r
AttributeList = []\r
NodeList = [Element1]\r
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
-\r
return Root\r
\r
def __str__(self):\r
[Mod for Mod in GetSplitValueList(XmlAttribute(Item, 'SupModList'), DataType.TAB_SPACE_SPLIT) if Mod]\r
self.FeatureFlag = ConvertNOTEQToNE(XmlAttribute(Item, 'FeatureFlag'))\r
\r
-\r
def ToXml(self):\r
pass\r
\r
return "Usage = %s SupArchList = %s SupModList = %s FeatureFlag = %s" \\r
% (self.Usage, self.SupArchList, self.SupModList, self.FeatureFlag)\r
\r
+##\r
+# PromptXml\r
+#\r
+class PromptXml(object):\r
+ def __init__(self):\r
+ self.Prompt = ''\r
+ self.Lang = ''\r
\r
+ def FromXml(self, Item, Key):\r
+ if Key:\r
+ pass\r
+ self.Prompt = XmlElement2(Item, 'Prompt')\r
+ self.Lang = XmlAttribute(Item, 'Lang')\r
+\r
+ def ToXml(self, Prompt, Key='Prompt'):\r
+ if self.Prompt:\r
+ pass\r
+ return CreateXmlElement('%s' % Key, Prompt.GetString(), [], [['Lang', Prompt.GetLang()]])\r
+ def __str__(self):\r
+ return "Prompt = %s Lang = %s" % (self.Prompt, self.Lang)\r
+ \r
##\r
# HelpTextXml\r
#\r
self.BaseName = ''\r
self.GUID = ''\r
self.Version = ''\r
- self.Copyright = ''\r
- self.License = ''\r
- self.Abstract = ''\r
- self.Description = ''\r
+ self.CopyrightList = []\r
+ self.LicenseList = []\r
+ self.AbstractList = []\r
+ self.DescriptionList = []\r
\r
def FromXml(self, Item, Key, IsRequiredCheck=False, IsStandAlongModule=False):\r
if not Item and IsRequiredCheck:\r
self.BaseName = XmlAttribute(XmlNode(Item, '%s/Name' % Key), 'BaseName')\r
self.GUID = XmlElement(Item, '%s/GUID' % Key)\r
self.Version = XmlAttribute(XmlNode(Item, '%s/GUID' % Key), 'Version')\r
- self.Copyright = XmlElement(Item, '%s/Copyright' % Key)\r
- self.License = XmlElement(Item, '%s/License' % Key)\r
- self.Abstract = XmlElement(Item, '%s/Abstract' % Key)\r
- self.Description = XmlElement(Item, '%s/Description' % Key)\r
\r
+ for SubItem in XmlList(Item, '%s/Abstract' % Key):\r
+ HeaderAbstractLang = XmlAttribute(SubItem, 'Lang')\r
+ self.AbstractList.append((HeaderAbstractLang, XmlElement(SubItem, '%s/Abstract' % Key)))\r
+ for SubItem in XmlList(Item, '%s/Description' % Key):\r
+ HeaderDescriptionLang = XmlAttribute(SubItem, 'Lang')\r
+ self.DescriptionList.append((HeaderDescriptionLang, XmlElement(SubItem, '%s/Description' % Key)))\r
+ for SubItem in XmlList(Item, '%s/Copyright' % Key):\r
+ HeaderCopyrightLang = XmlAttribute(SubItem, 'Lang')\r
+ self.CopyrightList.append((HeaderCopyrightLang, XmlElement(SubItem, '%s/Copyright' % Key)))\r
+ for SubItem in XmlList(Item, '%s/License' % Key):\r
+ HeaderLicenseLang = XmlAttribute(SubItem, 'Lang')\r
+ self.LicenseList.append((HeaderLicenseLang, XmlElement(SubItem, '%s/License' % Key))) \r
ModuleHeader = ModuleObject()\r
ModuleHeader.SetName(self.Name)\r
ModuleHeader.SetBaseName(self.BaseName)\r
ModuleHeader.SetGuid(self.GUID)\r
ModuleHeader.SetVersion(self.Version)\r
- ModuleHeader.SetCopyright(self.Copyright)\r
- ModuleHeader.SetLicense(self.License)\r
- ModuleHeader.SetAbstract(self.Abstract)\r
- ModuleHeader.SetDescription(self.Description)\r
-\r
+ ModuleHeader.SetCopyright(self.CopyrightList)\r
+ ModuleHeader.SetLicense(self.LicenseList)\r
+ ModuleHeader.SetAbstract(self.AbstractList)\r
+ ModuleHeader.SetDescription(self.DescriptionList)\r
return ModuleHeader\r
\r
def ToXml(self, Header, Key):\r
pass\r
Element1 = CreateXmlElement('Name', Header.GetName(), [], [['BaseName', Header.GetBaseName()]])\r
Element2 = CreateXmlElement('GUID', Header.GetGuid(), [], [['Version', Header.GetVersion()]])\r
- AttributeList = []\r
NodeList = [Element1,\r
Element2,\r
- ['Copyright', Header.GetCopyright()],\r
- ['License', Header.GetLicense()],\r
- ['Abstract', Header.GetAbstract()],\r
- ['Description', Header.GetDescription()],\r
]\r
- Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
\r
+ UNIInfAbstractList = []\r
+ UNIInfDescriptionList = []\r
+ # Get Abstract and Description from Uni File\r
+ # if the Uni File exists\r
+ if Header.UniFileClassObject is not None:\r
+ UniStrDict = Header.UniFileClassObject.OrderedStringList\r
+ for Lang in UniStrDict:\r
+ for StringDefClassObject in UniStrDict[Lang]:\r
+ if not StringDefClassObject.StringValue:\r
+ continue\r
+ if StringDefClassObject.StringName == DataType.TAB_INF_ABSTRACT:\r
+ UNIInfAbstractList.append((GetLanguageCode1766(Lang),\r
+ ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+\r
+ if StringDefClassObject.StringName == DataType.TAB_INF_DESCRIPTION:\r
+ UNIInfDescriptionList.append((GetLanguageCode1766(Lang),\r
+ ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+\r
+ # Get Abstract and Description from INF File Header\r
+ for (Lang, Value) in Header.GetCopyright():\r
+ if Value:\r
+ NodeList.append(CreateXmlElement('Copyright', Value, [], []))\r
+ for (Lang, Value) in Header.GetLicense():\r
+ if Value:\r
+ NodeList.append(CreateXmlElement('License', Value, [], []))\r
+ for (Lang, Value) in Header.GetAbstract() + UNIInfAbstractList:\r
+ if Value:\r
+ NodeList.append(CreateXmlElement('Abstract', Value, [], [['Lang', Lang]]))\r
+ for (Lang, Value) in Header.GetDescription() + UNIInfDescriptionList:\r
+ if Value:\r
+ NodeList.append(CreateXmlElement('Description', Value, [], [['Lang', Lang]]))\r
+\r
+ AttributeList = []\r
+ Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
return Root\r
\r
def __str__(self):\r
return "Name = %s BaseName = %s GUID = %s Version = %s Copyright = %s \\r
License = %s Abstract = %s Description = %s" % \\r
- (self.Name, self.BaseName, self.GUID, self.Version, self.Copyright, \\r
- self.License, self.Abstract, self.Description)\r
+ (self.Name, self.BaseName, self.GUID, self.Version, self.CopyrightList, \\r
+ self.LicenseList, self.AbstractList, self.DescriptionList)\r
##\r
# DistributionPackageHeaderXml\r
#\r
self.Signature = XmlElement(Item, '%s/Signature' % Key)\r
self.XmlSpecification = XmlElement(Item, '%s/XmlSpecification' % Key)\r
self.Header.FromXml(Item, Key)\r
-\r
DistributionPackageHeader = DistributionPackageHeaderObject()\r
if self.ReadOnly.upper() == 'TRUE':\r
DistributionPackageHeader.ReadOnly = True\r
elif self.ReadOnly.upper() == 'FALSE':\r
DistributionPackageHeader.ReadOnly = False\r
-\r
if self.RePackage.upper() == 'TRUE':\r
DistributionPackageHeader.RePackage = True\r
elif self.RePackage.upper() == 'FALSE':\r
DistributionPackageHeader.Date = self.Date\r
DistributionPackageHeader.Signature = self.Signature\r
DistributionPackageHeader.XmlSpecification = self.XmlSpecification\r
-\r
DistributionPackageHeader.SetName(self.Header.Name)\r
DistributionPackageHeader.SetBaseName(self.Header.BaseName)\r
DistributionPackageHeader.SetGuid(self.Header.GUID)\r
DistributionPackageHeader.SetVersion(self.Header.Version)\r
- DistributionPackageHeader.SetCopyright(self.Header.Copyright)\r
- DistributionPackageHeader.SetLicense(self.Header.License)\r
- DistributionPackageHeader.SetAbstract(self.Header.Abstract)\r
- DistributionPackageHeader.SetDescription(self.Header.Description)\r
-\r
+ DistributionPackageHeader.SetCopyright(self.Header.CopyrightList)\r
+ DistributionPackageHeader.SetLicense(self.Header.LicenseList)\r
+ DistributionPackageHeader.SetAbstract(self.Header.AbstractList)\r
+ DistributionPackageHeader.SetDescription(self.Header.DescriptionList)\r
return DistributionPackageHeader\r
\r
def ToXml(self, DistributionPackageHeader, Key):\r
AttributeList.append(['ReadOnly', str(DistributionPackageHeader.ReadOnly).lower()])\r
if DistributionPackageHeader.RePackage != '':\r
AttributeList.append(['RePackage', str(DistributionPackageHeader.RePackage).lower()])\r
-\r
+ if DistributionPackageHeader.GetAbstract():\r
+ DPAbstract = DistributionPackageHeader.GetAbstract()[0][1]\r
+ else:\r
+ DPAbstract = ''\r
+ if DistributionPackageHeader.GetDescription():\r
+ DPDescription = DistributionPackageHeader.GetDescription()[0][1]\r
+ else:\r
+ DPDescription = ''\r
+ if DistributionPackageHeader.GetCopyright():\r
+ DPCopyright = DistributionPackageHeader.GetCopyright()[0][1]\r
+ else:\r
+ DPCopyright = ''\r
+ if DistributionPackageHeader.GetLicense():\r
+ DPLicense = DistributionPackageHeader.GetLicense()[0][1]\r
+ else:\r
+ DPLicense = ''\r
NodeList = [Element1,\r
Element2,\r
['Vendor', DistributionPackageHeader.Vendor],\r
['Date', DistributionPackageHeader.Date],\r
- ['Copyright', DistributionPackageHeader.GetCopyright()],\r
- ['License', DistributionPackageHeader.GetLicense()],\r
- ['Abstract', DistributionPackageHeader.GetAbstract()],\r
- ['Description', \\r
- DistributionPackageHeader.GetDescription()],\r
+ ['Copyright', DPCopyright],\r
+ ['License', DPLicense],\r
+ ['Abstract', DPAbstract],\r
+ ['Description', DPDescription],\r
['Signature', DistributionPackageHeader.Signature],\r
['XmlSpecification', \\r
DistributionPackageHeader.XmlSpecification],\r
]\r
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
-\r
return Root\r
\r
def __str__(self):\r
IsRequiredItemListNull(CheckDict, XmlTreeLevel)\r
self.PackagePath = XmlElement(Item, '%s/PackagePath' % Key)\r
self.Header.FromXml(Item, Key)\r
-\r
PackageObject2.SetName(self.Header.Name)\r
PackageObject2.SetBaseName(self.Header.BaseName)\r
PackageObject2.SetGuid(self.Header.GUID)\r
PackageObject2.SetVersion(self.Header.Version)\r
- PackageObject2.SetCopyright(self.Header.Copyright)\r
- PackageObject2.SetLicense(self.Header.License)\r
- PackageObject2.SetAbstract(self.Header.Abstract)\r
- PackageObject2.SetDescription(self.Header.Description)\r
+ PackageObject2.SetCopyright(self.Header.CopyrightList)\r
+ PackageObject2.SetLicense(self.Header.LicenseList)\r
+ PackageObject2.SetAbstract(self.Header.AbstractList)\r
+ PackageObject2.SetDescription(self.Header.DescriptionList)\r
PackageObject2.SetPackagePath(self.PackagePath)\r
\r
def ToXml(self, PackageObject2, Key):\r
if self.PackagePath:\r
pass\r
- Element1 = \\r
- CreateXmlElement('Name', PackageObject2.GetName(), [], \\r
+ Element1 = CreateXmlElement('Name', PackageObject2.GetName(), [], \\r
[['BaseName', PackageObject2.GetBaseName()]])\r
Element2 = CreateXmlElement('GUID', PackageObject2.GetGuid(), [], \\r
[['Version', PackageObject2.GetVersion()]])\r
- AttributeList = []\r
NodeList = [Element1,\r
- Element2,\r
- ['Copyright', PackageObject2.GetCopyright()],\r
- ['License', PackageObject2.GetLicense()],\r
- ['Abstract', PackageObject2.GetAbstract()],\r
- ['Description', PackageObject2.GetDescription()],\r
- ['PackagePath', PackageObject2.GetPackagePath()],\r
+ Element2\r
]\r
+ \r
+ UNIPackageAbrstractList = []\r
+ UNIPackageDescriptionList = []\r
+ # Get Abstract and Description from Uni File\r
+ # if the Uni File exists\r
+ if PackageObject2.UniFileClassObject is not None:\r
+ UniStrDict = PackageObject2.UniFileClassObject.OrderedStringList\r
+ for Lang in UniStrDict:\r
+ for StringDefClassObject in UniStrDict[Lang]:\r
+ if not StringDefClassObject.StringValue:\r
+ continue\r
+ if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_ABSTRACT:\r
+ UNIPackageAbrstractList.append((GetLanguageCode1766(Lang), \r
+ ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+\r
+ if StringDefClassObject.StringName == DataType.TAB_DEC_PACKAGE_DESCRIPTION:\r
+ UNIPackageDescriptionList.append((GetLanguageCode1766(Lang), \r
+ ConvertSpecialUnicodes(StringDefClassObject.StringValue)))\r
+\r
+ # Get Abstract and Description from DEC File Header\r
+ for (Lang, Value) in PackageObject2.GetCopyright():\r
+ if Value:\r
+ NodeList.append(CreateXmlElement(DataType.TAB_HEADER_COPYRIGHT, Value, [], []))\r
+ for (Lang, Value) in PackageObject2.GetLicense():\r
+ if Value:\r
+ NodeList.append(CreateXmlElement(DataType.TAB_HEADER_LICENSE, Value, [], []))\r
+ for (Lang, Value) in PackageObject2.GetAbstract() + UNIPackageAbrstractList:\r
+ if Value:\r
+ NodeList.append(CreateXmlElement(DataType.TAB_HEADER_ABSTRACT, Value, [], [['Lang', Lang]]))\r
+ for (Lang, Value) in PackageObject2.GetDescription() + UNIPackageDescriptionList:\r
+ if Value:\r
+ NodeList.append(CreateXmlElement(DataType.TAB_HEADER_DESCRIPTION, Value, [], [['Lang', Lang]]))\r
+ \r
+\r
+ NodeList.append(['PackagePath', PackageObject2.GetPackagePath()])\r
+ AttributeList = []\r
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
-\r
return Root\r
\r
def __str__(self):\r
self.Header.FromXml(Item, Key)\r
NewItem = XmlNode(Item, '%s/Header' % Key)\r
self.Header.FromXml(NewItem, 'Header')\r
-\r
for SubItem in XmlList(Item, '%s/Filename' % Key):\r
Filename = XmlElement(SubItem, '%s/Filename' % Key)\r
Executable = XmlAttribute(XmlNode(SubItem, '%s/Filename' % Key), 'Executable')\r
else:\r
Executable = ''\r
self.Files.append([Filename, Executable])\r
-\r
MiscFile = MiscFileObject()\r
- MiscFile.SetCopyright(self.Header.Copyright)\r
- MiscFile.SetLicense(self.Header.License)\r
- MiscFile.SetAbstract(self.Header.Abstract)\r
- MiscFile.SetDescription(self.Header.Description)\r
+ MiscFile.SetCopyright(self.Header.CopyrightList)\r
+ MiscFile.SetLicense(self.Header.LicenseList)\r
+ MiscFile.SetAbstract(self.Header.AbstractList)\r
+ MiscFile.SetDescription(self.Header.DescriptionList)\r
MiscFileList = []\r
for File in self.Files:\r
FileObj = FileObject()\r
FileObj.SetExecutable(File[1])\r
MiscFileList.append(FileObj)\r
MiscFile.SetFileList(MiscFileList)\r
-\r
return MiscFile\r
##\r
# This API is used for DistP's tool section\r
def FromXml2(self, Item, Key):\r
if Item is None:\r
return None\r
-\r
NewItem = XmlNode(Item, '%s/Header' % Key)\r
self.Header.FromXml(NewItem, 'Header')\r
-\r
for SubItem in XmlList(Item, '%s/Filename' % Key):\r
Filename = XmlElement(SubItem, '%s/Filename' % Key)\r
Executable = \\r
else:\r
Executable = ''\r
self.Files.append([Filename, Executable, OsType])\r
-\r
MiscFile = MiscFileObject()\r
MiscFile.SetName(self.Header.Name)\r
- MiscFile.SetCopyright(self.Header.Copyright)\r
- MiscFile.SetLicense(self.Header.License)\r
- MiscFile.SetAbstract(self.Header.Abstract)\r
- MiscFile.SetDescription(self.Header.Description)\r
+ MiscFile.SetCopyright(self.Header.CopyrightList)\r
+ MiscFile.SetLicense(self.Header.LicenseList)\r
+ MiscFile.SetAbstract(self.Header.AbstractList)\r
+ MiscFile.SetDescription(self.Header.DescriptionList)\r
MiscFileList = []\r
for File in self.Files:\r
FileObj = FileObject()\r
FileObj.SetOS(File[2])\r
MiscFileList.append(FileObj)\r
MiscFile.SetFileList(MiscFileList)\r
-\r
return MiscFile\r
\r
##\r
if self.Header:\r
pass\r
if MiscFile:\r
- NodeList = [['Copyright', MiscFile.GetCopyright()],\r
- ['License', MiscFile.GetLicense()],\r
- ['Abstract', MiscFile.GetAbstract()],\r
- ['Description', MiscFile.GetDescription()],\r
+ if MiscFile.GetAbstract():\r
+ DPAbstract = MiscFile.GetAbstract()[0][1]\r
+ else:\r
+ DPAbstract = ''\r
+ if MiscFile.GetDescription():\r
+ DPDescription = MiscFile.GetDescription()[0][1]\r
+ else:\r
+ DPDescription = ''\r
+ if MiscFile.GetCopyright():\r
+ DPCopyright = MiscFile.GetCopyright()[0][1]\r
+ else:\r
+ DPCopyright = ''\r
+ if MiscFile.GetLicense():\r
+ DPLicense = MiscFile.GetLicense()[0][1]\r
+ else:\r
+ DPLicense = ''\r
+ NodeList = [['Copyright', DPCopyright],\r
+ ['License', DPLicense],\r
+ ['Abstract', DPAbstract],\r
+ ['Description', DPDescription],\r
]\r
-\r
for File in MiscFile.GetFileList():\r
NodeList.append\\r
(CreateXmlElement\\r
('Filename', File.GetURI(), [], \\r
[['Executable', str(File.GetExecutable()).lower()]]))\r
Root = CreateXmlElement('%s' % Key, '', NodeList, [])\r
-\r
return Root\r
##\r
# This API is used for DistP's tool section\r
if self.Header:\r
pass\r
if MiscFile:\r
+ if MiscFile.GetAbstract():\r
+ DPAbstract = MiscFile.GetAbstract()[0][1]\r
+ else:\r
+ DPAbstract = ''\r
+ if MiscFile.GetDescription():\r
+ DPDescription = MiscFile.GetDescription()[0][1]\r
+ else:\r
+ DPDescription = ''\r
+ if MiscFile.GetCopyright():\r
+ DPCopyright = MiscFile.GetCopyright()[0][1]\r
+ else:\r
+ DPCopyright = ''\r
+ if MiscFile.GetLicense():\r
+ DPLicense = MiscFile.GetLicense()[0][1]\r
+ else:\r
+ DPLicense = ''\r
NodeList = [['Name', MiscFile.GetName()],\r
- ['Copyright', MiscFile.GetCopyright()],\r
- ['License', MiscFile.GetLicense()],\r
- ['Abstract', MiscFile.GetAbstract()],\r
- ['Description', MiscFile.GetDescription()],\r
+ ['Copyright', DPCopyright],\r
+ ['License', DPLicense],\r
+ ['Abstract', DPAbstract],\r
+ ['Description', DPDescription],\r
]\r
HeaderNode = CreateXmlElement('Header', '', NodeList, [])\r
NodeList = [HeaderNode]\r
-\r
for File in MiscFile.GetFileList():\r
NodeList.append\\r
(CreateXmlElement\\r
[['Executable', str(File.GetExecutable()).lower()], \\r
['OS', File.GetOS()]]))\r
Root = CreateXmlElement('%s' % Key, '', NodeList, [])\r
-\r
return Root\r
\r
def __str__(self):\r
def __init__(self):\r
self.UserId = ''\r
self.Identifier = ''\r
+ self.BinaryAbstractList = []\r
+ self.BinaryDescriptionList = []\r
+ self.BinaryCopyrightList = []\r
+ self.BinaryLicenseList = []\r
+ self.LangDefsList = []\r
self.DefineDict = {}\r
self.BuildOptionDict = {}\r
self.IncludesDict = {}\r
def FromXml2(self, Item, Key):\r
self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')\r
self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')\r
-\r
UserExtension = UserExtensionObject()\r
UserExtension.SetUserID(self.UserId)\r
UserExtension.SetIdentifier(self.Identifier)\r
-\r
return UserExtension\r
\r
def FromXml(self, Item, Key):\r
self.UserId = XmlAttribute(XmlNode(Item, '%s' % Key), 'UserId')\r
self.Identifier = XmlAttribute(XmlNode(Item, '%s' % Key), 'Identifier')\r
+ if self.UserId == DataType.TAB_BINARY_HEADER_USERID \\r
+ and self.Identifier == DataType.TAB_BINARY_HEADER_IDENTIFIER:\r
+ for SubItem in XmlList(Item, '%s/BinaryAbstract' % Key):\r
+ BinaryAbstractLang = XmlAttribute(SubItem, 'Lang')\r
+ self.BinaryAbstractList.append((BinaryAbstractLang, XmlElement(SubItem, '%s/BinaryAbstract' % Key)))\r
+ for SubItem in XmlList(Item, '%s/BinaryDescription' % Key):\r
+ BinaryDescriptionLang = XmlAttribute(SubItem, 'Lang')\r
+ self.BinaryDescriptionList.append((BinaryDescriptionLang, \r
+ XmlElement(SubItem, '%s/BinaryDescription' % Key)))\r
+ for SubItem in XmlList(Item, '%s/BinaryCopyright' % Key):\r
+ BinaryCopyrightLang = XmlAttribute(SubItem, 'Lang')\r
+ self.BinaryCopyrightList.append((BinaryCopyrightLang, \r
+ XmlElement(SubItem, '%s/BinaryCopyright' % Key)))\r
+ for SubItem in XmlList(Item, '%s/BinaryLicense' % Key):\r
+ BinaryLicenseLang = XmlAttribute(SubItem, 'Lang')\r
+ self.BinaryLicenseList.append((BinaryLicenseLang, \r
+ XmlElement(SubItem, '%s/BinaryLicense' % Key))) \r
\r
DefineItem = XmlNode(Item, '%s/Define' % Key)\r
for SubItem in XmlList(DefineItem, 'Define/Statement'):\r
Statement = XmlElement(SubItem, '%s/Statement' % Key)\r
self.DefineDict[Statement] = ""\r
-\r
BuildOptionItem = XmlNode(Item, '%s/BuildOption' % Key)\r
for SubItem in XmlList(BuildOptionItem, 'BuildOption/Statement'):\r
Statement = XmlElement(SubItem, '%s/Statement' % Key)\r
Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')\r
self.BuildOptionDict[Arch] = Statement\r
-\r
IncludesItem = XmlNode(Item, '%s/Includes' % Key)\r
for SubItem in XmlList(IncludesItem, 'Includes/Statement'):\r
Statement = XmlElement(SubItem, '%s/Statement' % Key)\r
Arch = XmlAttribute(XmlNode(SubItem, '%s/Statement' % Key), 'SupArchList')\r
self.IncludesDict[Statement] = Arch\r
-\r
SourcesItem = XmlNode(Item, '%s/Sources' % Key)\r
Tmp = UserExtensionSourceXml()\r
SourceDict = Tmp.FromXml(SourcesItem, 'Sources')\r
self.SourcesDict = SourceDict\r
-\r
BinariesItem = XmlNode(Item, '%s/Binaries' % Key)\r
Tmp = UserExtensionBinaryXml()\r
BinariesDict = Tmp.FromXml(BinariesItem, 'Binaries')\r
self.BinariesDict = BinariesDict\r
-\r
self.Statement = XmlElement(Item, 'UserExtensions')\r
SupArch = XmlAttribute(XmlNode(Item, '%s' % Key), 'SupArchList')\r
self.SupArchList = [Arch for Arch in GetSplitValueList(SupArch, DataType.TAB_SPACE_SPLIT) if Arch]\r
-\r
UserExtension = UserExtensionObject()\r
UserExtension.SetUserID(self.UserId)\r
UserExtension.SetIdentifier(self.Identifier)\r
+ UserExtension.SetBinaryAbstract(self.BinaryAbstractList)\r
+ UserExtension.SetBinaryDescription(self.BinaryDescriptionList)\r
+ UserExtension.SetBinaryCopyright(self.BinaryCopyrightList)\r
+ UserExtension.SetBinaryLicense(self.BinaryLicenseList)\r
UserExtension.SetStatement(self.Statement)\r
UserExtension.SetSupArchList(self.SupArchList)\r
UserExtension.SetDefinesDict(self.DefineDict)\r
UserExtension.SetIncludesDict(self.IncludesDict)\r
UserExtension.SetSourcesDict(self.SourcesDict)\r
UserExtension.SetBinariesDict(self.BinariesDict)\r
-\r
return UserExtension\r
\r
def ToXml(self, UserExtension, Key):\r
if self.UserId:\r
pass\r
-\r
AttributeList = [['UserId', str(UserExtension.GetUserID())],\r
['Identifier', str(UserExtension.GetIdentifier())],\r
['SupArchList', \\r
GetStringOfList(UserExtension.GetSupArchList())],\r
]\r
-\r
Root = CreateXmlElement('%s' % Key, UserExtension.GetStatement(), [], \\r
- AttributeList)\r
-\r
+ AttributeList)\r
+ if UserExtension.GetIdentifier() == DataType.TAB_BINARY_HEADER_IDENTIFIER and \\r
+ UserExtension.GetUserID() == DataType.TAB_BINARY_HEADER_USERID:\r
+ for (Lang, Value) in UserExtension.GetBinaryAbstract():\r
+ if Value:\r
+ ChildElement = CreateXmlElement('BinaryAbstract', Value, [], [['Lang', Lang]])\r
+ Root.appendChild(ChildElement)\r
+ for (Lang, Value) in UserExtension.GetBinaryDescription():\r
+ if Value:\r
+ ChildElement = CreateXmlElement('BinaryDescription', Value, [], [['Lang', Lang]])\r
+ Root.appendChild(ChildElement)\r
+ for (Lang, Value) in UserExtension.GetBinaryCopyright():\r
+ if Value:\r
+ ChildElement = CreateXmlElement('BinaryCopyright', Value, [], [])\r
+ Root.appendChild(ChildElement)\r
+ for (Lang, Value) in UserExtension.GetBinaryLicense():\r
+ if Value:\r
+ ChildElement = CreateXmlElement('BinaryLicense', Value, [], [])\r
+ Root.appendChild(ChildElement)\r
+ \r
NodeList = []\r
DefineDict = UserExtension.GetDefinesDict()\r
if DefineDict:\r
('Statement', Item, [], []))\r
DefineElement = CreateXmlElement('Define', '', NodeList, [])\r
Root.appendChild(DefineElement)\r
-\r
NodeList = []\r
BuildOptionDict = UserExtension.GetBuildOptionDict()\r
if BuildOptionDict:\r
BuildOptionElement = \\r
CreateXmlElement('BuildOption', '', NodeList, [])\r
Root.appendChild(BuildOptionElement)\r
-\r
NodeList = []\r
IncludesDict = UserExtension.GetIncludesDict()\r
if IncludesDict:\r
[['SupArchList', IncludesDict[Item]]]))\r
IncludesElement = CreateXmlElement('Includes', '', NodeList, [])\r
Root.appendChild(IncludesElement)\r
-\r
NodeList = []\r
SourcesDict = UserExtension.GetSourcesDict()\r
if SourcesDict:\r
Tmp = UserExtensionSourceXml()\r
Root.appendChild(Tmp.ToXml(SourcesDict, 'Sources'))\r
-\r
NodeList = []\r
BinariesDict = UserExtension.GetBinariesDict()\r
if BinariesDict:\r
Tmp = UserExtensionBinaryXml()\r
Root.appendChild(Tmp.ToXml(BinariesDict, 'Binaries'))\r
-\r
return Root\r
\r
def __str__(self):\r
if self.UserExtensionSource:\r
pass\r
Dict = {}\r
-\r
#SourcesItem = XmlNode(Item, '%s/Sources' % Key)\r
for SubItem in XmlList(Item, 'Sources/SourceFile'):\r
FileName = XmlElement(SubItem, 'SourceFile/FileName')\r
FeatureFlag = XmlElement(SubItem, 'SourceFile/FeatureFlag')\r
SupArchStr = XmlElement(SubItem, 'SourceFile/SupArchList')\r
DictKey = (FileName, Family, FeatureFlag, SupArchStr)\r
-\r
ValueList = []\r
for ValueNodeItem in XmlList(SubItem, \\r
'SourceFile/SourceFileOtherAttr'):\r
ToolCode = ''\r
Comment = ''\r
ValueList.append((TagName, ToolCode, Comment))\r
-\r
Dict[DictKey] = ValueList\r
-\r
return Dict\r
\r
def ToXml(self, Dict, Key):\r
pass\r
if self.UserExtensionBinary:\r
pass\r
-\r
Dict = {}\r
-\r
for SubItem in XmlList(Item, 'Binaries/Binary'):\r
FileName = XmlElement(SubItem, 'Binary/FileName')\r
FileType = XmlElement(SubItem, 'Binary/FileType')\r
FFE = XmlElement(SubItem, 'Binary/FeatureFlag')\r
SupArch = XmlElement(SubItem, 'Binary/SupArchList')\r
DictKey = (FileName, FileType, ConvertNOTEQToNE(FFE), SupArch)\r
-\r
ValueList = []\r
for ValueNodeItem in XmlList(SubItem, \\r
'Binary/BinaryFileOtherAttr'):\r
Comment = ''\r
\r
ValueList.append((Target, Family, TagName, Comment))\r
-\r
Dict[DictKey] = ValueList\r
-\r
return Dict\r
\r
def ToXml(self, Dict, Key):\r
HelpTextObj = HelpTextXml()\r
HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)\r
self.HelpText.append(HelpTextObj)\r
-\r
LibraryClass = LibraryClassObject()\r
LibraryClass.SetLibraryClass(self.Keyword)\r
LibraryClass.SetIncludeHeader(self.HeaderFile)\r
LibraryClass.SetSupModuleList(self.CommonDefines.SupModList)\r
LibraryClass.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))\r
LibraryClass.SetHelpTextList(GetHelpTextList(self.HelpText))\r
-\r
return LibraryClass\r
\r
def ToXml(self, LibraryClass, Key):\r
for Item in LibraryClass.GetHelpTextList():\r
Tmp = HelpTextXml()\r
NodeList.append(Tmp.ToXml(Item))\r
-\r
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
-\r
return Root\r
\r
def ToXml2(self, LibraryClass, Key):\r
if self.HeaderFile:\r
pass\r
-\r
FeatureFlag = ConvertNEToNOTEQ(LibraryClass.GetFeatureFlag())\r
-\r
AttributeList = \\r
[['Usage', LibraryClass.GetUsage()], \\r
['SupArchList', GetStringOfList(LibraryClass.GetSupArchList())], \\r
for Item in LibraryClass.GetHelpTextList():\r
Tmp = HelpTextXml()\r
NodeList.append(Tmp.ToXml(Item))\r
-\r
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
-\r
return Root\r
\r
def __str__(self):\r
\r
def FromXml(self, Item, Key):\r
self.FileType = XmlAttribute(Item, 'FileType')\r
+ Guid = XmlAttribute(Item, 'GUID')\r
self.Filename = XmlElement(Item, 'Filename')\r
self.CommonDefines.FromXml(Item, Key)\r
-\r
FeatureFlag = ConvertNOTEQToNE(self.CommonDefines.FeatureFlag)\r
-\r
Filename = FileNameObject()\r
#\r
# Convert File Type\r
#\r
if self.FileType == 'UEFI_IMAGE':\r
self.FileType = 'PE32'\r
-\r
+ \r
+ Filename.SetGuidValue(Guid)\r
Filename.SetFileType(self.FileType)\r
Filename.SetFilename(self.Filename)\r
Filename.SetSupArchList(self.CommonDefines.SupArchList)\r
GetStringOfList(Filename.GetSupArchList())],\r
['FileType', Filename.GetFileType()],\r
['FeatureFlag', ConvertNEToNOTEQ(Filename.GetFeatureFlag())],\r
+ ['GUID', Filename.GetGuidValue()]\r
]\r
Root = CreateXmlElement('%s' % Key, Filename.GetFilename(), [], AttributeList)\r
\r
## @file\r
# This file is for converting package information data file to xml file.\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Logger import StringTable as ST\r
from Library.String import ConvertSpecialChar\r
from Library.ParserValidate import IsValidPath\r
+from Library import GlobalData\r
\r
## log error:\r
#\r
# @param Filename: File to be checked\r
#\r
def ValidateMiscFile(Filename):\r
- Root = ''\r
- if 'WORKSPACE' in os.environ:\r
- Root = os.environ['WORKSPACE']\r
+ Root = GlobalData.gWORKSPACE\r
return __ValidatePath(Filename, Root)\r
\r
## ValidateToolsFile\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 and 'WORKSPACE' in os.environ:\r
- Valid, Cause = __ValidatePath(Filename, os.environ['WORKSPACE'])\r
+ if not Valid:\r
+ Valid, Cause = __ValidatePath(Filename, GlobalData.gWORKSPACE)\r
return Valid, Cause\r
\r
## ParseFileList\r
for Index in range(0, len(FileContent)):\r
LastIndex = Index\r
Line = FileContent[Index].strip()\r
- if Line == '':\r
+ if Line == '' or Line.startswith(';'):\r
continue\r
if Line[0] == TAB_SECTION_START and Line[-1] == TAB_SECTION_END:\r
CurrentKey = ''\r
#\r
# Copyright (c) 2011 - 2014, 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
+# 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
# </Filename> {1,}\r
# <AsBuilt> ... </AsBuilt> {0,}\r
# </BinaryFile> {1,}\r
-# \r
+#\r
class BinaryFileXml(object):\r
def __init__(self):\r
self.FileNames = []\r
pass\r
BinaryFile = BinaryFileObject()\r
FilenameList = []\r
+ SupArchList = ['COMMON']\r
for SubItem in XmlList(Item, '%s/Filename' % Key):\r
Axml = FilenameXml()\r
Bxml = Axml.FromXml(SubItem, 'Filename')\r
FilenameList.append(Bxml)\r
BinaryFile.SetFileNameList(FilenameList)\r
+ for FileName in FilenameList:\r
+ if FileName.GetSupArchList():\r
+ SupArchList = FileName.GetSupArchList()\r
+ BinaryFile.SetSupArchList(SupArchList)\r
if GlobalData.gIS_BINARY_INF:\r
AsBuiltList = []\r
for AsBuiltItem in XmlList(Item, '%s/AsBuilt' % Key):\r
NodeList.append(Tmp.ToXml(Filename, 'Filename'))\r
SupportArch = Filename.SupArchList\r
\r
- if GlobalData.gIS_BINARY_INF:\r
- AsBuildList = BinaryFile.GetAsBuiltList()\r
- PatchPcdValueList = AsBuildList.GetPatchPcdList()\r
- PcdExList = AsBuildList.GetPcdExList()\r
- LibGuidVerList = AsBuildList.GetLibraryInstancesList()\r
- BuildFlagList = AsBuildList.GetBuildFlagsList()\r
-\r
- AsBuiltNodeList = []\r
-\r
- for Pcd in PatchPcdValueList:\r
- if IsMatchArch(Pcd.SupArchList, SupportArch):\r
- Tmp = PcdEntryXml()\r
- AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))\r
-\r
- for Pcd in PcdExList:\r
- if IsMatchArch(Pcd.SupArchList, SupportArch):\r
- Tmp = PcdEntryXml()\r
- AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))\r
-\r
- GuiVerElemList = []\r
- for LibGuidVer in LibGuidVerList:\r
+ AsBuildList = BinaryFile.GetAsBuiltList()\r
+ PatchPcdValueList = AsBuildList.GetPatchPcdList()\r
+ PcdExList = AsBuildList.GetPcdExList()\r
+ LibGuidVerList = AsBuildList.GetLibraryInstancesList()\r
+ BuildFlagList = AsBuildList.GetBuildFlagsList()\r
+\r
+ AsBuiltNodeList = []\r
+\r
+ for Pcd in PatchPcdValueList:\r
+ if IsMatchArch(Pcd.SupArchList, SupportArch):\r
+ Tmp = PcdEntryXml()\r
+ AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PatchPcdValue'))\r
+\r
+ for Pcd in PcdExList:\r
+ if IsMatchArch(Pcd.SupArchList, SupportArch):\r
+ Tmp = PcdEntryXml()\r
+ AsBuiltNodeList.append(Tmp.ToXml4(Pcd, 'PcdExValue'))\r
+\r
+ GuiVerElemList = []\r
+ for LibGuidVer in LibGuidVerList:\r
+ if IsMatchArch(LibGuidVer.GetSupArchList(), SupportArch):\r
GuiVerElem = \\r
CreateXmlElement('GUID', LibGuidVer.GetLibGuid(), [], [['Version', LibGuidVer.GetLibVersion()]])\r
GuiVerElemList.append(GuiVerElem)\r
- if len(GuiVerElemList) > 0:\r
- LibGuidVerElem = CreateXmlElement('LibraryInstances', '', GuiVerElemList, [])\r
- AsBuiltNodeList.append(LibGuidVerElem)\r
+ if len(GuiVerElemList) > 0:\r
+ LibGuidVerElem = CreateXmlElement('LibraryInstances', '', GuiVerElemList, [])\r
+ AsBuiltNodeList.append(LibGuidVerElem)\r
\r
- for BuildFlag in BuildFlagList:\r
- Tmp = BuildFlagXml()\r
- Elem = CreateXmlElement('BuildFlags', ''.join(BuildFlag), [], [])\r
- AsBuiltNodeList.append(Elem)\r
+ for BuildFlag in BuildFlagList:\r
+ if IsMatchArch(BuildFlag.GetSupArchList(), SupportArch):\r
+ for Item in BuildFlag.GetAsBuildList():\r
+ Tmp = BuildFlagXml()\r
+ Elem = CreateXmlElement('BuildFlags', ''.join(Item), [], [])\r
+ AsBuiltNodeList.append(Elem)\r
\r
- if len(AsBuiltNodeList) > 0:\r
- Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])\r
- NodeList.append(Element)\r
+ if len(AsBuiltNodeList) > 0:\r
+ Element = CreateXmlElement('AsBuilt', '', AsBuiltNodeList, [])\r
+ NodeList.append(Element)\r
\r
Root = CreateXmlElement('%s' % Key, '', NodeList, [])\r
\r
for Item in self.HelpText:\r
Str = Str + '\n\t' + str(Item)\r
return Str\r
-## \r
+##\r
# DepexXml\r
#\r
class DepexXml(object):\r
else:\r
Module.SetMiscFileList([])\r
\r
- # \r
+ #\r
# UserExtensions\r
#\r
for Item in XmlList(Item, '/ModuleSurfaceArea/UserExtensions'):\r
not XmlList(Item, '/ModuleSurfaceArea/PackageDependencies/Package'):\r
Module.SetPackageDependencyList([None])\r
\r
- # \r
+ #\r
# Guid\r
#\r
for SubItem in XmlList(Item, '/ModuleSurfaceArea/Guids/GuidCName'):\r
## @file\r
# This file is used to parse a Package file of .PKG file\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
Tmp = PcdEntryXml()\r
PcdEntry = Tmp.FromXml2(SubItem, 'PcdEntry')\r
Package.SetPcdList(Package.GetPcdList() + [PcdEntry])\r
+ \r
+ #\r
+ # Get PcdErrorCommentDict from PcdError in PcdEntry Node\r
+ #\r
+ for PcdErrorObj in PcdEntry.GetPcdErrorsList():\r
+ PcdErrorMessageList = PcdErrorObj.GetErrorMessageList()\r
+ if PcdErrorMessageList:\r
+ Package.PcdErrorCommentDict[(PcdEntry.GetTokenSpaceGuidCName(), PcdErrorObj.GetErrorNumber())] = \\r
+ PcdErrorMessageList\r
+ \r
\r
if XmlList(Item, '/PackageSurfaceArea/PcdDeclarations') and not \\r
XmlList(Item, '/PackageSurfaceArea/PcdDeclarations/PcdEntry'):\r
## @file\r
# This file is used to parse a PCD file of .PKG file\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Object.POM.CommonObject import PcdObject\r
from Object.POM.CommonObject import PcdErrorObject\r
from Xml.CommonXml import HelpTextXml\r
+from Xml.CommonXml import PromptXml\r
from Xml.CommonXml import CommonDefinesXml\r
from Xml.XmlParserMisc import GetHelpTextList\r
+from Xml.XmlParserMisc import GetPromptList\r
+import re\r
\r
##\r
# PcdErrorXml\r
self.ValidValueList = XmlElement(Item, '%s/ValidValueList' % Key)\r
self.ValidValueListLang = \\r
XmlAttribute(XmlNode(Item, '%s/ValidValueList' % Key), 'Lang')\r
- self.ValidValueRange = XmlElement(Item, '%s/ValidValueRange' % Key)\r
+ self.ValidValueRange = self.TransferValidEpxr2ValidRange(XmlElement(Item, '%s/ValidValueRange' % Key))\r
self.Expression = XmlElement(Item, '%s/Expression' % Key)\r
self.ErrorNumber = XmlElement(Item, '%s/ErrorNumber' % Key)\r
for ErrMsg in XmlList(Item, '%s/ErrorMessage' % Key):\r
[['Lang', PcdError.GetValidValueLang()]])\r
NodeList.append(Element1)\r
if PcdError.GetValidValueRange():\r
+ TansferedRangeStr = self.TransferValidRange2Expr(PcdError.GetTokenSpaceGuidCName(),\r
+ PcdError.GetCName(),\r
+ PcdError.GetValidValueRange())\r
Element1 = \\r
CreateXmlElement('ValidValueRange', \\r
- PcdError.GetValidValueRange(), [], [])\r
+ TansferedRangeStr, [], [])\r
NodeList.append(Element1)\r
if PcdError.GetExpression():\r
NodeList.append(['Expression', PcdError.GetExpression()])\r
Root = CreateXmlElement('%s' % Key, '', NodeList, AttributeList)\r
\r
return Root\r
+ \r
+ def TransferValidRange2Expr(self, TokenSpaceGuidCName, CName, ValidRange):\r
+ if self.Expression:\r
+ pass\r
+ INT_RANGE_PATTERN1 = '[\t\s]*[0-9]+[\t\s]*-[\t\s]*[0-9]+'\r
+ INT_RANGE_PATTERN2 = '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'\r
+ HEX_RANGE_PATTERN1 = \\r
+ '[\t\s]*0[xX][a-fA-F0-9]+[\t\s]*-[\t\s]*0[xX][a-fA-F0-9]+'\r
+ HEX_RANGE_PATTERN2 = '[\t\s]*(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][a-fA-F0-9]+[\t\s]*'\r
+ IntMatch1 = re.compile(INT_RANGE_PATTERN1)\r
+ IntMatch2 = re.compile(INT_RANGE_PATTERN2)\r
+ HexMatch1 = re.compile(HEX_RANGE_PATTERN1)\r
+ HexMatch2 = re.compile(HEX_RANGE_PATTERN2)\r
+ PcdName = '.'.join([TokenSpaceGuidCName, CName])\r
+ HexMatchedList = []\r
+ IntMatchedList = []\r
+ #\r
+ # Convert HEX2 format range\r
+ #\r
+ if HexMatch2:\r
+ for MatchObj in HexMatch2.finditer(ValidRange):\r
+ MatchStr = MatchObj.group()\r
+ TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()])\r
+ ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) \r
+ #\r
+ # Convert INT2 format range\r
+ #\r
+ if IntMatch2:\r
+ for MatchObj in IntMatch2.finditer(ValidRange):\r
+ MatchStr = MatchObj.group()\r
+ TransferedRangeStr = ' '.join(['', PcdName, MatchStr.strip()])\r
+ ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) \r
+ #\r
+ # Convert HEX1 format range\r
+ #\r
+ if HexMatch1:\r
+ HexMatchedList += HexMatch1.findall(ValidRange)\r
+ \r
+ for MatchStr in HexMatchedList:\r
+ RangeItemList = MatchStr.strip().split('-')\r
+ TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \\r
+ (PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip())\r
+ ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) \r
+ #\r
+ # Convert INT1 format range\r
+ #\r
+ if IntMatch1:\r
+ IntMatchedList += IntMatch1.findall(ValidRange)\r
+ \r
+ for MatchStr in IntMatchedList:\r
+ RangeItemList = MatchStr.strip().split('-')\r
+ TransferedRangeStr = '(%s GE %s) AND (%s LE %s)' % \\r
+ (PcdName, RangeItemList[0].strip(), PcdName, RangeItemList[1].strip())\r
+ ValidRange = ValidRange.replace(MatchStr, TransferedRangeStr) \r
+ \r
+ return ValidRange\r
+ \r
+ def TransferValidEpxr2ValidRange(self, ValidRangeExpr):\r
+ if self.Expression:\r
+ pass\r
+ \r
+ PCD_PATTERN = \\r
+ '[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*\.[\t\s]*[_a-zA-Z][a-zA-Z0-9_]*[\t\s]*'\r
+ IntPattern1 = \\r
+ '[\t\s]*\([\t\s]*'+PCD_PATTERN+'[\t\s]+GE[\t\s]+\d+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\\r
+ PCD_PATTERN+'[\t\s]+LE[\t\s]+\d+[\t\s]*\)'\r
+ IntPattern1 = IntPattern1.replace(' ', '')\r
+ IntPattern2 = '[\t\s]*'+PCD_PATTERN+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+\d+[\t\s]*'\r
+ \r
+ HexPattern1 = \\r
+ '[\t\s]*\([\t\s]*'+PCD_PATTERN+'[\t\s]+GE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)[\t\s]+AND[\t\s]+\([\t\s]*'+\\r
+ PCD_PATTERN+'[\t\s]+LE[\t\s]+0[xX][0-9a-fA-F]+[\t\s]*\)'\r
+ HexPattern1 = HexPattern1.replace(' ', '')\r
+ HexPattern2 = '[\t\s]*'+PCD_PATTERN+'[\t\s]+(LT|GT|LE|GE|XOR|EQ)[\t\s]+0[xX][0-9a-zA-Z]+[\t\s]*'\r
+ \r
+ #\r
+ # Do the Hex1 conversion\r
+ # \r
+ HexMatchedList = re.compile(HexPattern1).findall(ValidRangeExpr)\r
+ HexRangeDict = {}\r
+ for HexMatchedItem in HexMatchedList:\r
+ #\r
+ # To match items on both sides of '-'\r
+ #\r
+ RangeItemList = re.compile('[\t\s]*0[xX][0-9a-fA-F]+[\t\s]*').findall(HexMatchedItem)\r
+ if RangeItemList and len(RangeItemList) == 2:\r
+ HexRangeDict[HexMatchedItem] = RangeItemList \r
+ \r
+ for Key in HexRangeDict.keys():\r
+ MaxItem = MixItem = ''\r
+ if int(HexRangeDict[Key][0], 16) > int(HexRangeDict[Key][1], 16):\r
+ MaxItem = HexRangeDict[Key][0]\r
+ MixItem = HexRangeDict[Key][1]\r
+ else:\r
+ MaxItem = HexRangeDict[Key][1]\r
+ MixItem = HexRangeDict[Key][0]\r
+ \r
+ Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip())\r
+ ValidRangeExpr = ValidRangeExpr.replace(Key, Range)\r
+ #\r
+ # Do the INT1 conversion\r
+ #\r
+ IntRangeDict = {}\r
+ IntMatchList = re.compile(IntPattern1).findall(ValidRangeExpr)\r
+ for MatchedItem in IntMatchList:\r
+ #\r
+ # To match items on both sides of '-'\r
+ #\r
+ RangeItemList = re.compile('[\t\s]*\d+[\t\s]*').findall(MatchedItem)\r
+ if RangeItemList and len(RangeItemList) == 2: \r
+ IntRangeDict[MatchedItem] = RangeItemList\r
+ \r
+ for Key in IntRangeDict.keys():\r
+ MaxItem = MixItem = ''\r
+ if int(IntRangeDict[Key][0]) > int(IntRangeDict[Key][1]):\r
+ MaxItem = IntRangeDict[Key][0]\r
+ MixItem = IntRangeDict[Key][1]\r
+ else:\r
+ MaxItem = IntRangeDict[Key][1]\r
+ MixItem = IntRangeDict[Key][0]\r
+ \r
+ Range = ' %s - %s' % (MixItem.strip(), MaxItem.strip())\r
+ ValidRangeExpr = ValidRangeExpr.replace(Key, Range)\r
+ #\r
+ # Do the HEX2 conversion \r
+ #\r
+ for MatchObj in re.compile(HexPattern2).finditer(ValidRangeExpr):\r
+ MatchStr = MatchObj.group()\r
+ Range = re.compile(PCD_PATTERN).sub(' ', MatchStr)\r
+ ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range)\r
+ #\r
+ # Do the INT2 conversion\r
+ #\r
+ for MatchObj in re.compile(IntPattern2).finditer(ValidRangeExpr):\r
+ MatchStr = MatchObj.group()\r
+ Range = re.compile(PCD_PATTERN).sub(' ', MatchStr)\r
+ ValidRangeExpr = ValidRangeExpr.replace(MatchStr, Range)\r
+\r
+ return ValidRangeExpr\r
+ \r
+ \r
\r
def __str__(self):\r
return "ValidValueList = %s ValidValueListLang = %s ValidValueRange \\r
self.Value = ''\r
self.Offset = ''\r
self.CommonDefines = CommonDefinesXml()\r
+ self.Prompt = []\r
self.HelpText = []\r
self.PcdError = []\r
\r
self.Value = XmlElement(Item, '%s/Value' % Key)\r
self.Offset = XmlElement(Item, '%s/Offset' % Key)\r
self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)\r
+ \r
for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):\r
HelpTextObj = HelpTextXml()\r
HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)\r
self.DefaultValue = XmlElement(Item, '%s/DefaultValue' % Key)\r
self.MaxDatumSize = XmlElement(Item, '%s/MaxDatumSize' % Key)\r
self.CommonDefines.FromXml(XmlNode(Item, '%s' % Key), Key)\r
+ for PromptItem in XmlList(Item, '%s/Prompt' % Key):\r
+ PromptObj = PromptXml()\r
+ PromptObj.FromXml(PromptItem, '%s/Prompt' % Key)\r
+ self.Prompt.append(PromptObj)\r
for HelpTextItem in XmlList(Item, '%s/HelpText' % Key):\r
HelpTextObj = HelpTextXml()\r
HelpTextObj.FromXml(HelpTextItem, '%s/HelpText' % Key)\r
PcdEntry.SetDefaultValue(self.DefaultValue)\r
PcdEntry.SetMaxDatumSize(self.MaxDatumSize)\r
PcdEntry.SetFeatureFlag(ConvertNOTEQToNE(self.CommonDefines.FeatureFlag))\r
-\r
+ \r
+ PcdEntry.SetPromptList(GetPromptList(self.Prompt))\r
PcdEntry.SetHelpTextList(GetHelpTextList(self.HelpText))\r
PcdEntry.SetPcdErrorsList(self.PcdError)\r
\r
['DefaultValue', DefaultValue],\r
['MaxDatumSize', PcdEntry.GetMaxDatumSize()],\r
]\r
+ for Item in PcdEntry.GetPromptList():\r
+ Tmp = PromptXml()\r
+ NodeList.append(Tmp.ToXml(Item))\r
+ \r
for Item in PcdEntry.GetHelpTextList():\r
Tmp = HelpTextXml()\r
NodeList.append(Tmp.ToXml(Item))\r
Str = Str + "\n\t" + str(Item)\r
for Item in self.PcdError:\r
Str = Str + "\n\tPcdError:" + str(Item)\r
- return Str
\ No newline at end of file
+ return Str\r
## @file\r
# This file is used to parse a xml file of .PKG file\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPMODLIST\r
from Logger.StringTable import ERR_XML_INVALID_EXTERN_SUPMODLIST_NOT_LIB\r
from Logger.StringTable import ERR_FILE_NAME_INVALIDE\r
-from Logger.StringTable import ERR_XML_INVALID_BINARY_FILE_TYPE\r
from Logger.ToolError import PARSER_ERROR\r
from Logger.ToolError import FORMAT_INVALID\r
\r
DpHeader = self.DistP.Header\r
XmlTreeLevel = ['DistributionPackage', 'DistributionHeader']\r
CheckDict = Sdict()\r
+ if DpHeader.GetAbstract():\r
+ DPAbstract = DpHeader.GetAbstract()[0][1]\r
+ else:\r
+ DPAbstract = ''\r
+ if DpHeader.GetCopyright():\r
+ DPCopyright = DpHeader.GetCopyright()[0][1]\r
+ else:\r
+ DPCopyright = ''\r
+ if DpHeader.GetLicense():\r
+ DPLicense = DpHeader.GetLicense()[0][1]\r
+ else:\r
+ DPLicense = ''\r
+ \r
CheckDict['Name'] = DpHeader.GetName()\r
CheckDict['GUID'] = DpHeader.GetGuid()\r
CheckDict['Version'] = DpHeader.GetVersion()\r
- CheckDict['Copyright'] = DpHeader.GetCopyright()\r
- CheckDict['License'] = DpHeader.GetLicense()\r
- CheckDict['Abstract'] = DpHeader.GetAbstract()\r
+ CheckDict['Copyright'] = DPCopyright\r
+ CheckDict['License'] = DPLicense\r
+ CheckDict['Abstract'] = DPAbstract\r
CheckDict['Vendor'] = DpHeader.GetVendor()\r
CheckDict['Date'] = DpHeader.GetDate()\r
CheckDict['XmlSpecification'] = DpHeader.GetXmlSpecification()\r
if Item and len(Item.FileNamList) > 0 and Item.FileNamList[0].FileType == 'FREEFORM':\r
Item.FileNamList[0].FileType = 'SUBTYPE_GUID'\r
Module.GetBinaryFileList()[ItemCount] = Item\r
- if Item and len(Item.FileNamList) > 0 and Item.FileNamList[0].FileType == 'DISPOSABLE':\r
- Logger.Error('\nUPT',\r
- PARSER_ERROR,\r
- ERR_XML_INVALID_BINARY_FILE_TYPE % ('DISPOSABLE'),\r
- RaiseError=True) \r
\r
## ValidateMS3\r
#\r
for PcdExItem in AsBuilt.PcdExValueList:\r
CheckDict = {'TokenSpaceGuidValue':PcdExItem.TokenSpaceGuidValue,\r
'Token':PcdExItem.Token,\r
- 'DatumType':PcdExItem.DatumType,\r
- 'Value':PcdExItem.DefaultValue}\r
+ 'DatumType':PcdExItem.DatumType}\r
XmlTreeLevel = TopXmlTreeLevel + ['BinaryFiles', 'BinaryFile', 'AsBuilt', 'PcdExValue']\r
IsRequiredItemListNull(CheckDict, XmlTreeLevel)\r
#\r
## @file\r
# This file is used to parse a xml file of .PKG file\r
#\r
-# Copyright (c) 2011, Intel Corporation. All rights reserved.<BR>\r
+# Copyright (c) 2011 - 2014, 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
ErrorMsg = ERR_XML_PARSER_REQUIRED_ITEM_MISSING % (Key, Msg)\r
Logger.Error('\nUPT', PARSER_ERROR, ErrorMsg, RaiseError=True)\r
\r
- \r
## Get help text \r
#\r
# @param HelpText\r
HelpTextObj.SetString(HelT.HelpText)\r
HelpTextList.append(HelpTextObj)\r
return HelpTextList\r
+ \r
+## Get Prompt text \r
+#\r
+# @param Prompt\r
+#\r
+def GetPromptList(Prompt):\r
+ PromptList = []\r
+ for SubPrompt in Prompt:\r
+ PromptObj = TextObject()\r
+ PromptObj.SetLang(SubPrompt.Lang)\r
+ PromptObj.SetString(SubPrompt.Prompt)\r
+ PromptList.append(PromptObj)\r
+ return PromptList\r
projects / mirror_edk2.git / commitdiff