audk/BaseTools/Source/Python/Common/DecClassObjectLight.py

## @file
# This file is used to define each component of DEC file in light mode
#
# Copyright (c) 2008, Intel Corporation. All rights reserved.<BR>
# This program and the accompanying materials
# are licensed and made available under the terms and conditions of the BSD License
# which accompanies this distribution.  The full text of the license may be found at
# http://opensource.org/licenses/bsd-license.php
#
# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
#

##
# Import Modules
#
import os
from Misc import GetFiles
from String import *
from DataType import *
from CommonDataClass.PackageClass import *
from CommonDataClass import CommonClass
from BuildToolError import *
from Parsing import *

# Global variable
Section = {TAB_UNKNOWN.upper() : MODEL_UNKNOWN,
           TAB_DEC_DEFINES.upper() : MODEL_META_DATA_HEADER,
           TAB_INCLUDES.upper() : MODEL_EFI_INCLUDE,
           TAB_LIBRARY_CLASSES.upper() : MODEL_EFI_LIBRARY_CLASS,
           TAB_COMPONENTS.upper() : MODEL_META_DATA_COMPONENT,
           TAB_GUIDS.upper() : MODEL_EFI_GUID,
           TAB_PROTOCOLS.upper() : MODEL_EFI_PROTOCOL,
           TAB_PPIS.upper() : MODEL_EFI_PPI,
           TAB_PCDS_FIXED_AT_BUILD_NULL.upper() : MODEL_PCD_FIXED_AT_BUILD,
           TAB_PCDS_PATCHABLE_IN_MODULE_NULL.upper() : MODEL_PCD_PATCHABLE_IN_MODULE,
           TAB_PCDS_FEATURE_FLAG_NULL.upper() : MODEL_PCD_FEATURE_FLAG,
           TAB_PCDS_DYNAMIC_EX_NULL.upper() : MODEL_PCD_DYNAMIC_EX,
           TAB_PCDS_DYNAMIC_NULL.upper() : MODEL_PCD_DYNAMIC,
           TAB_USER_EXTENSIONS.upper() : MODEL_META_DATA_USER_EXTENSION
           }

## DecObject
#
# This class defined basic Dec object which is used by inheriting
# 
# @param object:       Inherited from object class
#
class DecObject(object):
    def __init__(self):
        object.__init__()

