Source/Python/AutoGen/AutoGen.py

   1 ## @file
   2 # Generate AutoGen.h, AutoGen.c and *.depex files
   3 #
   4 # Copyright (c) 2007 - 2009, Intel Corporation
   5 # All rights reserved. This program and the accompanying materials
   6 # are licensed and made available under the terms and conditions of the BSD License
   7 # which accompanies this distribution.  The full text of the license may be found at
   8 # http://opensource.org/licenses/bsd-license.php
   9 #
  10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 #
  13
  14 ## Import Modules
  15 #
  16 import os
  17 import re
  18 import os.path as path
  19 import copy
  20
  21 import GenC
  22 import GenMake
  23 import GenDepex
  24 from StringIO import StringIO
  25
  26 from StrGather import *
  27 from BuildEngine import BuildRule
  28
  29 from Common.BuildToolError import *
  30 from Common.DataType import *
  31 from Common.Misc import *
  32 from Common.String import *
  33 import Common.GlobalData as GlobalData
  34 from GenFds.FdfParser import *
  35 from CommonDataClass.CommonClass import SkuInfoClass
  36 from Workspace.BuildClassObject import *
  37
  38 ## Regular expression for splitting Dependency Expression stirng into tokens
  39 gDepexTokenPattern = re.compile("(\(|\)|\w+| \S+\.inf)")
  40
  41 ## Mapping Makefile type
  42 gMakeTypeMap = {"MSFT":"nmake", "GCC":"gmake"}
  43
  44
  45 ## Build rule configuration file
  46 gBuildRuleFile = 'Conf/build_rule.txt'
  47
  48 ## default file name for AutoGen
  49 gAutoGenCodeFileName = "AutoGen.c"
  50 gAutoGenHeaderFileName = "AutoGen.h"
  51 gAutoGenStringFileName = "%(module_name)sStrDefs.h"
  52 gAutoGenStringFormFileName = "%(module_name)sStrDefs.hpk"
  53 gAutoGenDepexFileName = "%(module_name)s.depex"
  54
  55 ## Base class for AutoGen
  56 #
  57 #   This class just implements the cache mechanism of AutoGen objects.
  58 #
  59 class AutoGen(object):
  60     # database to maintain the objects of xxxAutoGen
  61     _CACHE_ = {}    # (BuildTarget, ToolChain) : {ARCH : {platform file: AutoGen object}}}
  62
  63     ## Factory method
  64     #
  65     #   @param  Class           class object of real AutoGen class
  66     #                           (WorkspaceAutoGen, ModuleAutoGen or PlatformAutoGen)
  67     #   @param  Workspace       Workspace directory or WorkspaceAutoGen object
  68     #   @param  MetaFile        The path of meta file
  69     #   @param  Target          Build target
  70     #   @param  Toolchain       Tool chain name
  71     #   @param  Arch            Target arch
  72     #   @param  *args           The specific class related parameters
  73     #   @param  **kwargs        The specific class related dict parameters
  74     #
  75     def __new__(Class, Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
  76         # check if the object has been created
  77         Key = (Target, Toolchain)
  78         if Key not in Class._CACHE_ or Arch not in Class._CACHE_[Key] \
  79            or MetaFile not in Class._CACHE_[Key][Arch]:
  80             AutoGenObject = super(AutoGen, Class).__new__(Class)
  81             # call real constructor
  82             if not AutoGenObject._Init(Workspace, MetaFile, Target, Toolchain, Arch, *args, **kwargs):
  83                 return None
  84             if Key not in Class._CACHE_:
  85                 Class._CACHE_[Key] = {}
  86             if Arch not in Class._CACHE_[Key]:
  87                 Class._CACHE_[Key][Arch] = {}
  88             Class._CACHE_[Key][Arch][MetaFile] = AutoGenObject
  89         else:
  90             AutoGenObject = Class._CACHE_[Key][Arch][MetaFile]
  91
  92         return AutoGenObject
  93
  94     ## hash() operator
  95     #
  96     #  The file path of platform file will be used to represent hash value of this object
  97     #
  98     #   @retval int     Hash value of the file path of platform file
  99     #
 100     def __hash__(self):
 101         return hash(self.MetaFile)
 102
 103     ## str() operator
 104     #
 105     #  The file path of platform file will be used to represent this object
 106     #
 107     #   @retval string  String of platform file path
 108     #
 109     def __str__(self):
 110         return str(self.MetaFile)
 111
 112     ## "==" operator
 113     def __eq__(self, Other):
 114         return Other and self.MetaFile == Other
 115
 116 ## Workspace AutoGen class
 117 #
 118 #   This class is used mainly to control the whole platform build for different
 119 # architecture. This class will generate top level makefile.
 120 #
 121 class WorkspaceAutoGen(AutoGen):
 122     ## Real constructor of WorkspaceAutoGen
 123     #
 124     # This method behaves the same as __init__ except that it needs explict invoke
 125     # (in super class's __new__ method)
 126     #
 127     #   @param  WorkspaceDir            Root directory of workspace
 128     #   @param  ActivePlatform          Meta-file of active platform
 129     #   @param  Target                  Build target
 130     #   @param  Toolchain               Tool chain name
 131     #   @param  ArchList                List of architecture of current build
 132     #   @param  MetaFileDb              Database containing meta-files
 133     #   @param  BuildConfig             Configuration of build
 134     #   @param  ToolDefinition          Tool chain definitions
 135     #   @param  FlashDefinitionFile     File of flash definition
 136     #   @param  Fds                     FD list to be generated
 137     #   @param  Fvs                     FV list to be generated
 138     #   @param  SkuId                   SKU id from command line
 139     #
 140     def _Init(self, WorkspaceDir, ActivePlatform, Target, Toolchain, ArchList, MetaFileDb,
 141               BuildConfig, ToolDefinition, FlashDefinitionFile='', Fds=[], Fvs=[], SkuId='',
 142               ReportFile=None, ReportType=None):
 143         self.MetaFile       = ActivePlatform.MetaFile
 144         self.WorkspaceDir   = WorkspaceDir
 145         self.Platform       = ActivePlatform
 146         self.BuildTarget    = Target
 147         self.ToolChain      = Toolchain
 148         self.ArchList       = ArchList
 149         self.SkuId          = SkuId
 150         self.ReportFile     = ReportFile
 151         self.ReportType     = ReportType
 152
 153         self.BuildDatabase  = MetaFileDb
 154         self.TargetTxt      = BuildConfig
 155         self.ToolDef        = ToolDefinition
 156         self.FdfFile        = FlashDefinitionFile
 157         self.FdTargetList   = Fds
 158         self.FvTargetList   = Fvs
 159         self.AutoGenObjectList = []
 160
 161         # there's many relative directory operations, so ...
 162         os.chdir(self.WorkspaceDir)
 163
 164         # parse FDF file to get PCDs in it, if any
 165         if self.FdfFile != None and self.FdfFile != '':
 166             Fdf = FdfParser(self.FdfFile.Path)
 167             Fdf.ParseFile()
 168             PcdSet = Fdf.Profile.PcdDict
 169             ModuleList = Fdf.Profile.InfList
 170         else:
 171             PcdSet = {}
 172             ModuleList = []
 173
 174         # apply SKU and inject PCDs from Flash Definition file
 175         for Arch in self.ArchList:
 176             Platform = self.BuildDatabase[self.MetaFile, Arch]
 177             Platform.SkuName = self.SkuId
 178             for Name, Guid in PcdSet:
 179                 Platform.AddPcd(Name, Guid, PcdSet[Name, Guid])
 180
 181             Pa = PlatformAutoGen(self, self.MetaFile, Target, Toolchain, Arch)
 182             #
 183             # Explicitly collect platform's dynamic PCDs
 184             #
 185             Pa.CollectPlatformDynamicPcds()
 186             self.AutoGenObjectList.append(Pa)
 187
 188         AllPcds = {}
 189         MaxLen = 0
 190         for Pcd in Pa._DynaPcdList_ + Pa._NonDynaPcdList_:
 191           if Pcd.TokenSpaceGuidCName not in AllPcds:
 192             AllPcds[Pcd.TokenSpaceGuidCName] = {}
 193           if Pcd.Type not in AllPcds[Pcd.TokenSpaceGuidCName]:
 194             AllPcds[Pcd.TokenSpaceGuidCName][Pcd.Type] = []
 195           AllPcds[Pcd.TokenSpaceGuidCName][Pcd.Type] += [Pcd]
 196           if len(Pcd.TokenCName) > MaxLen:
 197             MaxLen = len(Pcd.TokenCName)
 198
 199         if self.ReportFile <> None:
 200           try:
 201             if os.path.exists(self.ReportFile):
 202               os.remove(self.ReportFile)
 203
 204             Fd = open(self.ReportFile, "w")
 205
 206             Fd.write ('===============================================================================\n')
 207             Fd.write ('Platform Configuration Database Report\n')
 208             Fd.write ('===============================================================================\n')
 209             Fd.write ('  *P  - Platform scoped PCD override in DSC file\n')
 210             Fd.write ('  *F  - Platform scoped PCD override in FDF file\n')
 211             Fd.write ('  *M  - Module scoped PCD override in DSC file\n')
 212             Fd.write ('  *C  - Library has a constructor\n')
 213             Fd.write ('  *D  - Library has a destructor\n')
 214             Fd.write ('  *CD - Library has both a constructor and a destructor\n')
 215             Fd.write ('===============================================================================\n')
 216             Fd.write ('\n')
 217             Fd.write ('===============================================================================\n')
 218             Fd.write ('PLATFORM: %s\n' % (ActivePlatform.MetaFile))
 219             Fd.write ('===============================================================================\n')
 220             for Key in AllPcds:
 221               Fd.write ('%s\n' % (Key))
 222               for Type in AllPcds[Key]:
 223                 TypeName = ''
 224                 DecType = Type
 225                 if Type == 'FixedAtBuild':
 226                   TypeName = 'FIXED'
 227                 if Type == 'PatchableInModule':
 228                   TypeName = 'PATCH'
 229                 if Type == 'FeatureFlag':
 230                   TypeName = 'FLAG'
 231                 if Type == 'Dynamic':
 232                   TypeName = 'DYN'
 233                 if Type == 'DynamicHii':
 234                   TypeName = 'DYNHII'
 235                   DecType = 'Dynamic'
 236                 if Type == 'DynamicVpd':
 237                   TypeName = 'DYNVPD'
 238                   DecType = 'Dynamic'
 239                 if Type == 'DynamicEx':
 240                   TypeName = 'DEX'
 241                   DecType = 'Dynamic'
 242                 if Type == 'DynamicExHii':
 243                   TypeName = 'DEXHII'
 244                   DecType = 'Dynamic'
 245                 if Type == 'DynamicExVpd':
 246                   TypeName = 'DEXVPD'
 247                   DecType = 'Dynamic'
 248                 for Pcd in AllPcds[Key][Type]:
 249
 250                   DecDefaultValue = None
 251                   for F in Pa.Platform.Modules.keys():
 252                     for Package in Pa.Platform.Modules[F].M.Module.Packages:
 253                       if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType) in Package.Pcds:
 254                         if DecDefaultValue == None:
 255                           DecDefaultValue = Package.Pcds[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType].DefaultValue
 256
 257                   DscDefaultValue = None
 258                   if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds:
 259                     DscDefaultValue = self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)].DefaultValue
 260
 261                   if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
 262                     if Pcd.DefaultValue.strip()[0:2].upper() == '0X':
 263                       PcdDefaultValueNumber = int(Pcd.DefaultValue.strip(), 16)
 264                     else:
 265                       PcdDefaultValueNumber = int(Pcd.DefaultValue.strip())
 266
 267                     if DecDefaultValue == None:
 268                       DecMatch = True
 269                     else:
 270                       if DecDefaultValue.strip()[0:2].upper() == '0X':
 271                         DecDefaultValueNumber = int(DecDefaultValue.strip(), 16)
 272                       else:
 273                         DecDefaultValueNumber = int(DecDefaultValue.strip())
 274                       DecMatch = (DecDefaultValueNumber == PcdDefaultValueNumber)
 275
 276                     if DscDefaultValue == None:
 277                       DscMatch = True
 278                     else:
 279                       if DscDefaultValue.strip()[0:2].upper() == '0X':
 280                         DscDefaultValueNumber = int(DscDefaultValue.strip(), 16)
 281                       else:
 282                         DscDefaultValueNumber = int(DscDefaultValue.strip())
 283                       DscMatch = (DscDefaultValueNumber == PcdDefaultValueNumber)
 284                   else:
 285                     if DecDefaultValue == None:
 286                       DecMatch = True
 287                     else:
 288                       DecMatch = (DecDefaultValue == Pcd.DefaultValue)
 289
 290                     if DscDefaultValue == None:
 291                       DscMatch = True
 292                     else:
 293                       DscMatch = (DscDefaultValue == Pcd.DefaultValue)
 294
 295                   if DecMatch:
 296                     Fd.write ('    %-*s: %6s %10s = %-22s\n' % (MaxLen + 2, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', Pcd.DefaultValue))
 297                   else:
 298                     if DscMatch:
 299                       if (Pcd.TokenCName, Key) in PcdSet:
 300                         Fd.write (' *F %-*s: %6s %10s = %-22s\n' % (MaxLen + 2, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', Pcd.DefaultValue))
 301                       else:
 302                         Fd.write (' *P %-*s: %6s %10s = %-22s\n' % (MaxLen + 2, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', Pcd.DefaultValue))
 303
 304                   for F in Pa.Platform.Modules.keys():
 305                     for ModulePcd in Pa.Platform.Modules[F].M.ModulePcdList + Pa.Platform.Modules[F].M.LibraryPcdList:
 306                       if ModulePcd.TokenSpaceGuidCName <> Pcd.TokenSpaceGuidCName:
 307                         continue
 308                       if ModulePcd.TokenCName <> Pcd.TokenCName:
 309                         continue
 310                       if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
 311                         if ModulePcd.DefaultValue.strip()[0:2].upper() == '0X':
 312                           ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip(), 16)
 313                         else:
 314                           ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip())
 315                         Match = (ModulePcdDefaultValueNumber == PcdDefaultValueNumber)
 316                       else:
 317                         Match = (ModulePcd.DefaultValue == Pcd.DefaultValue)
 318                       if Match:
 319                         continue
 320                       Fd.write (' *M %*s = %s\n' % (MaxLen + 21, str(F).split('\\')[-1], ModulePcd.DefaultValue))
 321
 322                   if not DecMatch and DscMatch and DecDefaultValue <> None:
 323                     Fd.write ('    %*s = %s\n' % (MaxLen + 21, 'DEC DEFAULT', DecDefaultValue))
 324
 325               Fd.write ('\n')
 326
 327             Fd.write ('===============================================================================\n')
 328             Fd.write ('===============================================================================\n')
 329
 330             for F in Pa.Platform.Modules.keys():
 331               Fd.write ('\n')
 332               Fd.write ('===============================================================================\n')
 333               Fd.write ('MODULE: %s\n' % (F))
 334               Fd.write ('===============================================================================\n')
 335
 336               Fd.write ('PLATFORM CONFIGURATION DATABASE\n')
 337               Fd.write ('-------------------------------------------------------------------------------\n')
 338               ModuleFirst = True
 339               for Key in AllPcds:
 340                 First = True
 341                 for Type in AllPcds[Key]:
 342                   TypeName = ''
 343                   DecType = Type
 344                   if Type == 'FixedAtBuild':
 345                     TypeName = 'FIXED'
 346                   if Type == 'PatchableInModule':
 347                     TypeName = 'PATCH'
 348                   if Type == 'FeatureFlag':
 349                     TypeName = 'FLAG'
 350                   if Type == 'Dynamic':
 351                     TypeName = 'DYN'
 352                   if Type == 'DynamicHii':
 353                     TypeName = 'DYNHII'
 354                     DecType = 'Dynamic'
 355                   if Type == 'DynamicVpd':
 356                     TypeName = 'DYNVPD'
 357                     DecType = 'Dynamic'
 358                   if Type == 'DynamicEx':
 359                     TypeName = 'DEX'
 360                     DecType = 'Dynamic'
 361                   if Type == 'DynamicExHii':
 362                     TypeName = 'DEXHII'
 363                     DecType = 'Dynamic'
 364                   if Type == 'DynamicExVpd':
 365                     TypeName = 'DEXVPD'
 366                     DecType = 'Dynamic'
 367                   for Pcd in AllPcds[Key][Type]:
 368                     for ModulePcd in Pa.Platform.Modules[F].M.ModulePcdList + Pa.Platform.Modules[F].M.LibraryPcdList:
 369                       if ModulePcd.TokenSpaceGuidCName <> Pcd.TokenSpaceGuidCName:
 370                         continue
 371                       if ModulePcd.TokenCName <> Pcd.TokenCName:
 372                         continue
 373                       if ModulePcd.Type <> Pcd.Type:
 374                         continue
 375                       if First:
 376                         if ModuleFirst:
 377                           ModuleFirst = False
 378                         else:
 379                           Fd.write ('\n')
 380                         Fd.write ('%s\n' % (Key))
 381                         First = False
 382
 383                       InfDefaultValue = ModulePcd.InfDefaultValue
 384                       if InfDefaultValue == '':
 385                         InfDefaultValue = None
 386
 387                       DecDefaultValue = None
 388                       for Package in Pa.Platform.Modules[F].M.Module.Packages:
 389                         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType) in Package.Pcds:
 390                           if DecDefaultValue == None:
 391                             DecDefaultValue = Package.Pcds[Pcd.TokenCName, Pcd.TokenSpaceGuidCName, DecType].DefaultValue
 392
 393                       DscDefaultValue = None
 394                       if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds:
 395                         DscDefaultValue = self.BuildDatabase.WorkspaceDb.PlatformList[0].Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)].DefaultValue
 396
 397                       DscModuleOverrideDefaultValue = None
 398                       if F in self.BuildDatabase.WorkspaceDb.PlatformList[0].Modules:
 399                         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) in self.BuildDatabase.WorkspaceDb.PlatformList[0].Modules[F].Pcds:
 400                           DscModuleOverrideDefaultValue = self.BuildDatabase.WorkspaceDb.PlatformList[0].Modules[F].Pcds[(Pcd.TokenCName, Pcd.TokenSpaceGuidCName)].DefaultValue
 401
 402                       if Pcd.DatumType in ('UINT8', 'UINT16', 'UINT32', 'UINT64'):
 403                         if ModulePcd.DefaultValue.strip()[0:2].upper() == '0X':
 404                           ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip(), 16)
 405                         else:
 406                           ModulePcdDefaultValueNumber = int(ModulePcd.DefaultValue.strip())
 407
 408                         if DecDefaultValue == None:
 409                           DecMatch = True
 410                         else:
 411                           if DecDefaultValue.strip()[0:2].upper() == '0X':
 412                             DecDefaultValueNumber = int(DecDefaultValue.strip(), 16)
 413                           else:
 414                             DecDefaultValueNumber = int(DecDefaultValue.strip())
 415                           DecMatch = (DecDefaultValueNumber == ModulePcdDefaultValueNumber)
 416
 417                         if InfDefaultValue == None:
 418                           InfMatch = True
 419                         else:
 420                           if InfDefaultValue.strip()[0:2].upper() == '0X':
 421                             InfDefaultValueNumber = int(InfDefaultValue.strip(), 16)
 422                           else:
 423                             InfDefaultValueNumber = int(InfDefaultValue.strip())
 424                           InfMatch = (InfDefaultValueNumber == ModulePcdDefaultValueNumber)
 425
 426                         if DscDefaultValue == None:
 427                           DscMatch = True
 428                         else:
 429                           if DscDefaultValue.strip()[0:2].upper() == '0X':
 430                             DscDefaultValueNumber = int(DscDefaultValue.strip(), 16)
 431                           else:
 432                             DscDefaultValueNumber = int(DscDefaultValue.strip())
 433                           DscMatch = (DscDefaultValueNumber == ModulePcdDefaultValueNumber)
 434                       else:
 435                         if DecDefaultValue == None:
 436                           DecMatch = True
 437                         else:
 438                           DecMatch = (DecDefaultValue == ModulePcd.DefaultValue)
 439
 440                         if InfDefaultValue == None:
 441                           InfMatch = True
 442                         else:
 443                           InfMatch = (InfDefaultValue == ModulePcd.DefaultValue)
 444
 445                         if DscDefaultValue == None:
 446                           DscMatch = True
 447                         else:
 448                           DscMatch = (DscDefaultValue == ModulePcd.DefaultValue)
 449
 450                       if DecMatch and InfMatch:
 451                         Fd.write ('    %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
 452                       else:
 453                         if DscMatch and DscModuleOverrideDefaultValue == None:
 454                           if (Pcd.TokenCName, Key) in PcdSet:
 455                             Fd.write (' *F %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
 456                           else:
 457                             Fd.write (' *P %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
 458                         else:
 459                           Fd.write (' *M %-*s: %6s %10s = %-22s\n' % (MaxLen, Pcd.TokenCName, TypeName, '('+Pcd.DatumType+')', ModulePcd.DefaultValue))
 460                           if DscDefaultValue <> None:
 461                             Fd.write ('    %*s = %s\n' % (MaxLen + 19, 'DSC DEFAULT', DscDefaultValue))
 462                         if InfDefaultValue <> None:
 463                           Fd.write ('    %*s = %s\n' % (MaxLen + 19, 'INF DEFAULT', InfDefaultValue))
 464                         if DecDefaultValue <> None and not DecMatch:
 465                           Fd.write ('    %*s = %s\n' % (MaxLen + 19, 'DEC DEFAULT', DecDefaultValue))
 466               Fd.write ('-------------------------------------------------------------------------------\n')
 467               Fd.write ('LIBRARIES\n')
 468               Fd.write ('-------------------------------------------------------------------------------\n')
 469               for Lib in Pa.Platform.Modules[F].M.DependentLibraryList:
 470                 if len(Lib.ConstructorList) > 0:
 471                   if  len(Lib.DestructorList) > 0:
 472                     Fd.write (' *CD')
 473                   else:
 474                     Fd.write (' *C ')
 475                 else:
 476                   if  len(Lib.DestructorList) > 0:
 477                     Fd.write (' *D ')
 478                   else:
 479                     Fd.write ('    ')
 480                 Fd.write (' %s\n' % (Lib))
 481                 for Depex in Lib.DepexExpression[Pa.Platform.Modules[F].M.Arch, Pa.Platform.Modules[F].M.ModuleType]:
 482                   Fd.write ('       DEPEX = %s\n' % (Depex))
 483               Fd.write ('-------------------------------------------------------------------------------\n')
 484
 485               Fd.write ('MODULE DEPENDENCY EXPRESSION\n')
 486               if len(Pa.Platform.Modules[F].M.Module.DepexExpression[Pa.Platform.Modules[F].M.Arch, Pa.Platform.Modules[F].M.ModuleType]) == 0:
 487                 Fd.write ('  NONE\n')
 488               else:
 489                 for Depex in Pa.Platform.Modules[F].M.Module.DepexExpression[Pa.Platform.Modules[F].M.Arch, Pa.Platform.Modules[F].M.ModuleType]:
 490                   Fd.write ('  %s\n' % (Depex))
 491               Fd.write ('-------------------------------------------------------------------------------\n')
 492
 493               Fd.write ('MODULE + LIBRARY DEPENDENCY EXPRESSION\n')
 494               if Pa.Platform.Modules[F].M.ModuleType in Pa.Platform.Modules[F].M.DepexExpressionList:
 495                 if Pa.Platform.Modules[F].M.DepexExpressionList[Pa.Platform.Modules[F].M.ModuleType] == '':
 496                   Fd.write ('  NONE\n')
 497                 else:
 498                   Fd.write ('  %s\n' % (Pa.Platform.Modules[F].M.DepexExpressionList[Pa.Platform.Modules[F].M.ModuleType]))
 499               else:
 500                 Fd.write ('  NONE\n')
 501               Fd.write ('-------------------------------------------------------------------------------\n')
 502
 503             Fd.close()
 504           except:
 505             EdkLogger.error(None, FILE_OPEN_FAILURE, ExtraData=self.ReportFile)
 506
 507         self._BuildDir = None
 508         self._FvDir = None
 509         self._MakeFileDir = None
 510         self._BuildCommand = None
 511
 512         return True
 513
 514     def __repr__(self):
 515         return "%s [%s]" % (self.MetaFile, ", ".join(self.ArchList))
 516
 517     ## Return the directory to store FV files
 518     def _GetFvDir(self):
 519         if self._FvDir == None:
 520             self._FvDir = path.join(self.BuildDir, 'FV')
 521         return self._FvDir
 522
 523     ## Return the directory to store all intermediate and final files built
 524     def _GetBuildDir(self):
 525         return self.AutoGenObjectList[0].BuildDir
 526
 527     ## Return the build output directory platform specifies
 528     def _GetOutputDir(self):
 529         return self.Platform.OutputDirectory
 530
 531     ## Return platform name
 532     def _GetName(self):
 533         return self.Platform.PlatformName
 534
 535     ## Return meta-file GUID
 536     def _GetGuid(self):
 537         return self.Platform.Guid
 538
 539     ## Return platform version
 540     def _GetVersion(self):
 541         return self.Platform.Version
 542
 543     ## Return paths of tools
 544     def _GetToolDefinition(self):
 545         return self.AutoGenObjectList[0].ToolDefinition
 546
 547     ## Return directory of platform makefile
 548     #
 549     #   @retval     string  Makefile directory
 550     #
 551     def _GetMakeFileDir(self):
 552         if self._MakeFileDir == None:
 553             self._MakeFileDir = self.BuildDir
 554         return self._MakeFileDir
 555
 556     ## Return build command string
 557     #
 558     #   @retval     string  Build command string
 559     #
 560     def _GetBuildCommand(self):
 561         if self._BuildCommand == None:
 562             # BuildCommand should be all the same. So just get one from platform AutoGen
 563             self._BuildCommand = self.AutoGenObjectList[0].BuildCommand
 564         return self._BuildCommand
 565
 566     ## Create makefile for the platform and mdoules in it
 567     #
 568     #   @param      CreateDepsMakeFile      Flag indicating if the makefile for
 569     #                                       modules will be created as well
 570     #
 571     def CreateMakeFile(self, CreateDepsMakeFile=False):
 572         # create makefile for platform
 573         Makefile = GenMake.TopLevelMakefile(self)
 574         if Makefile.Generate():
 575             EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] %s\n" %
 576                             (self.MetaFile, self.ArchList))
 577         else:
 578             EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] %s\n" %
 579                             (self.MetaFile, self.ArchList))
 580
 581         if CreateDepsMakeFile:
 582             for Pa in self.AutoGenObjectList:
 583                 Pa.CreateMakeFile(CreateDepsMakeFile)
 584
 585     ## Create autogen code for platform and modules
 586     #
 587     #  Since there's no autogen code for platform, this method will do nothing
 588     #  if CreateModuleCodeFile is set to False.
 589     #
 590     #   @param      CreateDepsCodeFile      Flag indicating if creating module's
 591     #                                       autogen code file or not
 592     #
 593     def CreateCodeFile(self, CreateDepsCodeFile=False):
 594         if not CreateDepsCodeFile:
 595             return
 596         for Pa in self.AutoGenObjectList:
 597             Pa.CreateCodeFile(CreateDepsCodeFile)
 598
 599     Name                = property(_GetName)
 600     Guid                = property(_GetGuid)
 601     Version             = property(_GetVersion)
 602     OutputDir           = property(_GetOutputDir)
 603
 604     ToolDefinition      = property(_GetToolDefinition)       # toolcode : tool path
 605
 606     BuildDir            = property(_GetBuildDir)
 607     FvDir               = property(_GetFvDir)
 608     MakeFileDir         = property(_GetMakeFileDir)
 609     BuildCommand        = property(_GetBuildCommand)
 610
 611 ## AutoGen class for platform
 612 #
 613 #  PlatformAutoGen class will process the original information in platform
 614 #  file in order to generate makefile for platform.
 615 #
 616 class PlatformAutoGen(AutoGen):
 617     #
 618     # Used to store all PCDs for both PEI and DXE phase, in order to generate
 619     # correct PCD database
 620     #
 621     _DynaPcdList_ = []
 622     _NonDynaPcdList_ = []
 623
 624     ## The real constructor of PlatformAutoGen
 625     #
 626     #  This method is not supposed to be called by users of PlatformAutoGen. It's
 627     #  only used by factory method __new__() to do real initialization work for an
 628     #  object of PlatformAutoGen
 629     #
 630     #   @param      Workspace       WorkspaceAutoGen object
 631     #   @param      PlatformFile    Platform file (DSC file)
 632     #   @param      Target          Build target (DEBUG, RELEASE)
 633     #   @param      Toolchain       Name of tool chain
 634     #   @param      Arch            arch of the platform supports
 635     #
 636     def _Init(self, Workspace, PlatformFile, Target, Toolchain, Arch):
 637         EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen platform [%s] [%s]" % (PlatformFile, Arch))
 638         GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (PlatformFile, Arch, Toolchain, Target)
 639
 640         self.MetaFile = PlatformFile
 641         self.Workspace = Workspace
 642         self.WorkspaceDir = Workspace.WorkspaceDir
 643         self.ToolChain = Toolchain
 644         self.BuildTarget = Target
 645         self.Arch = Arch
 646         self.SourceDir = PlatformFile.SubDir
 647         self.SourceOverrideDir = None
 648         self.FdTargetList = self.Workspace.FdTargetList
 649         self.FvTargetList = self.Workspace.FvTargetList
 650
 651         # flag indicating if the makefile/C-code file has been created or not
 652         self.IsMakeFileCreated  = False
 653         self.IsCodeFileCreated  = False
 654
 655         self._Platform   = None
 656         self._Name       = None
 657         self._Guid       = None
 658         self._Version    = None
 659
 660         self._BuildRule = None
 661         self._SourceDir = None
 662         self._BuildDir = None
 663         self._OutputDir = None
 664         self._FvDir = None
 665         self._MakeFileDir = None
 666         self._FdfFile = None
 667
 668         self._PcdTokenNumber = None    # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber
 669         self._DynamicPcdList = None    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
 670         self._NonDynamicPcdList = None # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
 671
 672         self._ToolDefinitions = None
 673         self._ToolDefFile = None          # toolcode : tool path
 674         self._ToolChainFamily = None
 675         self._BuildRuleFamily = None
 676         self._BuildOption = None          # toolcode : option
 677         self._PackageList = None
 678         self._ModuleAutoGenList  = None
 679         self._LibraryAutoGenList = None
 680         self._BuildCommand = None
 681
 682         # get the original module/package/platform objects
 683         self.BuildDatabase = Workspace.BuildDatabase
 684         return True
 685
 686     def __repr__(self):
 687         return "%s [%s]" % (self.MetaFile, self.Arch)
 688
 689     ## Create autogen code for platform and modules
 690     #
 691     #  Since there's no autogen code for platform, this method will do nothing
 692     #  if CreateModuleCodeFile is set to False.
 693     #
 694     #   @param      CreateModuleCodeFile    Flag indicating if creating module's
 695     #                                       autogen code file or not
 696     #
 697     def CreateCodeFile(self, CreateModuleCodeFile=False):
 698         # only module has code to be greated, so do nothing if CreateModuleCodeFile is False
 699         if self.IsCodeFileCreated or not CreateModuleCodeFile:
 700             return
 701
 702         for Ma in self.ModuleAutoGenList:
 703             Ma.CreateCodeFile(True)
 704
 705         # don't do this twice
 706         self.IsCodeFileCreated = True
 707
 708     ## Create makefile for the platform and mdoules in it
 709     #
 710     #   @param      CreateModuleMakeFile    Flag indicating if the makefile for
 711     #                                       modules will be created as well
 712     #
 713     def CreateMakeFile(self, CreateModuleMakeFile=False):
 714         if CreateModuleMakeFile:
 715             for ModuleFile in self.Platform.Modules:
 716                 Ma = ModuleAutoGen(self.Workspace, ModuleFile, self.BuildTarget,
 717                                    self.ToolChain, self.Arch, self.MetaFile)
 718                 Ma.CreateMakeFile(True)
 719
 720         # no need to create makefile for the platform more than once
 721         if self.IsMakeFileCreated:
 722             return
 723
 724         # create makefile for platform
 725         Makefile = GenMake.PlatformMakefile(self)
 726         if Makefile.Generate():
 727             EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for platform [%s] [%s]\n" %
 728                             (self.MetaFile, self.Arch))
 729         else:
 730             EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for platform [%s] [%s]\n" %
 731                             (self.MetaFile, self.Arch))
 732         self.IsMakeFileCreated = True
 733
 734     ## Collect dynamic PCDs
 735     #
 736     #  Gather dynamic PCDs list from each module and their settings from platform
 737     #  This interface should be invoked explicitly when platform action is created.
 738     #
 739     def CollectPlatformDynamicPcds(self):
 740         # for gathering error information
 741         NoDatumTypePcdList = set()
 742
 743         self._GuidValue = {}
 744         for F in self.Platform.Modules.keys():
 745             M = ModuleAutoGen(self.Workspace, F, self.BuildTarget, self.ToolChain, self.Arch, self.MetaFile)
 746             #GuidValue.update(M.Guids)
 747
 748             self.Platform.Modules[F].M = M
 749
 750             for PcdFromModule in M.ModulePcdList+M.LibraryPcdList:
 751                 # make sure that the "VOID*" kind of datum has MaxDatumSize set
 752                 if PcdFromModule.DatumType == "VOID*" and PcdFromModule.MaxDatumSize == None:
 753                     NoDatumTypePcdList.add("%s.%s [%s]" % (PcdFromModule.TokenSpaceGuidCName, PcdFromModule.TokenCName, F))
 754
 755                 if PcdFromModule.Type in GenC.gDynamicPcd or PcdFromModule.Type in GenC.gDynamicExPcd:
 756                     #
 757                     # If a dynamic PCD used by a PEM module/PEI module & DXE module,
 758                     # it should be stored in Pcd PEI database, If a dynamic only
 759                     # used by DXE module, it should be stored in DXE PCD database.
 760                     # The default Phase is DXE
 761                     #
 762                     if M.ModuleType in ["PEIM", "PEI_CORE"]:
 763                         PcdFromModule.Phase = "PEI"
 764                     if PcdFromModule not in self._DynaPcdList_:
 765                         self._DynaPcdList_.append(PcdFromModule)
 766                     elif PcdFromModule.Phase == 'PEI':
 767                         # overwrite any the same PCD existing, if Phase is PEI
 768                         Index = self._DynaPcdList_.index(PcdFromModule)
 769                         self._DynaPcdList_[Index] = PcdFromModule
 770                 elif PcdFromModule not in self._NonDynaPcdList_:
 771                     self._NonDynaPcdList_.append(PcdFromModule)
 772
 773         # print out error information and break the build, if error found
 774         if len(NoDatumTypePcdList) > 0:
 775             NoDatumTypePcdListString = "\n\t\t".join(NoDatumTypePcdList)
 776             EdkLogger.error("build", AUTOGEN_ERROR, "PCD setting error",
 777                             File=self.MetaFile,
 778                             ExtraData="\n\tPCD(s) without MaxDatumSize:\n\t\t%s\n"
 779                                       % NoDatumTypePcdListString)
 780         self._NonDynamicPcdList = self._NonDynaPcdList_
 781         self._DynamicPcdList = self._DynaPcdList_
 782
 783         #
 784         # Sort dynamic PCD list to:
 785         # 1) If PCD's datum type is VOID* and value is unicode string which starts with L, the PCD item should
 786         #    try to be put header of dynamicd List
 787         # 2) If PCD is HII type, the PCD item should be put after unicode type PCD
 788         #
 789         # The reason of sorting is make sure the unicode string is in double-byte alignment in string table.
 790         #
 791         UnicodePcdArray = []
 792         HiiPcdArray     = []
 793         OtherPcdArray   = []
 794         for Pcd in self._DynamicPcdList:
 795             # just pick the a value to determine whether is unicode string type
 796             Sku      = Pcd.SkuInfoList[Pcd.SkuInfoList.keys()[0]]
 797             PcdValue = Sku.DefaultValue
 798             if Pcd.DatumType == 'VOID*' and PcdValue.startswith("L"):
 799                 # if found PCD which datum value is unicode string the insert to left size of UnicodeIndex
 800                 UnicodePcdArray.append(Pcd)
 801             elif len(Sku.VariableName) > 0:
 802                 # if found HII type PCD then insert to right of UnicodeIndex
 803                 HiiPcdArray.append(Pcd)
 804             else:
 805                 OtherPcdArray.append(Pcd)
 806         del self._DynamicPcdList[:]
 807         self._DynamicPcdList.extend(UnicodePcdArray)
 808         self._DynamicPcdList.extend(HiiPcdArray)
 809         self._DynamicPcdList.extend(OtherPcdArray)
 810
 811
 812     ## Return the platform build data object
 813     def _GetPlatform(self):
 814         if self._Platform == None:
 815             self._Platform = self.BuildDatabase[self.MetaFile, self.Arch]
 816         return self._Platform
 817
 818     ## Return platform name
 819     def _GetName(self):
 820         return self.Platform.PlatformName
 821
 822     ## Return the meta file GUID
 823     def _GetGuid(self):
 824         return self.Platform.Guid
 825
 826     ## Return the platform version
 827     def _GetVersion(self):
 828         return self.Platform.Version
 829
 830     ## Return the FDF file name
 831     def _GetFdfFile(self):
 832         if self._FdfFile == None:
 833             if self.Workspace.FdfFile != "":
 834                 self._FdfFile= path.join(self.WorkspaceDir, self.Workspace.FdfFile)
 835             else:
 836                 self._FdfFile = ''
 837         return self._FdfFile
 838
 839     ## Return the build output directory platform specifies
 840     def _GetOutputDir(self):
 841         return self.Platform.OutputDirectory
 842
 843     ## Return the directory to store all intermediate and final files built
 844     def _GetBuildDir(self):
 845         if self._BuildDir == None:
 846             if os.path.isabs(self.OutputDir):
 847                 self._BuildDir = path.join(
 848                                             path.abspath(self.OutputDir),
 849                                             self.BuildTarget + "_" + self.ToolChain,
 850                                             )
 851             else:
 852                 self._BuildDir = path.join(
 853                                             self.WorkspaceDir,
 854                                             self.OutputDir,
 855                                             self.BuildTarget + "_" + self.ToolChain,
 856                                             )
 857         return self._BuildDir
 858
 859     ## Return directory of platform makefile
 860     #
 861     #   @retval     string  Makefile directory
 862     #
 863     def _GetMakeFileDir(self):
 864         if self._MakeFileDir == None:
 865             self._MakeFileDir = path.join(self.BuildDir, self.Arch)
 866         return self._MakeFileDir
 867
 868     ## Return build command string
 869     #
 870     #   @retval     string  Build command string
 871     #
 872     def _GetBuildCommand(self):
 873         if self._BuildCommand == None:
 874             self._BuildCommand = []
 875             if "MAKE" in self.ToolDefinition and "PATH" in self.ToolDefinition["MAKE"]:
 876                 self._BuildCommand += SplitOption(self.ToolDefinition["MAKE"]["PATH"])
 877                 if "FLAGS" in self.ToolDefinition["MAKE"]:
 878                     NewOption = self.ToolDefinition["MAKE"]["FLAGS"].strip()
 879                     if NewOption != '':
 880                       self._BuildCommand += SplitOption(NewOption)
 881         return self._BuildCommand
 882
 883     ## Get tool chain definition
 884     #
 885     #  Get each tool defition for given tool chain from tools_def.txt and platform
 886     #
 887     def _GetToolDefinition(self):
 888         if self._ToolDefinitions == None:
 889             ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDictionary
 890             if TAB_TOD_DEFINES_COMMAND_TYPE not in self.Workspace.ToolDef.ToolsDefTxtDatabase:
 891                 EdkLogger.error('build', RESOURCE_NOT_AVAILABLE, "No tools found in configuration",
 892                                 ExtraData="[%s]" % self.MetaFile)
 893             self._ToolDefinitions = {}
 894             DllPathList = set()
 895             for Def in ToolDefinition:
 896                 Target, Tag, Arch, Tool, Attr = Def.split("_")
 897                 if Target != self.BuildTarget or Tag != self.ToolChain or Arch != self.Arch:
 898                     continue
 899
 900                 Value = ToolDefinition[Def]
 901                 # don't record the DLL
 902                 if Attr == "DLL":
 903                     DllPathList.add(Value)
 904                     continue
 905
 906                 if Tool not in self._ToolDefinitions:
 907                     self._ToolDefinitions[Tool] = {}
 908                 self._ToolDefinitions[Tool][Attr] = Value
 909
 910             ToolsDef = ''
 911             MakePath = ''
 912             if GlobalData.gOptions.SilentMode and "MAKE" in self._ToolDefinitions:
 913                 if "FLAGS" not in self._ToolDefinitions["MAKE"]:
 914                     self._ToolDefinitions["MAKE"]["FLAGS"] = ""
 915                 self._ToolDefinitions["MAKE"]["FLAGS"] += " -s"
 916             MakeFlags = ''
 917             for Tool in self._ToolDefinitions:
 918                 for Attr in self._ToolDefinitions[Tool]:
 919                     Value = self._ToolDefinitions[Tool][Attr]
 920                     if Tool in self.BuildOption and Attr in self.BuildOption[Tool]:
 921                         # check if override is indicated
 922                         if self.BuildOption[Tool][Attr].startswith('='):
 923                             Value = self.BuildOption[Tool][Attr][1:]
 924                         else:
 925                             Value += " " + self.BuildOption[Tool][Attr]
 926
 927                     if Attr == "PATH":
 928                         # Don't put MAKE definition in the file
 929                         if Tool == "MAKE":
 930                             MakePath = Value
 931                         else:
 932                             ToolsDef += "%s = %s\n" % (Tool, Value)
 933                     elif Attr != "DLL":
 934                         # Don't put MAKE definition in the file
 935                         if Tool == "MAKE":
 936                             if Attr == "FLAGS":
 937                                 MakeFlags = Value
 938                         else:
 939                             ToolsDef += "%s_%s = %s\n" % (Tool, Attr, Value)
 940                 ToolsDef += "\n"
 941
 942             SaveFileOnChange(self.ToolDefinitionFile, ToolsDef)
 943             for DllPath in DllPathList:
 944                 os.environ["PATH"] = DllPath + os.pathsep + os.environ["PATH"]
 945             os.environ["MAKE_FLAGS"] = MakeFlags
 946
 947         return self._ToolDefinitions
 948
 949     ## Return the paths of tools
 950     def _GetToolDefFile(self):
 951         if self._ToolDefFile == None:
 952             self._ToolDefFile = os.path.join(self.MakeFileDir, "TOOLS_DEF." + self.Arch)
 953         return self._ToolDefFile
 954
 955     ## Retrieve the toolchain family of given toolchain tag. Default to 'MSFT'.
 956     def _GetToolChainFamily(self):
 957         if self._ToolChainFamily == None:
 958             ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
 959             if TAB_TOD_DEFINES_FAMILY not in ToolDefinition \
 960                or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_FAMILY] \
 961                or not ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]:
 962                 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
 963                                    % self.ToolChain)
 964                 self._ToolChainFamily = "MSFT"
 965             else:
 966                 self._ToolChainFamily = ToolDefinition[TAB_TOD_DEFINES_FAMILY][self.ToolChain]
 967         return self._ToolChainFamily
 968
 969     def _GetBuildRuleFamily(self):
 970         if self._BuildRuleFamily == None:
 971             ToolDefinition = self.Workspace.ToolDef.ToolsDefTxtDatabase
 972             if TAB_TOD_DEFINES_BUILDRULEFAMILY not in ToolDefinition \
 973                or self.ToolChain not in ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY] \
 974                or not ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]:
 975                 EdkLogger.verbose("No tool chain family found in configuration for %s. Default to MSFT." \
 976                                    % self.ToolChain)
 977                 self._BuildRuleFamily = "MSFT"
 978             else:
 979                 self._BuildRuleFamily = ToolDefinition[TAB_TOD_DEFINES_BUILDRULEFAMILY][self.ToolChain]
 980         return self._BuildRuleFamily
 981
 982     ## Return the build options specific to this platform
 983     def _GetBuildOptions(self):
 984         if self._BuildOption == None:
 985             self._BuildOption = self._ExpandBuildOption(self.Platform.BuildOptions)
 986         return self._BuildOption
 987
 988     ## Parse build_rule.txt in $(WORKSPACE)/Conf/build_rule.txt
 989     #
 990     #   @retval     BuildRule object
 991     #
 992     def _GetBuildRule(self):
 993         if self._BuildRule == None:
 994             BuildRuleFile = None
 995             if TAB_TAT_DEFINES_BUILD_RULE_CONF in self.Workspace.TargetTxt.TargetTxtDictionary:
 996                 BuildRuleFile = self.Workspace.TargetTxt.TargetTxtDictionary[TAB_TAT_DEFINES_BUILD_RULE_CONF]
 997             if BuildRuleFile in [None, '']:
 998                 BuildRuleFile = gBuildRuleFile
 999             self._BuildRule = BuildRule(BuildRuleFile)