## Dec
#
# This class defined the structure used in Dec object
# 
# @param DecObject:         Inherited from DecObject class
# @param Filename:          Input value for Filename of Dec file, default is None
# @param IsMergeAllArches:  Input value for IsMergeAllArches
#                           True is to merge all arches
#                           Fales is not to merge all arches
#                           default is False
# @param IsToPackage:       Input value for IsToPackage
#                           True is to transfer to PackageObject automatically
#                           False is not to transfer to PackageObject automatically
#                           default is False
# @param WorkspaceDir:      Input value for current workspace directory, default is None
#
# @var Identification:      To store value for Identification, it is a structure as Identification
# @var Defines:             To store value for Defines, it is a structure as DecDefines
# @var UserExtensions:      To store value for UserExtensions
# @var Package:             To store value for Package, it is a structure as PackageClass
# @var WorkspaceDir:        To store value for WorkspaceDir
# @var Contents:            To store value for Contents, it is a structure as DecContents
# @var KeyList:             To store value for KeyList, a list for all Keys used in Dec
#
class Dec(DecObject):
    def __init__(self, Filename = None, IsToPackage = False, WorkspaceDir = None, AllGuidVersionDict = None, SupArchList = DataType.ARCH_LIST):
        self.Identification = IdentificationClass()
        self.Package = PackageClass()
        self.UserExtensions = ''
        self.WorkspaceDir = WorkspaceDir
        self.SupArchList = SupArchList
        self.AllGuidVersionDict = {}
        if AllGuidVersionDict:
            self.AllGuidVersionDict = AllGuidVersionDict

        self.KeyList = [
            TAB_INCLUDES, TAB_GUIDS, TAB_PROTOCOLS, TAB_PPIS, TAB_LIBRARY_CLASSES, \
            TAB_PCDS_FIXED_AT_BUILD_NULL, TAB_PCDS_PATCHABLE_IN_MODULE_NULL, TAB_PCDS_FEATURE_FLAG_NULL, \
            TAB_PCDS_DYNAMIC_NULL, TAB_PCDS_DYNAMIC_EX_NULL, TAB_DEC_DEFINES
        ]
        # Upper all KEYs to ignore case sensitive when parsing
        self.KeyList = map(lambda c: c.upper(), self.KeyList)
        
        # Init RecordSet
        self.RecordSet = {}        
        for Key in self.KeyList:
            self.RecordSet[Section[Key]] = []
        
        # Init Comment
        self.SectionHeaderCommentDict = {}
        
        # Load Dec file if filename is not None
        if Filename != None:
            self.LoadDecFile(Filename)
        
        # Transfer to Package Object if IsToPackage is True
        if IsToPackage:
            self.DecToPackage()
    
    ## Load Dec file
    #
    # Load the file if it exists
    #
    # @param Filename:  Input value for filename of Dec file
    #
    def LoadDecFile(self, Filename):
        # Insert a record for file
        Filename = NormPath(Filename)
        self.Identification.FullPath = Filename
        (self.Identification.RelaPath, self.Identification.FileName) = os.path.split(Filename)
        if self.Identification.FullPath.find(self.WorkspaceDir) > -1:
            self.Identification.PackagePath = os.path.dirname(self.Identification.FullPath[len(self.WorkspaceDir) + 1:])        
       
        # Init common datas
        IfDefList, SectionItemList, CurrentSection, ArchList, ThirdList, IncludeFiles = \
        [], [], TAB_UNKNOWN, [], [], []
        LineNo = 0
        
        # Parse file content
        IsFindBlockComment = False
        ReservedLine = ''
        Comment = ''
        for Line in open(Filename, 'r'):
            LineNo = LineNo + 1
            # Remove comment block
            if Line.find(TAB_COMMENT_R8_START) > -1:
                ReservedLine = GetSplitValueList(Line, TAB_COMMENT_R8_START, 1)[0]
                if ReservedLine.strip().startswith(TAB_COMMENT_SPLIT):
                    Comment = Comment + Line.strip() + '\n'
                    ReservedLine = ''
                else:
                    Comment = Comment + Line[len(ReservedLine):] + '\n'
                IsFindBlockComment = True
                if not ReservedLine:
                    continue
            if Line.find(TAB_COMMENT_R8_END) > -1:
                Comment = Comment + Line[:Line.find(TAB_COMMENT_R8_END) + len(TAB_COMMENT_R8_END)] + '\n'
                Line = ReservedLine + GetSplitValueList(Line, TAB_COMMENT_R8_END, 1)[1]
                ReservedLine = ''
                IsFindBlockComment = False
            if IsFindBlockComment:
                Comment = Comment + Line.strip() + '\n'
                continue

            # Remove comments at tail and remove spaces again
            if Line.strip().startswith(TAB_COMMENT_SPLIT) or Line.strip().startswith('--/'):
                Comment = Comment + Line.strip() + '\n'
            Line = CleanString(Line)
            if Line == '':
                continue
            
            ## Find a new section tab
            # First insert previous section items
            # And then parse the content of the new section
            #
            if Line.startswith(TAB_SECTION_START) and Line.endswith(TAB_SECTION_END):
                # Insert items data of previous section
                Model = Section[CurrentSection.upper()]
                InsertSectionItems(Model, CurrentSection, SectionItemList, ArchList, ThirdList, self.RecordSet)
                # Parse the new section
                SectionItemList = []
                ArchList = []
                ThirdList = []
                
                CurrentSection = ''
                LineList = GetSplitValueList(Line[len(TAB_SECTION_START):len(Line) - len(TAB_SECTION_END)], TAB_COMMA_SPLIT)
                for Item in LineList:
                    ItemList = GetSplitValueList(Item, TAB_SPLIT)
                    if CurrentSection == '':
                        CurrentSection = ItemList[0]
                    else:
                        if CurrentSection != ItemList[0]:
                            EdkLogger.error("Parser", PARSER_ERROR, "Different section names '%s' and '%s' are found in one section definition, this is not allowed." % (CurrentSection, ItemList[0]), File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError)
                    if CurrentSection.upper() not in self.KeyList:
                        RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
                    ItemList.append('')
                    ItemList.append('')
                    if len(ItemList) > 5:
                        RaiseParserError(Line, CurrentSection, Filename, '', LineNo)
                    else:
                        if ItemList[1] != '' and ItemList[1].upper() not in ARCH_LIST_FULL:
                            EdkLogger.error("Parser", PARSER_ERROR, "Invalid Arch definition '%s' found" % ItemList[1], File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError)
                        ArchList.append(ItemList[1].upper())
                        ThirdList.append(ItemList[2])
                
                if Comment:
                    if Comment.endswith('\n'):
                        Comment = Comment[:len(Comment) - len('\n')]
                    self.SectionHeaderCommentDict[Section[CurrentSection.upper()]] = Comment
                    Comment = ''
                continue
            
            # Not in any defined section
            if CurrentSection == TAB_UNKNOWN:
                ErrorMsg = "%s is not in any defined section" % Line
                EdkLogger.error("Parser", PARSER_ERROR, ErrorMsg, File=Filename, Line=LineNo, RaiseError = EdkLogger.IsRaiseError)

            # Add a section item
            SectionItemList.append([Line, LineNo, Comment])
            Comment = ''
            # End of parse
        #End of For
        
        #
        # Insert items data of last section
        #
        Model = Section[CurrentSection.upper()]
        InsertSectionItems(Model, CurrentSection, SectionItemList, ArchList, ThirdList, self.RecordSet)
        if Comment != '':
            self.SectionHeaderCommentDict[Model] = Comment
            Comment = ''

    ## Package Object to DEC file
    def PackageToDec(self, Package):
        Dec = ''
        DecList = sdict()
        SectionHeaderCommentDict = {}
        if Package == None:
            return Dec
        
        PackageHeader = Package.PackageHeader
        TmpList = []
        if PackageHeader.Name:
            TmpList.append(TAB_DEC_DEFINES_PACKAGE_NAME + ' = ' + PackageHeader.Name)
        if PackageHeader.Guid:
            TmpList.append(TAB_DEC_DEFINES_PACKAGE_GUID + ' = ' + PackageHeader.Guid)
        if PackageHeader.Version:
            TmpList.append(TAB_DEC_DEFINES_PACKAGE_VERSION + ' = ' + PackageHeader.Version)
        if PackageHeader.DecSpecification:
            TmpList.append(TAB_DEC_DEFINES_DEC_SPECIFICATION + ' = ' + PackageHeader.DecSpecification)
        if Package.UserExtensions != None:
            for Item in Package.UserExtensions.Defines:
                TmpList.append(Item)
        DecList['Defines'] =TmpList
        if PackageHeader.Description != '':
            SectionHeaderCommentDict['Defines'] = PackageHeader.Description
        
        for Item in Package.Includes:
            Key = 'Includes.' + Item.SupArchList
            Value = Item.FilePath
            GenMetaDatSectionItem(Key, Value, DecList)
        
        for Item in Package.GuidDeclarations:
            Key = 'Guids.' + Item.SupArchList
            Value = Item.CName + '=' + Item.Guid
            GenMetaDatSectionItem(Key, Value, DecList)
        
        for Item in Package.ProtocolDeclarations:
            Key = 'Protocols.' + Item.SupArchList
            Value = Item.CName + '=' + Item.Guid
            GenMetaDatSectionItem(Key, Value, DecList)
        
        for Item in Package.PpiDeclarations:
            Key = 'Ppis.' + Item.SupArchList
            Value = Item.CName + '=' + Item.Guid
            GenMetaDatSectionItem(Key, Value, DecList)
        
        for Item in Package.LibraryClassDeclarations:
            Key = 'LibraryClasses.' + Item.SupArchList
            Value = Item.LibraryClass + '|' + Item.RecommendedInstance
            GenMetaDatSectionItem(Key, Value, DecList)

        for Item in Package.PcdDeclarations:
            Key = 'Pcds' + Item.ItemType + '.' + Item.SupArchList
            Value = Item.TokenSpaceGuidCName + '.' + Item.CName
            if Item.DefaultValue != '':
                Value = Value + '|' + Item.DefaultValue
            if Item.DatumType != '':
                Value = Value + '|' + Item.DatumType
            if Item.Token != '':
                Value = Value + '|' + Item.Token
            GenMetaDatSectionItem(Key, Value, DecList)

        # Transfer Package to Inf
        for Key in DecList:
            if Key in SectionHeaderCommentDict:
                List = SectionHeaderCommentDict[Key].split('\r')
                for Item in List:
                    Dec = Dec + Item + '\n'
            Dec = Dec + '[' + Key + ']' + '\n'
            for Value in DecList[Key]:
                if type(Value) == type([]):
                    for SubValue in Value:
                        Dec = Dec + '  ' + SubValue + '\n'
                else:
                    Dec = Dec + '  ' + Value + '\n'
            Dec = Dec + '\n'
        
        return Dec

    ## Transfer to Package Object
    # 
    # Transfer all contents of a Dec file to a standard Package Object
    #
    def DecToPackage(self):
        # Init global information for the file
        ContainerFile = self.Identification.FullPath
        
        # Generate Package Header
        self.GenPackageHeader(ContainerFile)
        
        # Generate Includes
        # Only for R8
        self.GenIncludes(ContainerFile)

        # Generate Guids
        self.GenGuidProtocolPpis(DataType.TAB_GUIDS, ContainerFile)

        # Generate Protocols
        self.GenGuidProtocolPpis(DataType.TAB_PROTOCOLS, ContainerFile)

        # Generate Ppis
        self.GenGuidProtocolPpis(DataType.TAB_PPIS, ContainerFile)
        
        # Generate LibraryClasses
        self.GenLibraryClasses(ContainerFile)
        
        # Generate Pcds
        self.GenPcds(ContainerFile)
        
        # Init MiscFiles
        self.GenMiscFiles(ContainerFile)
    
    ## GenMiscFiles
    #
    def GenMiscFiles(self, ContainerFile):
        MiscFiles = MiscFileClass()
        MiscFiles.Name = 'ModuleFiles'
        for Item in GetFiles(os.path.dirname(ContainerFile), ['CVS', '.svn'], False):
            File = CommonClass.FileClass()
            File.Filename = Item
            MiscFiles.Files.append(File)
        self.Package.MiscFiles = MiscFiles
    
    ## Get Package Header
    #
    # Gen Package Header of Dec as <Key> = <Value>
    #
    # @param ContainerFile: The Dec file full path 
    #
    def GenPackageHeader(self, ContainerFile):
        EdkLogger.debug(2, "Generate PackageHeader ...")
        #
        # Update all defines item in database
        #
        RecordSet = self.RecordSet[MODEL_META_DATA_HEADER]
        PackageHeader = PackageHeaderClass()
        OtherDefines = []
        for Record in RecordSet:
            ValueList = GetSplitValueList(Record[0], TAB_EQUAL_SPLIT)
            if len(ValueList) != 2:
                OtherDefines.append(Record[0])
            else:
                Name = ValueList[0]
                Value = ValueList[1]
                if Name == TAB_DEC_DEFINES_PACKAGE_NAME:
                    PackageHeader.Name = Value
                elif Name == TAB_DEC_DEFINES_PACKAGE_GUID:
                    PackageHeader.Guid = Value
                elif Name == TAB_DEC_DEFINES_PACKAGE_VERSION:
                    PackageHeader.Version = Value
                elif Name == TAB_DEC_DEFINES_DEC_SPECIFICATION:
                    PackageHeader.DecSpecification = Value
                else:
                    OtherDefines.append(Record[0])
            
        PackageHeader.FileName = self.Identification.FileName
        PackageHeader.FullPath = self.Identification.FullPath
        PackageHeader.RelaPath = self.Identification.RelaPath
        PackageHeader.PackagePath = self.Identification.PackagePath
        PackageHeader.ModulePath = self.Identification.ModulePath
        PackageHeader.CombinePath = os.path.normpath(os.path.join(PackageHeader.PackagePath, PackageHeader.ModulePath, PackageHeader.FileName))
        
        if MODEL_META_DATA_HEADER in self.SectionHeaderCommentDict:
            PackageHeader.Description = self.SectionHeaderCommentDict[MODEL_META_DATA_HEADER]
        
        self.Package.PackageHeader = PackageHeader
        UE = UserExtensionsClass()
        UE.Defines = OtherDefines
        self.Package.UserExtensions = UE
        
    
    ## GenIncludes
    #
    # Gen Includes of Dec
    # 
    # @param ContainerFile: The Dec file full path 
    #
    def GenIncludes(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_INCLUDES)
        Includes = {}
        # Get all Includes
        RecordSet = self.RecordSet[MODEL_EFI_INCLUDE]
        
        # Go through each arch
        for Record in RecordSet:
            Arch = Record[1]
            Key = Record[0]
            Include = IncludeClass()
            Include.FilePath = NormPath(Key)
            Include.SupArchList = Arch
            self.Package.Includes.append(Include)
    
    ## GenPpis
    #
    # Gen Ppis of Dec
    # <CName>=<GuidValue>
    #
    # @param ContainerFile: The Dec file full path 
    #
    def GenGuidProtocolPpis(self, Type, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % Type)
        Lists = {}
        # Get all Items
        RecordSet = self.RecordSet[Section[Type.upper()]]
        
        # Go through each arch
        for Record in RecordSet:
            Arch = Record[1]
            (Name, Value) = GetGuidsProtocolsPpisOfDec(Record[0], Type, ContainerFile, Record[2])
       
            ListMember = None
            if Type == TAB_GUIDS:
                ListMember = self.Package.GuidDeclarations
            elif Type == TAB_PROTOCOLS:
                ListMember = self.Package.ProtocolDeclarations
            elif Type == TAB_PPIS:
                ListMember = self.Package.PpiDeclarations
        
            ListClass = GuidProtocolPpiCommonClass()
            ListClass.CName = Name
            ListClass.Guid = Value
            ListClass.SupArchList = Arch
            ListMember.append(ListClass)
    
    ## GenLibraryClasses
    #
    # Gen LibraryClasses of Dec
    # <CName>=<GuidValue>
    #
    # @param ContainerFile: The Dec file full path 
    #
    def GenLibraryClasses(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_LIBRARY_CLASSES)
        LibraryClasses = {}
        # Get all Guids
        RecordSet = self.RecordSet[MODEL_EFI_LIBRARY_CLASS]
        
        # Go through each arch
        for Record in RecordSet:
            Arch = Record[1]
            List = GetSplitValueList(Record[0], DataType.TAB_VALUE_SPLIT)
            if len(List) != 2:
                continue
            LibraryClass = LibraryClassClass()
            LibraryClass.LibraryClass = List[0]
            LibraryClass.RecommendedInstance = NormPath(List[1])
            LibraryClass.SupArchList = Arch
            self.Package.LibraryClassDeclarations.append(LibraryClass)
    
    def AddPcd(self, CName, Token, TokenSpaceGuidCName, DatumType, DefaultValue, ItemType, Arch):
        Pcd = CommonClass.PcdClass()
        Pcd.CName = CName
        Pcd.Token = Token
        Pcd.TokenSpaceGuidCName = TokenSpaceGuidCName
        Pcd.DatumType = DatumType
        Pcd.DefaultValue = DefaultValue
        Pcd.ItemType = ItemType
        Pcd.SupArchList = Arch
        self.Package.PcdDeclarations.append(Pcd)
    
    ## GenPcds
    #
    # Gen Pcds of Dec
    # <TokenSpcCName>.<TokenCName>|<Value>|<DatumType>|<Token>
    #
    # @param ContainerFile: The Dec file full path 
    #
    def GenPcds(self, ContainerFile):
        EdkLogger.debug(2, "Generate %s ..." % TAB_PCDS)
        Pcds = {}
        PcdToken = {}
        # Get all Pcds
        RecordSet1 = self.RecordSet[MODEL_PCD_FIXED_AT_BUILD]
        RecordSet2 = self.RecordSet[MODEL_PCD_PATCHABLE_IN_MODULE]
        RecordSet3 = self.RecordSet[MODEL_PCD_FEATURE_FLAG]
        RecordSet4 = self.RecordSet[MODEL_PCD_DYNAMIC_EX]
        RecordSet5 = self.RecordSet[MODEL_PCD_DYNAMIC]
        
        # Go through each pcd
        for Record in RecordSet1:
            Arch = Record[1]
            (TokenGuidCName, TokenName, DefaultValue, DatumType, Token, ItemType) = GetPcdOfDec(Record[0], TAB_PCDS_FIXED_AT_BUILD, ContainerFile, Record[2])
            self.AddPcd(TokenName, Token, TokenGuidCName, DatumType, DefaultValue, ItemType, Arch)
        for Record in RecordSet2:
            Arch = Record[1]
            (TokenGuidCName, TokenName, DefaultValue, DatumType, Token, ItemType) = GetPcdOfDec(Record[0], TAB_PCDS_PATCHABLE_IN_MODULE, ContainerFile, Record[2])
            self.AddPcd(TokenName, Token, TokenGuidCName, DatumType, DefaultValue, ItemType, Arch)
        for Record in RecordSet3:
            Arch = Record[1]
            (TokenGuidCName, TokenName, DefaultValue, DatumType, Token, ItemType) = GetPcdOfDec(Record[0], TAB_PCDS_FEATURE_FLAG, ContainerFile, Record[2])
            self.AddPcd(TokenName, Token, TokenGuidCName, DatumType, DefaultValue, ItemType, Arch)
        for Record in RecordSet4:
            Arch = Record[1]
            (TokenGuidCName, TokenName, DefaultValue, DatumType, Token, ItemType) = GetPcdOfDec(Record[0], TAB_PCDS_DYNAMIC_EX, ContainerFile, Record[2])
            self.AddPcd(TokenName, Token, TokenGuidCName, DatumType, DefaultValue, ItemType, Arch)
        for Record in RecordSet5:
            Arch = Record[1]
            (TokenGuidCName, TokenName, DefaultValue, DatumType, Token, ItemType) = GetPcdOfDec(Record[0], TAB_PCDS_DYNAMIC, ContainerFile, Record[2])
            self.AddPcd(TokenName, Token, TokenGuidCName, DatumType, DefaultValue, ItemType, Arch)
            
    ## Show detailed information of Package
    #
    # Print all members and their values of Package class
    #
    def ShowPackage(self):
        M = self.Package
        print 'Filename =', M.PackageHeader.FileName
        print 'FullPath =', M.PackageHeader.FullPath
        print 'RelaPath =', M.PackageHeader.RelaPath
        print 'PackagePath =', M.PackageHeader.PackagePath
        print 'ModulePath =', M.PackageHeader.ModulePath
        print 'CombinePath =', M.PackageHeader.CombinePath
        
        print 'BaseName =', M.PackageHeader.Name
        print 'Guid =', M.PackageHeader.Guid
        print 'Version =', M.PackageHeader.Version
        print 'DecSpecification =', M.PackageHeader.DecSpecification

        print '\nIncludes ='#, M.Includes
        for Item in M.Includes:
            print Item.FilePath, Item.SupArchList
        print '\nGuids ='#, M.GuidDeclarations
        for Item in M.GuidDeclarations:
            print Item.CName, Item.Guid, Item.SupArchList
        print '\nProtocols ='#, M.ProtocolDeclarations
        for Item in M.ProtocolDeclarations:
            print Item.CName, Item.Guid, Item.SupArchList
        print '\nPpis ='#, M.PpiDeclarations
        for Item in M.PpiDeclarations:
            print Item.CName, Item.Guid, Item.SupArchList
        print '\nLibraryClasses ='#, M.LibraryClassDeclarations
        for Item in M.LibraryClassDeclarations:
            print Item.LibraryClass, Item.RecommendedInstance, Item.SupModuleList, Item.SupArchList
        print '\nPcds ='#, M.PcdDeclarations
        for Item in M.PcdDeclarations:
            print 'CName=', Item.CName, 'TokenSpaceGuidCName=', Item.TokenSpaceGuidCName, 'DefaultValue=', Item.DefaultValue, 'ItemType=', Item.ItemType, 'Token=', Item.Token, 'DatumType=', Item.DatumType, Item.SupArchList
        print '\nUserExtensions =', M.UserExtensions.Defines
        print '\n*** FileList ***'
        for Item in M.MiscFiles.Files:
            print Item.Filename
        print '****************\n'

##
#
# This acts like the main() function for the script, unless it is 'import'ed into another
# script.
#
if __name__ == '__main__':
    EdkLogger.Initialize()
    EdkLogger.SetLevel(EdkLogger.QUIET)
    
    W = os.getenv('WORKSPACE')
    F = os.path.join(W, 'MdeModulePkg/MdeModulePkg.dec')

    P = Dec(os.path.normpath(F), True, W)
    P.ShowPackage()
    print P.PackageToDec(P.Package)