1000         return self._BuildRule
1001
1002     ## Summarize the packages used by modules in this platform
1003     def _GetPackageList(self):
1004         if self._PackageList == None:
1005             self._PackageList = set()
1006             for La in self.LibraryAutoGenList:
1007                 self._PackageList.update(La.DependentPackageList)
1008             for Ma in self.ModuleAutoGenList:
1009                 self._PackageList.update(Ma.DependentPackageList)
1010             self._PackageList = list(self._PackageList)
1011         return self._PackageList
1012
1013     ## Get list of non-dynamic PCDs
1014     def _GetNonDynamicPcdList(self):
1015         return self._NonDynamicPcdList
1016
1017     ## Get list of dynamic PCDs
1018     def _GetDynamicPcdList(self):
1019         return self._DynamicPcdList
1020
1021     ## Generate Token Number for all PCD
1022     def _GetPcdTokenNumbers(self):
1023         if self._PcdTokenNumber == None:
1024             self._PcdTokenNumber = sdict()
1025             TokenNumber = 1
1026             for Pcd in self.DynamicPcdList:
1027                 if Pcd.Phase == "PEI":
1028                     EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
1029                     self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
1030                     TokenNumber += 1
1031
1032             for Pcd in self.DynamicPcdList:
1033                 if Pcd.Phase == "DXE":
1034                     EdkLogger.debug(EdkLogger.DEBUG_5, "%s %s (%s) -> %d" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName, Pcd.Phase, TokenNumber))
1035                     self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
1036                     TokenNumber += 1
1037
1038             for Pcd in self.NonDynamicPcdList:
1039                 self._PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName] = TokenNumber
1040                 TokenNumber += 1
1041         return self._PcdTokenNumber
1042
1043     ## Summarize ModuleAutoGen objects of all modules/libraries to be built for this platform
1044     def _GetAutoGenObjectList(self):
1045         self._ModuleAutoGenList = []
1046         self._LibraryAutoGenList = []
1047         for ModuleFile in self.Platform.Modules:
1048             Ma = ModuleAutoGen(
1049                     self.Workspace,
1050                     ModuleFile,
1051                     self.BuildTarget,
1052                     self.ToolChain,
1053                     self.Arch,
1054                     self.MetaFile
1055                     )
1056             if Ma not in self._ModuleAutoGenList:
1057                 self._ModuleAutoGenList.append(Ma)
1058             for La in Ma.LibraryAutoGenList:
1059                 if La not in self._LibraryAutoGenList:
1060                     self._LibraryAutoGenList.append(La)
1061
1062     ## Summarize ModuleAutoGen objects of all modules to be built for this platform
1063     def _GetModuleAutoGenList(self):
1064         if self._ModuleAutoGenList == None:
1065             self._GetAutoGenObjectList()
1066         return self._ModuleAutoGenList
1067
1068     ## Summarize ModuleAutoGen objects of all libraries to be built for this platform
1069     def _GetLibraryAutoGenList(self):
1070         if self._LibraryAutoGenList == None:
1071             self._GetAutoGenObjectList()
1072         return self._LibraryAutoGenList
1073
1074     ## Test if a module is supported by the platform
1075     #
1076     #  An error will be raised directly if the module or its arch is not supported
1077     #  by the platform or current configuration
1078     #
1079     def ValidModule(self, Module):
1080         return Module in self.Platform.Modules or Module in self.Platform.LibraryInstances
1081
1082     ## Resolve the library classes in a module to library instances
1083     #
1084     # This method will not only resolve library classes but also sort the library
1085     # instances according to the dependency-ship.
1086     #
1087     #   @param  Module      The module from which the library classes will be resolved
1088     #
1089     #   @retval library_list    List of library instances sorted
1090     #
1091     def ApplyLibraryInstance(self, Module):
1092         ModuleType = Module.ModuleType
1093
1094         # for overridding library instances with module specific setting
1095         PlatformModule = self.Platform.Modules[str(Module)]
1096
1097         # add forced library instances (specified under LibraryClasses sections)
1098         for LibraryClass in self.Platform.LibraryClasses.GetKeys():
1099             if LibraryClass.startswith("NULL"):
1100                 Module.LibraryClasses[LibraryClass] = self.Platform.LibraryClasses[LibraryClass]
1101
1102         # add forced library instances (specified in module overrides)
1103         for LibraryClass in PlatformModule.LibraryClasses:
1104             if LibraryClass.startswith("NULL"):
1105                 Module.LibraryClasses[LibraryClass] = PlatformModule.LibraryClasses[LibraryClass]
1106
1107         # R9 module
1108         LibraryConsumerList = [Module]
1109         Constructor         = []
1110         ConsumedByList      = sdict()
1111         LibraryInstance     = sdict()
1112
1113         EdkLogger.verbose("")
1114         EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))
1115         while len(LibraryConsumerList) > 0:
1116             M = LibraryConsumerList.pop()
1117             for LibraryClassName in M.LibraryClasses:
1118                 if LibraryClassName not in LibraryInstance:
1119                     # override library instance for this module
1120                     if LibraryClassName in PlatformModule.LibraryClasses:
1121                         LibraryPath = PlatformModule.LibraryClasses[LibraryClassName]
1122                     else:
1123                         LibraryPath = self.Platform.LibraryClasses[LibraryClassName, ModuleType]
1124                     if LibraryPath == None or LibraryPath == "":
1125                         LibraryPath = M.LibraryClasses[LibraryClassName]
1126                         if LibraryPath == None or LibraryPath == "":
1127                             EdkLogger.error("build", RESOURCE_NOT_AVAILABLE,
1128                                             "Instance of library class [%s] is not found" % LibraryClassName,
1129                                             File=self.MetaFile,
1130                                             ExtraData="in [%s] [%s]\n\tconsumed by module [%s]" % (str(M), self.Arch, str(Module)))
1131
1132                     LibraryModule = self.BuildDatabase[LibraryPath, self.Arch]
1133                     # for those forced library instance (NULL library), add a fake library class
1134                     if LibraryClassName.startswith("NULL"):
1135                         LibraryModule.LibraryClass.append(LibraryClassObject(LibraryClassName, [ModuleType]))
1136                     elif LibraryModule.LibraryClass == None \
1137                          or len(LibraryModule.LibraryClass) == 0 \
1138                          or (ModuleType != 'USER_DEFINED'
1139                              and ModuleType not in LibraryModule.LibraryClass[0].SupModList):
1140                         # only USER_DEFINED can link against any library instance despite of its SupModList
1141                         EdkLogger.error("build", OPTION_MISSING,
1142                                         "Module type [%s] is not supported by library instance [%s]" \
1143                                         % (ModuleType, LibraryPath), File=self.MetaFile,
1144                                         ExtraData="consumed by [%s]" % str(Module))
1145
1146                     LibraryInstance[LibraryClassName] = LibraryModule
1147                     LibraryConsumerList.append(LibraryModule)
1148                     EdkLogger.verbose("\t" + str(LibraryClassName) + " : " + str(LibraryModule))
1149                 else:
1150                     LibraryModule = LibraryInstance[LibraryClassName]
1151
1152                 if LibraryModule == None:
1153                     continue
1154
1155                 if LibraryModule.ConstructorList != [] and LibraryModule not in Constructor:
1156                     Constructor.append(LibraryModule)
1157
1158                 if LibraryModule not in ConsumedByList:
1159                     ConsumedByList[LibraryModule] = []
1160                 # don't add current module itself to consumer list
1161                 if M != Module:
1162                     if M in ConsumedByList[LibraryModule]:
1163                         continue
1164                     ConsumedByList[LibraryModule].append(M)
1165         #
1166         # Initialize the sorted output list to the empty set
1167         #
1168         SortedLibraryList = []
1169         #
1170         # Q <- Set of all nodes with no incoming edges
1171         #
1172         LibraryList = [] #LibraryInstance.values()
1173         Q = []
1174         for LibraryClassName in LibraryInstance:
1175             M = LibraryInstance[LibraryClassName]
1176             LibraryList.append(M)
1177             if ConsumedByList[M] == []:
1178                 Q.insert(0, M)
1179
1180         #
1181         # start the  DAG algorithm
1182         #
1183         while True:
1184             EdgeRemoved = True
1185             while Q == [] and EdgeRemoved:
1186                 EdgeRemoved = False
1187                 # for each node Item with a Constructor
1188                 for Item in LibraryList:
1189                     if Item not in Constructor:
1190                         continue
1191                     # for each Node without a constructor with an edge e from Item to Node
1192                     for Node in ConsumedByList[Item]:
1193                         if Node in Constructor:
1194                             continue
1195                         # remove edge e from the graph if Node has no constructor
1196                         ConsumedByList[Item].remove(Node)
1197                         EdgeRemoved = True
1198                         if ConsumedByList[Item] == []:
1199                             # insert Item into Q
1200                             Q.insert(0, Item)
1201                             break
1202                     if Q != []:
1203                         break
1204             # DAG is done if there's no more incoming edge for all nodes
1205             if Q == []:
1206                 break
1207
1208             # remove node from Q
1209             Node = Q.pop()
1210             # output Node
1211             SortedLibraryList.append(Node)
1212
1213             # for each node Item with an edge e from Node to Item do
1214             for Item in LibraryList:
1215                 if Node not in ConsumedByList[Item]:
1216                     continue
1217                 # remove edge e from the graph
1218                 ConsumedByList[Item].remove(Node)
1219
1220                 if ConsumedByList[Item] != []:
1221                     continue
1222                 # insert Item into Q, if Item has no other incoming edges
1223                 Q.insert(0, Item)
1224
1225         #
1226         # if any remaining node Item in the graph has a constructor and an incoming edge, then the graph has a cycle
1227         #
1228         for Item in LibraryList:
1229             if ConsumedByList[Item] != [] and Item in Constructor and len(Constructor) > 1:
1230                 ErrorMessage = "\tconsumed by " + "\n\tconsumed by ".join([str(L) for L in ConsumedByList[Item]])
1231                 EdkLogger.error("build", BUILD_ERROR, 'Library [%s] with constructors has a cycle' % str(Item),
1232                                 ExtraData=ErrorMessage, File=self.MetaFile)
1233             if Item not in SortedLibraryList:
1234                 SortedLibraryList.append(Item)
1235
1236         #
1237         # Build the list of constructor and destructir names
1238         # The DAG Topo sort produces the destructor order, so the list of constructors must generated in the reverse order
1239         #
1240         SortedLibraryList.reverse()
1241         return SortedLibraryList
1242
1243
1244     ## Override PCD setting (type, value, ...)
1245     #
1246     #   @param  ToPcd       The PCD to be overrided
1247     #   @param  FromPcd     The PCD overrideing from
1248     #
1249     def _OverridePcd(self, ToPcd, FromPcd, Module=""):
1250         #
1251         # in case there's PCDs coming from FDF file, which have no type given.
1252         # at this point, ToPcd.Type has the type found from dependent
1253         # package
1254         #
1255         if FromPcd != None:
1256             if ToPcd.Pending and FromPcd.Type not in [None, '']:
1257                 ToPcd.Type = FromPcd.Type
1258             elif ToPcd.Type not in [None, ''] and FromPcd.Type not in [None, ''] \
1259                 and ToPcd.Type != FromPcd.Type:
1260                 EdkLogger.error("build", OPTION_CONFLICT, "Mismatched PCD type",
1261                                 ExtraData="%s.%s is defined as [%s] in module %s, but as [%s] in platform."\
1262                                           % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName,
1263                                              ToPcd.Type, Module, FromPcd.Type),
1264                                           File=self.MetaFile)
1265
1266             if FromPcd.MaxDatumSize not in [None, '']:
1267                 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize
1268             if FromPcd.DefaultValue not in [None, '']:
1269                 ToPcd.DefaultValue = FromPcd.DefaultValue
1270             if FromPcd.TokenValue not in [None, '']:
1271                 ToPcd.TokenValue = FromPcd.TokenValue
1272             if FromPcd.MaxDatumSize not in [None, '']:
1273                 ToPcd.MaxDatumSize = FromPcd.MaxDatumSize
1274             if FromPcd.DatumType not in [None, '']:
1275                 ToPcd.DatumType = FromPcd.DatumType
1276             if FromPcd.SkuInfoList not in [None, '', []]:
1277                 ToPcd.SkuInfoList = FromPcd.SkuInfoList
1278
1279             # check the validation of datum
1280             IsValid, Cause = CheckPcdDatum(ToPcd.DatumType, ToPcd.DefaultValue)
1281             if not IsValid:
1282                 EdkLogger.error('build', FORMAT_INVALID, Cause, File=self.MetaFile,
1283                                 ExtraData="%s.%s" % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))
1284
1285         if ToPcd.DatumType == "VOID*" and ToPcd.MaxDatumSize in ['', None]:
1286             EdkLogger.debug(EdkLogger.DEBUG_9, "No MaxDatumSize specified for PCD %s.%s" \
1287                             % (ToPcd.TokenSpaceGuidCName, ToPcd.TokenCName))
1288             Value = ToPcd.DefaultValue
1289             if Value in [None, '']:
1290                 ToPcd.MaxDatumSize = 1
1291             elif Value[0] == 'L':
1292                 ToPcd.MaxDatumSize = str(len(Value) * 2)
1293             elif Value[0] == '{':
1294                 ToPcd.MaxDatumSize = str(len(Value.split(',')))
1295             else:
1296                 ToPcd.MaxDatumSize = str(len(Value))
1297
1298         # apply default SKU for dynamic PCDS if specified one is not available
1299         if (ToPcd.Type in PCD_DYNAMIC_TYPE_LIST or ToPcd.Type in PCD_DYNAMIC_EX_TYPE_LIST) \
1300             and ToPcd.SkuInfoList in [None, {}, '']:
1301             if self.Platform.SkuName in self.Platform.SkuIds:
1302                 SkuName = self.Platform.SkuName
1303             else:
1304                 SkuName = 'DEFAULT'
1305             ToPcd.SkuInfoList = {
1306                 SkuName : SkuInfoClass(SkuName, self.Platform.SkuIds[SkuName], '', '', '', '', '', ToPcd.DefaultValue)
1307             }
1308
1309     ## Apply PCD setting defined platform to a module
1310     #
1311     #   @param  Module  The module from which the PCD setting will be overrided
1312     #
1313     #   @retval PCD_list    The list PCDs with settings from platform
1314     #
1315     def ApplyPcdSetting(self, Module, Pcds):
1316         # for each PCD in module
1317         for Name,Guid in Pcds:
1318             PcdInModule = Pcds[Name,Guid]
1319             # find out the PCD setting in platform
1320             if (Name,Guid) in self.Platform.Pcds:
1321                 PcdInPlatform = self.Platform.Pcds[Name,Guid]
1322             else:
1323                 PcdInPlatform = None
1324             # then override the settings if any
1325             self._OverridePcd(PcdInModule, PcdInPlatform, Module)
1326             # resolve the VariableGuid value
1327             for SkuId in PcdInModule.SkuInfoList:
1328                 Sku = PcdInModule.SkuInfoList[SkuId]
1329                 if Sku.VariableGuid == '': continue
1330                 Sku.VariableGuidValue = GuidValue(Sku.VariableGuid, self.PackageList)
1331                 if Sku.VariableGuidValue == None:
1332                     PackageList = "\n\t".join([str(P) for P in self.PackageList])
1333                     EdkLogger.error(
1334                                 'build',
1335                                 RESOURCE_NOT_AVAILABLE,
1336                                 "Value of GUID [%s] is not found in" % Sku.VariableGuid,
1337                                 ExtraData=PackageList + "\n\t(used with %s.%s from module %s)" \
1338                                                         % (Guid, Name, str(Module)),
1339                                 File=self.MetaFile
1340                                 )
1341
1342         # override PCD settings with module specific setting
1343         if Module in self.Platform.Modules:
1344             PlatformModule = self.Platform.Modules[str(Module)]
1345             for Key  in PlatformModule.Pcds:
1346                 if Key in Pcds:
1347                     self._OverridePcd(Pcds[Key], PlatformModule.Pcds[Key], Module)
1348         return Pcds.values()
1349
1350     ## Resolve library names to library modules
1351     #
1352     # (for R8.x modules)
1353     #
1354     #   @param  Module  The module from which the library names will be resolved
1355     #
1356     #   @retval library_list    The list of library modules
1357     #
1358     def ResolveLibraryReference(self, Module):
1359         EdkLogger.verbose("")
1360         EdkLogger.verbose("Library instances of module [%s] [%s]:" % (str(Module), self.Arch))
1361         LibraryConsumerList = [Module]
1362
1363         # "CompilerStub" is a must for R8 modules
1364         if Module.Libraries:
1365             Module.Libraries.append("CompilerStub")
1366         LibraryList = []
1367         while len(LibraryConsumerList) > 0:
1368             M = LibraryConsumerList.pop()
1369             for LibraryName in M.Libraries:
1370                 Library = self.Platform.LibraryClasses[LibraryName, ':dummy:']
1371                 if Library == None:
1372                     for Key in self.Platform.LibraryClasses.data.keys():
1373                         if LibraryName.upper() == Key.upper():
1374                             Library = self.Platform.LibraryClasses[Key, ':dummy:']
1375                             break
1376                     if Library == None:
1377                         EdkLogger.warn("build", "Library [%s] is not found" % LibraryName, File=str(M),
1378                             ExtraData="\t%s [%s]" % (str(Module), self.Arch))
1379                         continue
1380
1381                 if Library not in LibraryList:
1382                     LibraryList.append(Library)
1383                     LibraryConsumerList.append(Library)
1384                     EdkLogger.verbose("\t" + LibraryName + " : " + str(Library) + ' ' + str(type(Library)))
1385         return LibraryList
1386
1387     ## Expand * in build option key
1388     #
1389     #   @param  Options     Options to be expanded
1390     #
1391     #   @retval options     Options expanded
1392     #
1393     def _ExpandBuildOption(self, Options):
1394         BuildOptions = {}
1395         FamilyMatch  = False
1396         FamilyIsNull = True
1397         for Key in Options:
1398             Family = Key[0]
1399             Target, Tag, Arch, Tool, Attr = Key[1].split("_")
1400             # if tool chain family doesn't match, skip it
1401             if Tool in self.ToolDefinition and Family != "":
1402                 FamilyIsNull = False
1403                 if self.ToolDefinition[Tool].get(TAB_TOD_DEFINES_BUILDRULEFAMILY, "") != "":
1404                     if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_BUILDRULEFAMILY]:
1405                         continue
1406                 elif Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:
1407                     continue
1408                 FamilyMatch = True
1409             # expand any wildcard
1410             if Target == "*" or Target == self.BuildTarget:
1411                 if Tag == "*" or Tag == self.ToolChain:
1412                     if Arch == "*" or Arch == self.Arch:
1413                         if Tool not in BuildOptions:
1414                             BuildOptions[Tool] = {}
1415                         if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:
1416                             BuildOptions[Tool][Attr] = Options[Key]
1417                         else:
1418                             # append options for the same tool
1419                             BuildOptions[Tool][Attr] += " " + Options[Key]
1420         # Build Option Family has been checked, which need't to be checked again for family.
1421         if FamilyMatch or FamilyIsNull:
1422             return BuildOptions
1423
1424         for Key in Options:
1425             Family = Key[0]
1426             Target, Tag, Arch, Tool, Attr = Key[1].split("_")
1427             # if tool chain family doesn't match, skip it
1428             if Tool not in self.ToolDefinition or Family =="":
1429                 continue
1430             # option has been added before
1431             if Family != self.ToolDefinition[Tool][TAB_TOD_DEFINES_FAMILY]:
1432                 continue
1433
1434             # expand any wildcard
1435             if Target == "*" or Target == self.BuildTarget:
1436                 if Tag == "*" or Tag == self.ToolChain:
1437                     if Arch == "*" or Arch == self.Arch:
1438                         if Tool not in BuildOptions:
1439                             BuildOptions[Tool] = {}
1440                         if Attr != "FLAGS" or Attr not in BuildOptions[Tool]:
1441                             BuildOptions[Tool][Attr] = Options[Key]
1442                         else:
1443                             # append options for the same tool
1444                             BuildOptions[Tool][Attr] += " " + Options[Key]
1445         return BuildOptions
1446
1447     ## Append build options in platform to a module
1448     #
1449     #   @param  Module  The module to which the build options will be appened
1450     #
1451     #   @retval options     The options appended with build options in platform
1452     #
1453     def ApplyBuildOption(self, Module):
1454         PlatformOptions = self.BuildOption
1455         ModuleOptions = self._ExpandBuildOption(Module.BuildOptions)
1456         if Module in self.Platform.Modules:
1457             PlatformModule = self.Platform.Modules[str(Module)]
1458             PlatformModuleOptions = self._ExpandBuildOption(PlatformModule.BuildOptions)
1459         else:
1460             PlatformModuleOptions = {}
1461
1462         AllTools = set(ModuleOptions.keys() + PlatformOptions.keys() + PlatformModuleOptions.keys() + self.ToolDefinition.keys())
1463         BuildOptions = {}
1464         for Tool in AllTools:
1465             if Tool not in BuildOptions:
1466                 BuildOptions[Tool] = {}
1467
1468             for Options in [self.ToolDefinition, ModuleOptions, PlatformOptions, PlatformModuleOptions]:
1469                 if Tool not in Options:
1470                     continue
1471                 for Attr in Options[Tool]:
1472                     Value = Options[Tool][Attr]
1473                     if Attr not in BuildOptions[Tool]:
1474                         BuildOptions[Tool][Attr] = ""
1475                     # check if override is indicated
1476                     if Value.startswith('='):
1477                         BuildOptions[Tool][Attr] = Value[1:]
1478                     else:
1479                         BuildOptions[Tool][Attr] += " " + Value
1480         return BuildOptions
1481
1482     Platform            = property(_GetPlatform)
1483     Name                = property(_GetName)
1484     Guid                = property(_GetGuid)
1485     Version             = property(_GetVersion)
1486
1487     OutputDir           = property(_GetOutputDir)
1488     BuildDir            = property(_GetBuildDir)
1489     MakeFileDir         = property(_GetMakeFileDir)
1490     FdfFile             = property(_GetFdfFile)
1491
1492     PcdTokenNumber      = property(_GetPcdTokenNumbers)    # (TokenCName, TokenSpaceGuidCName) : GeneratedTokenNumber
1493     DynamicPcdList      = property(_GetDynamicPcdList)    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
1494     NonDynamicPcdList   = property(_GetNonDynamicPcdList)    # [(TokenCName1, TokenSpaceGuidCName1), (TokenCName2, TokenSpaceGuidCName2), ...]
1495     PackageList         = property(_GetPackageList)
1496
1497     ToolDefinition      = property(_GetToolDefinition)    # toolcode : tool path
1498     ToolDefinitionFile  = property(_GetToolDefFile)    # toolcode : lib path
1499     ToolChainFamily     = property(_GetToolChainFamily)
1500     BuildRuleFamily     = property(_GetBuildRuleFamily)
1501     BuildOption         = property(_GetBuildOptions)    # toolcode : option
1502
1503     BuildCommand        = property(_GetBuildCommand)
1504     BuildRule           = property(_GetBuildRule)
1505     ModuleAutoGenList   = property(_GetModuleAutoGenList)
1506     LibraryAutoGenList  = property(_GetLibraryAutoGenList)
1507
1508 ## ModuleAutoGen class
1509 #
1510 # This class encapsules the AutoGen behaviors for the build tools. In addition to
1511 # the generation of AutoGen.h and AutoGen.c, it will generate *.depex file according
1512 # to the [depex] section in module's inf file.
1513 #
1514 class ModuleAutoGen(AutoGen):
1515     ## The real constructor of ModuleAutoGen
1516     #
1517     #  This method is not supposed to be called by users of ModuleAutoGen. It's
1518     #  only used by factory method __new__() to do real initialization work for an
1519     #  object of ModuleAutoGen
1520     #
1521     #   @param      Workspace           EdkIIWorkspaceBuild object
1522     #   @param      ModuleFile          The path of module file
1523     #   @param      Target              Build target (DEBUG, RELEASE)
1524     #   @param      Toolchain           Name of tool chain
1525     #   @param      Arch                The arch the module supports
1526     #   @param      PlatformFile        Platform meta-file
1527     #
1528     def _Init(self, Workspace, ModuleFile, Target, Toolchain, Arch, PlatformFile):
1529         EdkLogger.debug(EdkLogger.DEBUG_9, "AutoGen module [%s] [%s]" % (ModuleFile, Arch))
1530         GlobalData.gProcessingFile = "%s [%s, %s, %s]" % (ModuleFile, Arch, Toolchain, Target)
1531
1532         self.Workspace = Workspace
1533         self.WorkspaceDir = Workspace.WorkspaceDir
1534
1535         self.MetaFile = ModuleFile
1536         self.PlatformInfo = PlatformAutoGen(Workspace, PlatformFile, Target, Toolchain, Arch)
1537         # check if this module is employed by active platform
1538         if not self.PlatformInfo.ValidModule(self.MetaFile):
1539             EdkLogger.verbose("Module [%s] for [%s] is not employed by active platform\n" \
1540                               % (self.MetaFile, Arch))
1541             return False
1542
1543         self.SourceDir = self.MetaFile.SubDir
1544         self.SourceOverrideDir = None
1545         # use overrided path defined in DSC file
1546         if self.MetaFile.Key in GlobalData.gOverrideDir:
1547             self.SourceOverrideDir = GlobalData.gOverrideDir[self.MetaFile.Key]
1548
1549         self.ToolChain = Toolchain
1550         self.BuildTarget = Target
1551         self.Arch = Arch
1552         self.ToolChainFamily = self.PlatformInfo.ToolChainFamily
1553         self.BuildRuleFamily = self.PlatformInfo.BuildRuleFamily
1554
1555         self.IsMakeFileCreated = False
1556         self.IsCodeFileCreated = False
1557
1558         self.BuildDatabase = self.Workspace.BuildDatabase
1559
1560         self._Module          = None
1561         self._Name            = None
1562         self._Guid            = None
1563         self._Version         = None
1564         self._ModuleType      = None
1565         self._ComponentType   = None
1566         self._PcdIsDriver     = None
1567         self._AutoGenVersion  = None
1568         self._LibraryFlag     = None
1569         self._CustomMakefile  = None
1570         self._Macro           = None
1571
1572         self._BuildDir        = None
1573         self._OutputDir       = None
1574         self._DebugDir        = None
1575         self._MakeFileDir     = None
1576
1577         self._IncludePathList = None
1578         self._AutoGenFileList = None
1579         self._UnicodeFileList = None
1580         self._SourceFileList  = None
1581         self._ObjectFileList  = None
1582         self._BinaryFileList  = None
1583
1584         self._DependentPackageList    = None
1585         self._DependentLibraryList    = None
1586         self._LibraryAutoGenList      = None
1587         self._DerivedPackageList      = None
1588         self._ModulePcdList           = None
1589         self._LibraryPcdList          = None
1590         self._GuidList                = None
1591         self._ProtocolList            = None
1592         self._PpiList                 = None
1593         self._DepexList               = None
1594         self._DepexExpressionList     = None
1595         self._BuildOption             = None
1596         self._BuildTargets            = None
1597         self._IntroBuildTargetList    = None
1598         self._FinalBuildTargetList    = None
1599         self._FileTypes               = None
1600         self._BuildRules              = None
1601
1602         return True
1603
1604     def __repr__(self):
1605         return "%s [%s]" % (self.MetaFile, self.Arch)
1606
1607     # Macros could be used in build_rule.txt (also Makefile)
1608     def _GetMacros(self):
1609         if self._Macro == None:
1610             self._Macro = sdict()
1611             self._Macro["WORKSPACE"             ] = self.WorkspaceDir
1612             self._Macro["MODULE_NAME"           ] = self.Name
1613             self._Macro["MODULE_GUID"           ] = self.Guid
1614             self._Macro["MODULE_VERSION"        ] = self.Version
1615             self._Macro["MODULE_TYPE"           ] = self.ModuleType
1616             self._Macro["MODULE_FILE"           ] = str(self.MetaFile)
1617             self._Macro["MODULE_FILE_BASE_NAME" ] = self.MetaFile.BaseName
1618             self._Macro["MODULE_RELATIVE_DIR"   ] = self.SourceDir
1619             self._Macro["MODULE_DIR"            ] = self.SourceDir
1620
1621             self._Macro["BASE_NAME"             ] = self.Name
1622
1623             self._Macro["ARCH"                  ] = self.Arch
1624             self._Macro["TOOLCHAIN"             ] = self.ToolChain
1625             self._Macro["TOOLCHAIN_TAG"         ] = self.ToolChain
1626             self._Macro["TARGET"                ] = self.BuildTarget
1627
1628             self._Macro["BUILD_DIR"             ] = self.PlatformInfo.BuildDir
1629             self._Macro["BIN_DIR"               ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)
1630             self._Macro["LIB_DIR"               ] = os.path.join(self.PlatformInfo.BuildDir, self.Arch)
1631             self._Macro["MODULE_BUILD_DIR"      ] = self.BuildDir
1632             self._Macro["OUTPUT_DIR"            ] = self.OutputDir
1633             self._Macro["DEBUG_DIR"             ] = self.DebugDir
1634         return self._Macro
1635
1636     ## Return the module build data object
1637     def _GetModule(self):
1638         if self._Module == None:
1639             self._Module = self.Workspace.BuildDatabase[self.MetaFile, self.Arch]
1640         return self._Module
1641
1642     ## Return the module name
1643     def _GetBaseName(self):
1644         return self.Module.BaseName
1645
1646     ## Return the module SourceOverridePath
1647     def _GetSourceOverridePath(self):
1648         return self.Module.SourceOverridePath
1649
1650     ## Return the module meta-file GUID
1651     def _GetGuid(self):
1652         return self.Module.Guid
1653
1654     ## Return the module version
1655     def _GetVersion(self):
1656         return self.Module.Version
1657
1658     ## Return the module type
1659     def _GetModuleType(self):
1660         return self.Module.ModuleType
1661
1662     ## Return the component type (for R8.x style of module)
1663     def _GetComponentType(self):
1664         return self.Module.ComponentType
1665
1666     ## Return the build type
1667     def _GetBuildType(self):
1668         return self.Module.BuildType
1669
1670     ## Return the PCD_IS_DRIVER setting
1671     def _GetPcdIsDriver(self):
1672         return self.Module.PcdIsDriver
1673
1674     ## Return the autogen version, i.e. module meta-file version
1675     def _GetAutoGenVersion(self):
1676         return self.Module.AutoGenVersion
1677
1678     ## Check if the module is library or not
1679     def _IsLibrary(self):
1680         if self._LibraryFlag == None:
1681             if self.Module.LibraryClass != None and self.Module.LibraryClass != []:
1682                 self._LibraryFlag = True
1683             else:
1684                 self._LibraryFlag = False
1685         return self._LibraryFlag
1686
1687     ## Return the directory to store intermediate files of the module
1688     def _GetBuildDir(self):
1689         if self._BuildDir == None:
1690             self._BuildDir = path.join(
1691                                     self.PlatformInfo.BuildDir,
1692                                     self.Arch,
1693                                     self.SourceDir,
1694                                     self.MetaFile.BaseName
1695                                     )
1696             CreateDirectory(self._BuildDir)
1697         return self._BuildDir
1698
1699     ## Return the directory to store the intermediate object files of the mdoule
1700     def _GetOutputDir(self):
1701         if self._OutputDir == None:
1702             self._OutputDir = path.join(self.BuildDir, "OUTPUT")
1703             CreateDirectory(self._OutputDir)
1704         return self._OutputDir
1705
1706     ## Return the directory to store auto-gened source files of the mdoule
1707     def _GetDebugDir(self):
1708         if self._DebugDir == None:
1709             self._DebugDir = path.join(self.BuildDir, "DEBUG")
1710             CreateDirectory(self._DebugDir)
1711         return self._DebugDir
1712
1713     ## Return the path of custom file
1714     def _GetCustomMakefile(self):
1715         if self._CustomMakefile == None:
1716             self._CustomMakefile = {}
1717             for Type in self.Module.CustomMakefile:
1718                 if Type in gMakeTypeMap:
1719                     MakeType = gMakeTypeMap[Type]
1720                 else:
1721                     MakeType = 'nmake'
1722                 if self.SourceOverrideDir != None:
1723                     File = os.path.join(self.SourceOverrideDir, self.Module.CustomMakefile[Type])
1724                     if not os.path.exists(File):
1725                         File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])
1726                 else:
1727                     File = os.path.join(self.SourceDir, self.Module.CustomMakefile[Type])
1728                 self._CustomMakefile[MakeType] = File
1729         return self._CustomMakefile
1730
1731     ## Return the directory of the makefile
1732     #
1733     #   @retval     string  The directory string of module's makefile
1734     #
1735     def _GetMakeFileDir(self):
1736         return self.BuildDir
1737
1738     ## Return build command string
1739     #
1740     #   @retval     string  Build command string
1741     #
1742     def _GetBuildCommand(self):
1743         return self.PlatformInfo.BuildCommand
1744
1745     ## Get object list of all packages the module and its dependent libraries belong to
1746     #
1747     #   @retval     list    The list of package object
1748     #
1749     def _GetDerivedPackageList(self):
1750         PackageList = []
1751         for M in [self.Module] + self.DependentLibraryList:
1752             for Package in M.Packages:
1753                 if Package in PackageList:
1754                     continue
1755                 PackageList.append(Package)
1756         return PackageList
1757
1758     ## Merge dependency expression
1759     #
1760     #   @retval     list    The token list of the dependency expression after parsed
1761     #
1762     def _GetDepexTokenList(self):
1763         if self._DepexList == None:
1764             self._DepexList = {}
1765             if self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:
1766                 return self._DepexList
1767
1768             self._DepexList[self.ModuleType] = []
1769
1770             for ModuleType in self._DepexList:
1771                 DepexList = self._DepexList[ModuleType]
1772                 #
1773                 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
1774                 #
1775                 for M in [self.Module] + self.DependentLibraryList:
1776                     Inherited = False
1777                     for D in M.Depex[self.Arch, ModuleType]:
1778                         if DepexList != []:
1779                             DepexList.append('AND')
1780                         DepexList.append('(')
1781                         DepexList.extend(D)
1782                         if DepexList[-1] == 'END':  # no need of a END at this time
1783                             DepexList.pop()
1784                         DepexList.append(')')
1785                         Inherited = True
1786                     if Inherited:
1787                         EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexList))
1788                     if 'BEFORE' in DepexList or 'AFTER' in DepexList:
1789                         break
1790                 if len(DepexList) > 0:
1791                     EdkLogger.verbose('')
1792         return self._DepexList
1793
1794     ## Merge dependency expression
1795     #
1796     #   @retval     list    The token list of the dependency expression after parsed
1797     #
1798     def _GetDepexExpressionTokenList(self):
1799         if self._DepexExpressionList == None:
1800             self._DepexExpressionList = {}
1801             if self.IsLibrary or TAB_DEPENDENCY_EXPRESSION_FILE in self.FileTypes:
1802                 return self._DepexExpressionList
1803
1804             self._DepexExpressionList[self.ModuleType] = ''
1805
1806             for ModuleType in self._DepexExpressionList:
1807                 DepexExpressionList = self._DepexExpressionList[ModuleType]
1808                 #
1809                 # Append depex from dependent libraries, if not "BEFORE", "AFTER" expresion
1810                 #
1811                 for M in [self.Module] + self.DependentLibraryList:
1812                     Inherited = False
1813                     for D in M.DepexExpression[self.Arch, ModuleType]:
1814                         if DepexExpressionList != '':
1815                             DepexExpressionList += ' AND '
1816                         DepexExpressionList += '('
1817                         DepexExpressionList += D
1818                         DepexExpressionList = DepexExpressionList.rstrip('END').strip()
1819                         DepexExpressionList += ')'
1820                         Inherited = True
1821                     if Inherited:
1822                         EdkLogger.verbose("DEPEX[%s] (+%s) = %s" % (self.Name, M.BaseName, DepexExpressionList))
1823                     if 'BEFORE' in DepexExpressionList or 'AFTER' in DepexExpressionList:
1824                         break
1825                 if len(DepexExpressionList) > 0:
1826                     EdkLogger.verbose('')
1827                 self._DepexExpressionList[ModuleType] = DepexExpressionList
1828         return self._DepexExpressionList
1829
1830     ## Return the list of specification version required for the module
1831     #
1832     #   @retval     list    The list of specification defined in module file
1833     #
1834     def _GetSpecification(self):
1835         return self.Module.Specification
1836
1837     ## Tool option for the module build
1838     #
1839     #   @param      PlatformInfo    The object of PlatformBuildInfo
1840     #   @retval     dict            The dict containing valid options
1841     #
1842     def _GetModuleBuildOption(self):
1843         if self._BuildOption == None:
1844             self._BuildOption = self.PlatformInfo.ApplyBuildOption(self.Module)
1845         return self._BuildOption
1846
1847     ## Return a list of files which can be built from source
1848     #
1849     #  What kind of files can be built is determined by build rules in
1850     #  $(WORKSPACE)/Conf/build_rule.txt and toolchain family.
1851     #
1852     def _GetSourceFileList(self):
1853         if self._SourceFileList == None:
1854             self._SourceFileList = []
1855             for F in self.Module.Sources:
1856                 # match tool chain
1857                 if F.TagName != "" and F.TagName != self.ToolChain:
1858                     EdkLogger.debug(EdkLogger.DEBUG_9, "The toolchain [%s] for processing file [%s] is found, "
1859                                     "but [%s] is needed" % (F.TagName, str(F), self.ToolChain))
1860                     continue
1861                 # match tool chain family
1862                 if F.ToolChainFamily != "" and F.ToolChainFamily != self.ToolChainFamily:
1863                     EdkLogger.debug(
1864                                 EdkLogger.DEBUG_0,
1865                                 "The file [%s] must be built by tools of [%s], " \
1866                                 "but current toolchain family is [%s]" \
1867                                     % (str(F), F.ToolChainFamily, self.ToolChainFamily))
1868                     continue
1869
1870                 # add the file path into search path list for file including
1871                 if F.Dir not in self.IncludePathList and self.AutoGenVersion >= 0x00010005:
1872                     self.IncludePathList.insert(0, F.Dir)
1873                 self._SourceFileList.append(F)
1874                 self._ApplyBuildRule(F, TAB_UNKNOWN_FILE)
1875         return self._SourceFileList
1876
1877     ## Return the list of unicode files
1878     def _GetUnicodeFileList(self):
1879         if self._UnicodeFileList == None:
1880             if TAB_UNICODE_FILE in self.FileTypes:
1881                 self._UnicodeFileList = self.FileTypes[TAB_UNICODE_FILE]
1882             else:
1883                 self._UnicodeFileList = []
1884         return self._UnicodeFileList
1885
1886     ## Return a list of files which can be built from binary
1887     #
1888     #  "Build" binary files are just to copy them to build directory.
1889     #
1890     #   @retval     list            The list of files which can be built later
1891     #
1892     def _GetBinaryFiles(self):
1893         if self._BinaryFileList == None:
1894             self._BinaryFileList = []
1895             for F in self.Module.Binaries:
1896                 if F.Target not in ['COMMON', '*'] and F.Target != self.BuildTarget:
1897                     continue
1898                 self._BinaryFileList.append(F)
1899                 self._ApplyBuildRule(F, F.Type)
1900         return self._BinaryFileList
1901
1902     def _GetBuildRules(self):
1903         if self._BuildRules == None:
1904             BuildRules = {}
1905             BuildRuleDatabase = self.PlatformInfo.BuildRule
1906             for Type in BuildRuleDatabase.FileTypeList:
1907                 #first try getting build rule by BuildRuleFamily
1908                 RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.BuildRuleFamily]
1909                 if not RuleObject:
1910                     # build type is always module type, but ...
1911                     if self.ModuleType != self.BuildType:
1912                         RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.BuildRuleFamily]
1913                 #second try getting build rule by ToolChainFamily
1914                 if not RuleObject:
1915                     RuleObject = BuildRuleDatabase[Type, self.BuildType, self.Arch, self.ToolChainFamily]
1916                     if not RuleObject:
1917                         # build type is always module type, but ...
1918                         if self.ModuleType != self.BuildType:
1919                             RuleObject = BuildRuleDatabase[Type, self.ModuleType, self.Arch, self.ToolChainFamily]
1920                 if not RuleObject:
1921                     continue
1922                 RuleObject = RuleObject.Instantiate(self.Macros)
1923                 BuildRules[Type] = RuleObject
1924                 for Ext in RuleObject.SourceFileExtList:
1925                     BuildRules[Ext] = RuleObject
1926             self._BuildRules = BuildRules
1927         return self._BuildRules
1928
1929     def _ApplyBuildRule(self, File, FileType):
1930         if self._BuildTargets == None:
1931             self._IntroBuildTargetList = set()
1932             self._FinalBuildTargetList = set()
1933             self._BuildTargets = {}
1934             self._FileTypes = {}
1935
1936         LastTarget = None
1937         RuleChain = []
1938         SourceList = [File]
1939         Index = 0
1940         while Index < len(SourceList):
1941             Source = SourceList[Index]
1942             Index = Index + 1
1943
1944             if Source != File:
1945                 CreateDirectory(Source.Dir)
1946
1947             if File.IsBinary and File == Source:
1948                 RuleObject = self.BuildRules[TAB_DEFAULT_BINARY_FILE]
1949             elif FileType in self.BuildRules:
1950                 RuleObject = self.BuildRules[FileType]
1951             elif Source.Ext in self.BuildRules:
1952                 RuleObject = self.BuildRules[Source.Ext]
1953             else:
1954                 # stop at no more rules
1955                 if LastTarget:
1956                     self._FinalBuildTargetList.add(LastTarget)
1957                 break
1958
1959             FileType = RuleObject.SourceFileType
1960             if FileType not in self._FileTypes:
1961                 self._FileTypes[FileType] = set()
1962             self._FileTypes[FileType].add(Source)
1963
1964             # stop at STATIC_LIBRARY for library
1965             if self.IsLibrary and FileType == TAB_STATIC_LIBRARY:
1966                 if LastTarget:
1967                     self._FinalBuildTargetList.add(LastTarget)
1968                 break
1969
1970             Target = RuleObject.Apply(Source)
1971             if not Target:
1972                 if LastTarget:
1973                     self._FinalBuildTargetList.add(LastTarget)
1974                 break
1975             elif not Target.Outputs:
1976                 # Only do build for target with outputs
1977                 self._FinalBuildTargetList.add(Target)
1978
1979             if FileType not in self._BuildTargets:
1980                 self._BuildTargets[FileType] = set()
1981             self._BuildTargets[FileType].add(Target)
1982
1983             if not Source.IsBinary and Source == File:
1984                 self._IntroBuildTargetList.add(Target)
1985
1986             # to avoid cyclic rule
1987             if FileType in RuleChain:
1988                 break
1989
1990             RuleChain.append(FileType)
1991             SourceList.extend(Target.Outputs)
1992             LastTarget = Target
1993             FileType = TAB_UNKNOWN_FILE
1994
1995     def _GetTargets(self):
1996         if self._BuildTargets == None:
1997             self._IntroBuildTargetList = set()
1998             self._FinalBuildTargetList = set()
1999             self._BuildTargets = {}
2000             self._FileTypes = {}
2001
2002         #TRICK: call _GetSourceFileList to apply build rule for binary files
2003         if self.SourceFileList:
2004             pass
2005
2006         #TRICK: call _GetBinaryFileList to apply build rule for binary files
2007         if self.BinaryFileList:
2008             pass
2009
2010         return self._BuildTargets
2011
2012     def _GetIntroTargetList(self):
2013         self._GetTargets()
2014         return self._IntroBuildTargetList
2015
2016     def _GetFinalTargetList(self):
2017         self._GetTargets()
2018         return self._FinalBuildTargetList
2019
2020     def _GetFileTypes(self):
2021         self._GetTargets()
2022         return self._FileTypes
2023
2024     ## Get the list of package object the module depends on
2025     #
2026     #   @retval     list    The package object list
2027     #
2028     def _GetDependentPackageList(self):
2029         return self.Module.Packages
2030
2031     ## Return the list of auto-generated code file
2032     #
2033     #   @retval     list        The list of auto-generated file
2034     #
2035     def _GetAutoGenFileList(self):
2036         UniStringAutoGenC = True
2037         UniStringBinBuffer = None
2038         if self.BuildType == 'UEFI_HII':
2039             UniStringBinBuffer = StringIO()
2040             UniStringAutoGenC = False
2041         if self._AutoGenFileList == None:
2042             self._AutoGenFileList = {}
2043             AutoGenC = TemplateString()
2044             AutoGenH = TemplateString()
2045             StringH = TemplateString()
2046             GenC.CreateCode(self, AutoGenC, AutoGenH, StringH, UniStringAutoGenC, UniStringBinBuffer)
2047             if str(AutoGenC) != "" and TAB_C_CODE_FILE in self.FileTypes:
2048                 AutoFile = PathClass(gAutoGenCodeFileName, self.DebugDir)
2049                 self._AutoGenFileList[AutoFile] = str(AutoGenC)
2050                 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
2051             if str(AutoGenH) != "":
2052                 AutoFile = PathClass(gAutoGenHeaderFileName, self.DebugDir)
2053                 self._AutoGenFileList[AutoFile] = str(AutoGenH)
2054                 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
2055             if str(StringH) != "":
2056                 AutoFile = PathClass(gAutoGenStringFileName % {"module_name":self.Name}, self.DebugDir)
2057                 self._AutoGenFileList[AutoFile] = str(StringH)
2058                 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
2059             if UniStringBinBuffer != None and UniStringBinBuffer.getvalue() != "":
2060                 AutoFile = PathClass(gAutoGenStringFormFileName % {"module_name":self.Name}, self.OutputDir)
2061                 self._AutoGenFileList[AutoFile] = UniStringBinBuffer.getvalue()
2062                 AutoFile.IsBinary = True
2063                 self._ApplyBuildRule(AutoFile, TAB_UNKNOWN_FILE)
2064             if UniStringBinBuffer != None:
2065                 UniStringBinBuffer.close()
2066         return self._AutoGenFileList
2067
2068     ## Return the list of library modules explicitly or implicityly used by this module
2069     def _GetLibraryList(self):
2070         if self._DependentLibraryList == None:
2071             # only merge library classes and PCD for non-library module
2072             if self.IsLibrary:
2073                 self._DependentLibraryList = []
2074             else:
2075                 if self.AutoGenVersion < 0x00010005:
2076                     self._DependentLibraryList = self.PlatformInfo.ResolveLibraryReference(self.Module)
2077                 else:
2078                     self._DependentLibraryList = self.PlatformInfo.ApplyLibraryInstance(self.Module)
2079         return self._DependentLibraryList
2080
2081     ## Get the list of PCDs from current module
2082     #
2083     #   @retval     list                    The list of PCD
2084     #
2085     def _GetModulePcdList(self):
2086         if self._ModulePcdList == None:
2087             # apply PCD settings from platform
2088             self._ModulePcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, self.Module.Pcds)
2089         return self._ModulePcdList
2090
2091     ## Get the list of PCDs from dependent libraries
2092     #
2093     #   @retval     list                    The list of PCD
2094     #
2095     def _GetLibraryPcdList(self):
2096         if self._LibraryPcdList == None:
2097             Pcds = {}
2098             if not self.IsLibrary:
2099                 # get PCDs from dependent libraries
2100                 for Library in self.DependentLibraryList:
2101                     for Key in Library.Pcds:
2102                         # skip duplicated PCDs
2103                         if Key in self.Module.Pcds or Key in Pcds:
2104                             continue
2105                         Pcds[Key] = copy.copy(Library.Pcds[Key])
2106                 # apply PCD settings from platform
2107                 self._LibraryPcdList = self.PlatformInfo.ApplyPcdSetting(self.Module, Pcds)
2108             else:
2109                 self._LibraryPcdList = []
2110         return self._LibraryPcdList
2111
2112     ## Get the GUID value mapping
2113     #
2114     #   @retval     dict    The mapping between GUID cname and its value
2115     #
2116     def _GetGuidList(self):
2117         if self._GuidList == None:
2118             self._GuidList = self.Module.Guids
2119             for Library in self.DependentLibraryList:
2120                 self._GuidList.update(Library.Guids)
2121         return self._GuidList
2122
2123     ## Get the protocol value mapping
2124     #
2125     #   @retval     dict    The mapping between protocol cname and its value
2126     #
2127     def _GetProtocolList(self):
2128         if self._ProtocolList == None:
2129             self._ProtocolList = self.Module.Protocols
2130             for Library in self.DependentLibraryList:
2131                 self._ProtocolList.update(Library.Protocols)
2132         return self._ProtocolList
2133
2134     ## Get the PPI value mapping
2135     #
2136     #   @retval     dict    The mapping between PPI cname and its value
2137     #
2138     def _GetPpiList(self):
2139         if self._PpiList == None:
2140             self._PpiList = self.Module.Ppis
2141             for Library in self.DependentLibraryList:
2142                 self._PpiList.update(Library.Ppis)
2143         return self._PpiList
2144
2145     ## Get the list of include search path
2146     #
2147     #   @retval     list                    The list path
2148     #
2149     def _GetIncludePathList(self):
2150         if self._IncludePathList == None:
2151             self._IncludePathList = []
2152             if self.AutoGenVersion < 0x00010005:
2153                 for Inc in self.Module.Includes:
2154                     if Inc not in self._IncludePathList:
2155                         self._IncludePathList.append(Inc)
2156                     # for r8 modules
2157                     Inc = path.join(Inc, self.Arch.capitalize())
2158                     if os.path.exists(Inc) and Inc not in self._IncludePathList:
2159                         self._IncludePathList.append(Inc)
2160                 # r8 module needs to put DEBUG_DIR at the end of search path and not to use SOURCE_DIR all the time
2161                 self._IncludePathList.append(self.DebugDir)
2162             else:
2163                 self._IncludePathList.append(self.MetaFile.Dir)
2164                 self._IncludePathList.append(self.DebugDir)
2165
2166             for Package in self.Module.Packages:
2167                 PackageDir = path.join(self.WorkspaceDir, Package.MetaFile.Dir)
2168                 if PackageDir not in self._IncludePathList:
2169                     self._IncludePathList.append(PackageDir)
2170                 for Inc in Package.Includes:
2171                     if Inc not in self._IncludePathList:
2172                         self._IncludePathList.append(str(Inc))
2173         return self._IncludePathList
2174
2175     ## Create makefile for the module and its dependent libraries
2176     #
2177     #   @param      CreateLibraryMakeFile   Flag indicating if or not the makefiles of
2178     #                                       dependent libraries will be created
2179     #
2180     def CreateMakeFile(self, CreateLibraryMakeFile=True):
2181         if self.IsMakeFileCreated:
2182             return
2183
2184         if not self.IsLibrary and CreateLibraryMakeFile:
2185             for LibraryAutoGen in self.LibraryAutoGenList:
2186                 LibraryAutoGen.CreateMakeFile()
2187
2188         if len(self.CustomMakefile) == 0:
2189             Makefile = GenMake.ModuleMakefile(self)
2190         else:
2191             Makefile = GenMake.CustomMakefile(self)
2192         if Makefile.Generate():
2193             EdkLogger.debug(EdkLogger.DEBUG_9, "Generated makefile for module %s [%s]" %
2194                             (self.Name, self.Arch))
2195         else:
2196             EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of makefile for module %s [%s]" %
2197                             (self.Name, self.Arch))
2198
2199         self.IsMakeFileCreated = True
2200
2201     ## Create autogen code for the module and its dependent libraries
2202     #
2203     #   @param      CreateLibraryCodeFile   Flag indicating if or not the code of
2204     #                                       dependent libraries will be created
2205     #
2206     def CreateCodeFile(self, CreateLibraryCodeFile=True):
2207         if self.IsCodeFileCreated:
2208             return
2209
2210         if not self.IsLibrary and CreateLibraryCodeFile:
2211             for LibraryAutoGen in self.LibraryAutoGenList:
2212                 LibraryAutoGen.CreateCodeFile()
2213
2214         AutoGenList = []
2215         IgoredAutoGenList = []
2216
2217         for File in self.AutoGenFileList:
2218             if GenC.Generate(File.Path, self.AutoGenFileList[File], File.IsBinary):
2219                 #Ignore R8 AutoGen.c
2220                 if self.AutoGenVersion < 0x00010005 and File.Name == 'AutoGen.c':
2221                         continue
2222
2223                 AutoGenList.append(str(File))
2224             else:
2225                 IgoredAutoGenList.append(str(File))
2226
2227         # Skip the following code for EDK I inf
2228         if self.AutoGenVersion < 0x00010005:
2229             return
2230
2231         for ModuleType in self.DepexList:
2232             if len(self.DepexList[ModuleType]) == 0:
2233                 continue
2234             Dpx = GenDepex.DependencyExpression(self.DepexList[ModuleType], ModuleType, True)
2235             DpxFile = gAutoGenDepexFileName % {"module_name" : self.Name}
2236
2237             if Dpx.Generate(path.join(self.OutputDir, DpxFile)):
2238                 AutoGenList.append(str(DpxFile))
2239             else:
2240                 IgoredAutoGenList.append(str(DpxFile))
2241
2242         if IgoredAutoGenList == []:
2243             EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] files for module %s [%s]" %
2244                             (" ".join(AutoGenList), self.Name, self.Arch))
2245         elif AutoGenList == []:
2246             EdkLogger.debug(EdkLogger.DEBUG_9, "Skipped the generation of [%s] files for module %s [%s]" %
2247                             (" ".join(IgoredAutoGenList), self.Name, self.Arch))
2248         else:
2249             EdkLogger.debug(EdkLogger.DEBUG_9, "Generated [%s] (skipped %s) files for module %s [%s]" %
2250                             (" ".join(AutoGenList), " ".join(IgoredAutoGenList), self.Name, self.Arch))
2251
2252         self.IsCodeFileCreated = True
2253         return AutoGenList
2254
2255     ## Summarize the ModuleAutoGen objects of all libraries used by this module
2256     def _GetLibraryAutoGenList(self):
2257         if self._LibraryAutoGenList == None:
2258             self._LibraryAutoGenList = []
2259             for Library in self.DependentLibraryList:
2260                 La = ModuleAutoGen(
2261                         self.Workspace,
2262                         Library.MetaFile,
2263                         self.BuildTarget,
2264                         self.ToolChain,
2265                         self.Arch,
2266                         self.PlatformInfo.MetaFile
2267                         )
2268                 if La not in self._LibraryAutoGenList:
2269                     self._LibraryAutoGenList.append(La)
2270                     for Lib in La.CodaTargetList:
2271                         self._ApplyBuildRule(Lib.Target, TAB_UNKNOWN_FILE)
2272         return self._LibraryAutoGenList
2273
2274     ## Return build command string
2275     #
2276     #   @retval     string  Build command string
2277     #
2278     def _GetBuildCommand(self):
2279         return self.PlatformInfo.BuildCommand
2280
2281
2282     Module          = property(_GetModule)
2283     Name            = property(_GetBaseName)
2284     Guid            = property(_GetGuid)
2285     Version         = property(_GetVersion)
2286     ModuleType      = property(_GetModuleType)
2287     ComponentType   = property(_GetComponentType)
2288     BuildType       = property(_GetBuildType)
2289     PcdIsDriver     = property(_GetPcdIsDriver)
2290     AutoGenVersion  = property(_GetAutoGenVersion)
2291     Macros          = property(_GetMacros)
2292     Specification   = property(_GetSpecification)
2293
2294     IsLibrary       = property(_IsLibrary)
2295
2296     BuildDir        = property(_GetBuildDir)
2297     OutputDir       = property(_GetOutputDir)
2298     DebugDir        = property(_GetDebugDir)
2299     MakeFileDir     = property(_GetMakeFileDir)
2300     CustomMakefile  = property(_GetCustomMakefile)
2301
2302     IncludePathList = property(_GetIncludePathList)
2303     AutoGenFileList = property(_GetAutoGenFileList)
2304     UnicodeFileList = property(_GetUnicodeFileList)
2305     SourceFileList  = property(_GetSourceFileList)
2306     BinaryFileList  = property(_GetBinaryFiles) # FileType : [File List]
2307     Targets         = property(_GetTargets)
2308     IntroTargetList = property(_GetIntroTargetList)
2309     CodaTargetList  = property(_GetFinalTargetList)
2310     FileTypes       = property(_GetFileTypes)
2311     BuildRules      = property(_GetBuildRules)
2312
2313     DependentPackageList    = property(_GetDependentPackageList)
2314     DependentLibraryList    = property(_GetLibraryList)
2315     LibraryAutoGenList      = property(_GetLibraryAutoGenList)
2316     DerivedPackageList      = property(_GetDerivedPackageList)
2317
2318     ModulePcdList           = property(_GetModulePcdList)
2319     LibraryPcdList          = property(_GetLibraryPcdList)
2320     GuidList                = property(_GetGuidList)
2321     ProtocolList            = property(_GetProtocolList)
2322     PpiList                 = property(_GetPpiList)
2323     DepexList               = property(_GetDepexTokenList)
2324     DepexExpressionList     = property(_GetDepexExpressionTokenList)
2325     BuildOption             = property(_GetModuleBuildOption)
2326     BuildCommand            = property(_GetBuildCommand)
2327
2328 # This acts like the main() function for the script, unless it is 'import'ed into another script.
2329 if __name__ == '__main__':
2330     pass
2331