BaseTools/Source/Python/AutoGen/GenC.py

   1 ## @file
   2 # Routines for generating AutoGen.h and AutoGen.c
   3 #
   4 # Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>
   5 # 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 string
  17
  18 from Common import EdkLogger
  19
  20 from Common.BuildToolError import *
  21 from Common.DataType import *
  22 from Common.Misc import *
  23 from Common.String import StringToArray
  24 from StrGather import *
  25 from GenPcdDb import CreatePcdDatabaseCode
  26
  27 ## PCD type string
  28 gItemTypeStringDatabase  = {
  29     TAB_PCDS_FEATURE_FLAG       :   'FixedAtBuild',
  30     TAB_PCDS_FIXED_AT_BUILD     :   'FixedAtBuild',
  31     TAB_PCDS_PATCHABLE_IN_MODULE:   'BinaryPatch',
  32     TAB_PCDS_DYNAMIC            :   '',
  33     TAB_PCDS_DYNAMIC_DEFAULT    :   '',
  34     TAB_PCDS_DYNAMIC_VPD        :   '',
  35     TAB_PCDS_DYNAMIC_HII        :   '',
  36     TAB_PCDS_DYNAMIC_EX         :   '',
  37     TAB_PCDS_DYNAMIC_EX_DEFAULT :   '',
  38     TAB_PCDS_DYNAMIC_EX_VPD     :   '',
  39     TAB_PCDS_DYNAMIC_EX_HII     :   '',
  40 }
  41
  42 ## Dynamic PCD types
  43 gDynamicPcd = [TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_DEFAULT, TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_HII]
  44
  45 ## Dynamic-ex PCD types
  46 gDynamicExPcd = [TAB_PCDS_DYNAMIC_EX, TAB_PCDS_DYNAMIC_EX_DEFAULT, TAB_PCDS_DYNAMIC_EX_VPD, TAB_PCDS_DYNAMIC_EX_HII]
  47
  48 ## Datum size
  49 gDatumSizeStringDatabase = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOLEAN','VOID*':'8'}
  50 gDatumSizeStringDatabaseH = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOL','VOID*':'PTR'}
  51 gDatumSizeStringDatabaseLib = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'Bool','VOID*':'Ptr'}
  52
  53 ## AutoGen File Header Templates
  54 gAutoGenHeaderString = TemplateString("""\
  55 /**
  56   DO NOT EDIT
  57   FILE auto-generated
  58   Module name:
  59     ${FileName}
  60   Abstract:       Auto-generated ${FileName} for building module or library.
  61 **/
  62 """)
  63
  64 gAutoGenHPrologueString = TemplateString("""
  65 #ifndef _${File}_${Guid}
  66 #define _${File}_${Guid}
  67
  68 """)
  69
  70 gAutoGenHCppPrologueString = """\
  71 #ifdef __cplusplus
  72 extern "C" {
  73 #endif
  74
  75 """
  76
  77 gAutoGenHEpilogueString = """
  78
  79 #ifdef __cplusplus
  80 }
  81 #endif
  82
  83 #endif
  84 """
  85
  86 ## PEI Core Entry Point Templates
  87 gPeiCoreEntryPointPrototype = TemplateString("""
  88 ${BEGIN}
  89 VOID
  90 EFIAPI
  91 ${Function} (
  92   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
  93   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,
  94   IN VOID                           *Context
  95   );
  96 ${END}
  97 """)
  98
  99 gPeiCoreEntryPointString = TemplateString("""
 100 ${BEGIN}
 101 VOID
 102 EFIAPI
 103 ProcessModuleEntryPointList (
 104   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,
 105   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,
 106   IN VOID                           *Context
 107   )
 108
 109 {
 110   ${Function} (SecCoreData, PpiList, Context);
 111 }
 112 ${END}
 113 """)
 114
 115
 116 ## DXE Core Entry Point Templates
 117 gDxeCoreEntryPointPrototype = TemplateString("""
 118 ${BEGIN}
 119 VOID
 120 EFIAPI
 121 ${Function} (
 122   IN VOID  *HobStart
 123   );
 124 ${END}
 125 """)
 126
 127 gDxeCoreEntryPointString = TemplateString("""
 128 ${BEGIN}
 129 VOID
 130 EFIAPI
 131 ProcessModuleEntryPointList (
 132   IN VOID  *HobStart
 133   )
 134
 135 {
 136   ${Function} (HobStart);
 137 }
 138 ${END}
 139 """)
 140
 141 ## PEIM Entry Point Templates
 142 gPeimEntryPointPrototype = TemplateString("""
 143 ${BEGIN}
 144 EFI_STATUS
 145 EFIAPI
 146 ${Function} (
 147   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 148   IN CONST EFI_PEI_SERVICES     **PeiServices
 149   );
 150 ${END}
 151 """)
 152
 153 gPeimEntryPointString = [
 154 TemplateString("""
 155 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 156
 157 EFI_STATUS
 158 EFIAPI
 159 ProcessModuleEntryPointList (
 160   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 161   IN CONST EFI_PEI_SERVICES     **PeiServices
 162   )
 163
 164 {
 165   return EFI_SUCCESS;
 166 }
 167 """),
 168 TemplateString("""
 169 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 170 ${BEGIN}
 171 EFI_STATUS
 172 EFIAPI
 173 ProcessModuleEntryPointList (
 174   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 175   IN CONST EFI_PEI_SERVICES     **PeiServices
 176   )
 177
 178 {
 179   return ${Function} (FileHandle, PeiServices);
 180 }
 181 ${END}
 182 """),
 183 TemplateString("""
 184 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = ${PiSpecVersion};
 185
 186 EFI_STATUS
 187 EFIAPI
 188 ProcessModuleEntryPointList (
 189   IN       EFI_PEI_FILE_HANDLE  FileHandle,
 190   IN CONST EFI_PEI_SERVICES     **PeiServices
 191   )
 192
 193 {
 194   EFI_STATUS  Status;
 195   EFI_STATUS  CombinedStatus;
 196
 197   CombinedStatus = EFI_LOAD_ERROR;
 198 ${BEGIN}
 199   Status = ${Function} (FileHandle, PeiServices);
 200   if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {
 201     CombinedStatus = Status;
 202   }
 203 ${END}
 204   return CombinedStatus;
 205 }
 206 """)
 207 ]
 208
 209 ## SMM_CORE Entry Point Templates
 210 gSmmCoreEntryPointPrototype = TemplateString("""
 211 ${BEGIN}
 212 EFI_STATUS
 213 EFIAPI
 214 ${Function} (
 215   IN EFI_HANDLE         ImageHandle,
 216   IN EFI_SYSTEM_TABLE   *SystemTable
 217   );
 218 ${END}
 219 """)
 220
 221 gSmmCoreEntryPointString = TemplateString("""
 222 ${BEGIN}
 223 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 224 const UINT32 _gDxeRevision = ${PiSpecVersion};
 225
 226 EFI_STATUS
 227 EFIAPI
 228 ProcessModuleEntryPointList (
 229   IN EFI_HANDLE         ImageHandle,
 230   IN EFI_SYSTEM_TABLE   *SystemTable
 231   )
 232 {
 233   return ${Function} (ImageHandle, SystemTable);
 234 }
 235 ${END}
 236 """)
 237
 238 ## DXE SMM Entry Point Templates
 239 gDxeSmmEntryPointPrototype = TemplateString("""
 240 ${BEGIN}
 241 EFI_STATUS
 242 EFIAPI
 243 ${Function} (
 244   IN EFI_HANDLE        ImageHandle,
 245   IN EFI_SYSTEM_TABLE  *SystemTable
 246   );
 247 ${END}
 248 """)
 249
 250 gDxeSmmEntryPointString = [
 251 TemplateString("""
 252 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 253 const UINT32 _gDxeRevision = ${PiSpecVersion};
 254
 255 EFI_STATUS
 256 EFIAPI
 257 ProcessModuleEntryPointList (
 258   IN EFI_HANDLE        ImageHandle,
 259   IN EFI_SYSTEM_TABLE  *SystemTable
 260   )
 261
 262 {
 263   return EFI_SUCCESS;
 264 }
 265 """),
 266 TemplateString("""
 267 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 268 const UINT32 _gDxeRevision = ${PiSpecVersion};
 269
 270 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 271 static EFI_STATUS  mDriverEntryPointStatus;
 272
 273 VOID
 274 EFIAPI
 275 ExitDriver (
 276   IN EFI_STATUS  Status
 277   )
 278 {
 279   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 280     mDriverEntryPointStatus = Status;
 281   }
 282   LongJump (&mJumpContext, (UINTN)-1);
 283   ASSERT (FALSE);
 284 }
 285
 286 EFI_STATUS
 287 EFIAPI
 288 ProcessModuleEntryPointList (
 289   IN EFI_HANDLE        ImageHandle,
 290   IN EFI_SYSTEM_TABLE  *SystemTable
 291   )
 292 {
 293   mDriverEntryPointStatus = EFI_LOAD_ERROR;
 294
 295 ${BEGIN}
 296   if (SetJump (&mJumpContext) == 0) {
 297     ExitDriver (${Function} (ImageHandle, SystemTable));
 298     ASSERT (FALSE);
 299   }
 300 ${END}
 301
 302   return mDriverEntryPointStatus;
 303 }
 304 """)
 305 ]
 306
 307 ## UEFI Driver Entry Point Templates
 308 gUefiDriverEntryPointPrototype = TemplateString("""
 309 ${BEGIN}
 310 EFI_STATUS
 311 EFIAPI
 312 ${Function} (
 313   IN EFI_HANDLE        ImageHandle,
 314   IN EFI_SYSTEM_TABLE  *SystemTable
 315   );
 316 ${END}
 317 """)
 318
 319 gUefiDriverEntryPointString = [
 320 TemplateString("""
 321 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 322 const UINT32 _gDxeRevision = ${PiSpecVersion};
 323
 324 EFI_STATUS
 325 EFIAPI
 326 ProcessModuleEntryPointList (
 327   IN EFI_HANDLE        ImageHandle,
 328   IN EFI_SYSTEM_TABLE  *SystemTable
 329   )
 330 {
 331   return EFI_SUCCESS;
 332 }
 333 """),
 334 TemplateString("""
 335 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 336 const UINT32 _gDxeRevision = ${PiSpecVersion};
 337
 338 ${BEGIN}
 339 EFI_STATUS
 340 EFIAPI
 341 ProcessModuleEntryPointList (
 342   IN EFI_HANDLE        ImageHandle,
 343   IN EFI_SYSTEM_TABLE  *SystemTable
 344   )
 345
 346 {
 347   return ${Function} (ImageHandle, SystemTable);
 348 }
 349 ${END}
 350 VOID
 351 EFIAPI
 352 ExitDriver (
 353   IN EFI_STATUS  Status
 354   )
 355 {
 356   if (EFI_ERROR (Status)) {
 357     ProcessLibraryDestructorList (gImageHandle, gST);
 358   }
 359   gBS->Exit (gImageHandle, Status, 0, NULL);
 360 }
 361 """),
 362 TemplateString("""
 363 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 364 const UINT32 _gDxeRevision = ${PiSpecVersion};
 365
 366 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 367 static EFI_STATUS  mDriverEntryPointStatus;
 368
 369 EFI_STATUS
 370 EFIAPI
 371 ProcessModuleEntryPointList (
 372   IN EFI_HANDLE        ImageHandle,
 373   IN EFI_SYSTEM_TABLE  *SystemTable
 374   )
 375 {
 376   mDriverEntryPointStatus = EFI_LOAD_ERROR;
 377   ${BEGIN}
 378   if (SetJump (&mJumpContext) == 0) {
 379     ExitDriver (${Function} (ImageHandle, SystemTable));
 380     ASSERT (FALSE);
 381   }
 382   ${END}
 383   return mDriverEntryPointStatus;
 384 }
 385
 386 VOID
 387 EFIAPI
 388 ExitDriver (
 389   IN EFI_STATUS  Status
 390   )
 391 {
 392   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 393     mDriverEntryPointStatus = Status;
 394   }
 395   LongJump (&mJumpContext, (UINTN)-1);
 396   ASSERT (FALSE);
 397 }
 398 """)
 399 ]
 400
 401
 402 ## UEFI Application Entry Point Templates
 403 gUefiApplicationEntryPointPrototype = TemplateString("""
 404 ${BEGIN}
 405 EFI_STATUS
 406 EFIAPI
 407 ${Function} (
 408   IN EFI_HANDLE        ImageHandle,
 409   IN EFI_SYSTEM_TABLE  *SystemTable
 410   );
 411 ${END}
 412 """)
 413
 414 gUefiApplicationEntryPointString = [
 415 TemplateString("""
 416 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 417
 418 EFI_STATUS
 419 EFIAPI
 420 ProcessModuleEntryPointList (
 421   IN EFI_HANDLE        ImageHandle,
 422   IN EFI_SYSTEM_TABLE  *SystemTable
 423   )
 424 {
 425   return EFI_SUCCESS;
 426 }
 427 """),
 428 TemplateString("""
 429 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 430
 431 ${BEGIN}
 432 EFI_STATUS
 433 EFIAPI
 434 ProcessModuleEntryPointList (
 435   IN EFI_HANDLE        ImageHandle,
 436   IN EFI_SYSTEM_TABLE  *SystemTable
 437   )
 438
 439 {
 440   return ${Function} (ImageHandle, SystemTable);
 441 }
 442 ${END}
 443 VOID
 444 EFIAPI
 445 ExitDriver (
 446   IN EFI_STATUS  Status
 447   )
 448 {
 449   if (EFI_ERROR (Status)) {
 450     ProcessLibraryDestructorList (gImageHandle, gST);
 451   }
 452   gBS->Exit (gImageHandle, Status, 0, NULL);
 453 }
 454 """),
 455 TemplateString("""
 456 const UINT32 _gUefiDriverRevision = ${UefiSpecVersion};
 457
 458 EFI_STATUS
 459 EFIAPI
 460 ProcessModuleEntryPointList (
 461   IN EFI_HANDLE        ImageHandle,
 462   IN EFI_SYSTEM_TABLE  *SystemTable
 463   )
 464
 465 {
 466   ${BEGIN}
 467   if (SetJump (&mJumpContext) == 0) {
 468     ExitDriver (${Function} (ImageHandle, SystemTable));
 469     ASSERT (FALSE);
 470   }
 471   ${END}
 472   return mDriverEntryPointStatus;
 473 }
 474
 475 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;
 476 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;
 477
 478 VOID
 479 EFIAPI
 480 ExitDriver (
 481   IN EFI_STATUS  Status
 482   )
 483 {
 484   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {
 485     mDriverEntryPointStatus = Status;
 486   }
 487   LongJump (&mJumpContext, (UINTN)-1);
 488   ASSERT (FALSE);
 489 }
 490 """)
 491 ]
 492
 493 ## UEFI Unload Image Templates
 494 gUefiUnloadImagePrototype = TemplateString("""
 495 ${BEGIN}
 496 EFI_STATUS
 497 EFIAPI
 498 ${Function} (
 499   IN EFI_HANDLE        ImageHandle
 500   );
 501 ${END}
 502 """)
 503
 504 gUefiUnloadImageString = [
 505 TemplateString("""
 506 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 507
 508 EFI_STATUS
 509 EFIAPI
 510 ProcessModuleUnloadList (
 511   IN EFI_HANDLE        ImageHandle
 512   )
 513 {
 514   return EFI_SUCCESS;
 515 }
 516 """),
 517 TemplateString("""
 518 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 519
 520 ${BEGIN}
 521 EFI_STATUS
 522 EFIAPI
 523 ProcessModuleUnloadList (
 524   IN EFI_HANDLE        ImageHandle
 525   )
 526 {
 527   return ${Function} (ImageHandle);
 528 }
 529 ${END}
 530 """),
 531 TemplateString("""
 532 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};
 533
 534 EFI_STATUS
 535 EFIAPI
 536 ProcessModuleUnloadList (
 537   IN EFI_HANDLE        ImageHandle
 538   )
 539 {
 540   EFI_STATUS  Status;
 541
 542   Status = EFI_SUCCESS;
 543 ${BEGIN}
 544   if (EFI_ERROR (Status)) {
 545     ${Function} (ImageHandle);
 546   } else {
 547     Status = ${Function} (ImageHandle);
 548   }
 549 ${END}
 550   return Status;
 551 }
 552 """)
 553 ]
 554
 555 gLibraryStructorPrototype = {
 556 'BASE'  : TemplateString("""${BEGIN}
 557 RETURN_STATUS
 558 EFIAPI
 559 ${Function} (
 560   VOID
 561   );${END}
 562 """),
 563
 564 'PEI'   : TemplateString("""${BEGIN}
 565 EFI_STATUS
 566 EFIAPI
 567 ${Function} (
 568   IN       EFI_PEI_FILE_HANDLE       FileHandle,
 569   IN CONST EFI_PEI_SERVICES          **PeiServices
 570   );${END}
 571 """),
 572
 573 'DXE'   : TemplateString("""${BEGIN}
 574 EFI_STATUS
 575 EFIAPI
 576 ${Function} (
 577   IN EFI_HANDLE        ImageHandle,
 578   IN EFI_SYSTEM_TABLE  *SystemTable
 579   );${END}
 580 """),
 581 }
 582
 583 gLibraryStructorCall = {
 584 'BASE'  : TemplateString("""${BEGIN}
 585   Status = ${Function} ();
 586   ASSERT_EFI_ERROR (Status);${END}
 587 """),
 588
 589 'PEI'   : TemplateString("""${BEGIN}
 590   Status = ${Function} (FileHandle, PeiServices);
 591   ASSERT_EFI_ERROR (Status);${END}
 592 """),
 593
 594 'DXE'   : TemplateString("""${BEGIN}
 595   Status = ${Function} (ImageHandle, SystemTable);
 596   ASSERT_EFI_ERROR (Status);${END}
 597 """),
 598 }
 599
 600 ## Library Constructor and Destructor Templates
 601 gLibraryString = {
 602 'BASE'  :   TemplateString("""
 603 ${BEGIN}${FunctionPrototype}${END}
 604
 605 VOID
 606 EFIAPI
 607 ProcessLibrary${Type}List (
 608   VOID
 609   )
 610 {
 611 ${BEGIN}  EFI_STATUS  Status;
 612 ${FunctionCall}${END}
 613 }
 614 """),
 615
 616 'PEI'   :   TemplateString("""
 617 ${BEGIN}${FunctionPrototype}${END}
 618
 619 VOID
 620 EFIAPI
 621 ProcessLibrary${Type}List (
 622   IN       EFI_PEI_FILE_HANDLE       FileHandle,
 623   IN CONST EFI_PEI_SERVICES          **PeiServices
 624   )
 625 {
 626 ${BEGIN}  EFI_STATUS  Status;
 627 ${FunctionCall}${END}
 628 }
 629 """),
 630
 631 'DXE'   :   TemplateString("""
 632 ${BEGIN}${FunctionPrototype}${END}
 633
 634 VOID
 635 EFIAPI
 636 ProcessLibrary${Type}List (
 637   IN EFI_HANDLE        ImageHandle,
 638   IN EFI_SYSTEM_TABLE  *SystemTable
 639   )
 640 {
 641 ${BEGIN}  EFI_STATUS  Status;
 642 ${FunctionCall}${END}
 643 }
 644 """),
 645 }
 646
 647 gBasicHeaderFile = "Base.h"
 648
 649 gModuleTypeHeaderFile = {
 650     "BASE"              :   [gBasicHeaderFile],
 651     "SEC"               :   ["PiPei.h", "Library/DebugLib.h"],
 652     "PEI_CORE"          :   ["PiPei.h", "Library/DebugLib.h", "Library/PeiCoreEntryPoint.h"],
 653     "PEIM"              :   ["PiPei.h", "Library/DebugLib.h", "Library/PeimEntryPoint.h"],
 654     "DXE_CORE"          :   ["PiDxe.h", "Library/DebugLib.h", "Library/DxeCoreEntryPoint.h"],
 655     "DXE_DRIVER"        :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 656     "DXE_SMM_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 657     "DXE_RUNTIME_DRIVER":   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 658     "DXE_SAL_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 659     "UEFI_DRIVER"       :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiDriverEntryPoint.h"],
 660     "UEFI_APPLICATION"  :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h", "Library/UefiApplicationEntryPoint.h"],
 661     "SMM_CORE"          :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiDriverEntryPoint.h"],
 662     "USER_DEFINED"      :   [gBasicHeaderFile]
 663 }
 664
 665 ## Autogen internal worker macro to define DynamicEx PCD name includes both the TokenSpaceGuidName
 666 #  the TokenName and Guid comparison to avoid define name collisions.
 667 #
 668 #   @param      Info        The ModuleAutoGen object
 669 #   @param      AutoGenH    The TemplateString object for header file
 670 #
 671 #
 672 def DynExPcdTokenNumberMapping(Info, AutoGenH):
 673     ExTokenCNameList = []
 674     PcdExList        = []
 675     if Info.IsLibrary:
 676         PcdList = Info.LibraryPcdList
 677     else:
 678         PcdList = Info.ModulePcdList
 679     for Pcd in PcdList:
 680         if Pcd.Type in gDynamicExPcd:
 681             ExTokenCNameList.append(Pcd.TokenCName)
 682             PcdExList.append(Pcd)
 683     if len(ExTokenCNameList) == 0:
 684         return
 685     AutoGenH.Append('\n#define COMPAREGUID(Guid1, Guid2) (BOOLEAN)(*(CONST UINT64*)Guid1 == *(CONST UINT64*)Guid2 && *((CONST UINT64*)Guid1 + 1) == *((CONST UINT64*)Guid2 + 1))\n')
 686     # AutoGen for each PCD listed in a [PcdEx] section of a Module/Lib INF file.
 687     # Auto generate a macro for each TokenName that takes a Guid pointer as a parameter.
 688     # Use the Guid pointer to see if it matches any of the token space GUIDs.
 689     TokenCNameList = []
 690     for TokenCName in ExTokenCNameList:
 691         if TokenCName in TokenCNameList:
 692             continue
 693         Index = 0
 694         Count = ExTokenCNameList.count(TokenCName)
 695         for Pcd in PcdExList:
 696             if Pcd.TokenCName == TokenCName:
 697                 Index = Index + 1
 698                 if Index == 1:
 699                     AutoGenH.Append('\n#define __PCD_%s_ADDR_CMP(GuidPtr)  (' % (Pcd.TokenCName))
 700                     AutoGenH.Append('\\\n  (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:'
 701                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 702                 else:
 703                     AutoGenH.Append('\\\n  (GuidPtr == &%s) ? _PCD_TOKEN_%s_%s:'
 704                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 705                 if Index == Count:
 706                     AutoGenH.Append('0 \\\n  )\n')
 707                 TokenCNameList.append(TokenCName)
 708
 709     TokenCNameList = []
 710     for TokenCName in ExTokenCNameList:
 711         if TokenCName in TokenCNameList:
 712             continue
 713         Index = 0
 714         Count = ExTokenCNameList.count(TokenCName)
 715         for Pcd in PcdExList:
 716             if Pcd.Type in gDynamicExPcd and Pcd.TokenCName == TokenCName:
 717                 Index = Index + 1
 718                 if Index == 1:
 719                     AutoGenH.Append('\n#define __PCD_%s_VAL_CMP(GuidPtr)  (' % (Pcd.TokenCName))
 720                     AutoGenH.Append('\\\n  COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:'
 721                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 722                 else:
 723                     AutoGenH.Append('\\\n  COMPAREGUID (GuidPtr, &%s) ? _PCD_TOKEN_%s_%s:'
 724                                     % (Pcd.TokenSpaceGuidCName, Pcd.TokenSpaceGuidCName, Pcd.TokenCName))
 725                 if Index == Count:
 726                     AutoGenH.Append('0 \\\n  )\n')
 727                     # Autogen internal worker macro to compare GUIDs.  Guid1 is a pointer to a GUID.
 728                     # Guid2 is a C name for a GUID. Compare pointers first because optimizing compiler
 729                     # can do this at build time on CONST GUID pointers and optimize away call to COMPAREGUID().
 730                     #  COMPAREGUID() will only be used if the Guid passed in is local to the module.
 731                     AutoGenH.Append('#define _PCD_TOKEN_EX_%s(GuidPtr)   __PCD_%s_ADDR_CMP(GuidPtr) ? __PCD_%s_ADDR_CMP(GuidPtr) : __PCD_%s_VAL_CMP(GuidPtr)  \n'
 732                                     % (Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName, Pcd.TokenCName))
 733                 TokenCNameList.append(TokenCName)
 734
 735 ## Create code for module PCDs
 736 #
 737 #   @param      Info        The ModuleAutoGen object
 738 #   @param      AutoGenC    The TemplateString object for C code
 739 #   @param      AutoGenH    The TemplateString object for header file
 740 #   @param      Pcd         The PCD object
 741 #
 742 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):
 743     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[Pcd.TokenSpaceGuidCName]
 744     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
 745     #
 746     # Write PCDs
 747     #
 748     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName
 749     if Pcd.Type in gDynamicExPcd:
 750         TokenNumber = int(Pcd.TokenValue, 0)
 751         # Add TokenSpaceGuidValue value to PcdTokenName to discriminate the DynamicEx PCDs with
 752         # different Guids but same TokenCName
 753         PcdExTokenName = '_PCD_TOKEN_' + Pcd.TokenSpaceGuidCName + '_' + Pcd.TokenCName
 754         AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))
 755     else:
 756         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
 757             # If one of the Source built modules listed in the DSC is not listed in FDF modules,
 758             # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
 759             # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
 760             # report warning message notify the PI that they are attempting to build a module
 761             # that must be included in a flash image in order to be functional. These Dynamic PCD
 762             # will not be added into the Database unless it is used by other modules that are
 763             # included in the FDF file.
 764             # In this case, just assign an invalid token number to make it pass build.
 765             if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
 766                 TokenNumber = 0
 767             else:
 768                 EdkLogger.error("build", AUTOGEN_ERROR,
 769                                 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 770                                 ExtraData="[%s]" % str(Info))
 771         else:
 772             TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
 773         AutoGenH.Append('\n#define %s  %dU\n' % (PcdTokenName, TokenNumber))
 774
 775     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "." + Pcd.TokenSpaceGuidCName)
 776     if Pcd.Type not in gItemTypeStringDatabase:
 777         EdkLogger.error("build", AUTOGEN_ERROR,
 778                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 779                         ExtraData="[%s]" % str(Info))
 780     if Pcd.DatumType not in gDatumSizeStringDatabase:
 781         EdkLogger.error("build", AUTOGEN_ERROR,
 782                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 783                         ExtraData="[%s]" % str(Info))
 784
 785     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]
 786     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]
 787     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 788     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName
 789
 790     PcdExCNameList  = []
 791     if Pcd.Type in gDynamicExPcd:
 792         if Info.IsLibrary:
 793             PcdList = Info.LibraryPcdList
 794         else:
 795             PcdList = Info.ModulePcdList
 796         for PcdModule in PcdList:
 797             if PcdModule.Type in gDynamicExPcd:
 798                 PcdExCNameList.append(PcdModule.TokenCName)
 799         # Be compatible with the current code which using PcdToken and PcdGet/Set for DynamicEx Pcd.
 800         # If only PcdToken and PcdGet/Set used in all Pcds with different CName, it should succeed to build.
 801         # If PcdToken and PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
 802         if PcdExCNameList.count(Pcd.TokenCName) > 1:
 803             AutoGenH.Append('// Disabled the macros, as PcdToken and PcdGet/Set are not allowed in the case that more than one DynamicEx Pcds are different Guids but same CName.\n')
 804             AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
 805             AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 806             if Pcd.DatumType == 'VOID*':
 807                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 808             else:
 809                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 810         else:
 811             AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
 812             AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 813             if Pcd.DatumType == 'VOID*':
 814                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 815             else:
 816                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
 817     elif Pcd.Type in gDynamicPcd:
 818         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
 819         if Pcd.DatumType == 'VOID*':
 820             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
 821         else:
 822             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
 823     else:
 824         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName
 825         Const = 'const'
 826         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 827             Const = ''
 828         Type = ''
 829         Array = ''
 830         Value = Pcd.DefaultValue
 831         Unicode = False
 832         ValueNumber = 0
 833
 834         if Pcd.DatumType == 'BOOLEAN':
 835             BoolValue = Value.upper()
 836             if BoolValue == 'TRUE' or BoolValue == '1':
 837                 Value = '1U'
 838             elif BoolValue == 'FALSE' or BoolValue == '0':
 839                 Value = '0U'
 840
 841         if Pcd.DatumType in ['UINT64', 'UINT32', 'UINT16', 'UINT8']:
 842             try:
 843                 if Value.upper().startswith('0X'):
 844                     ValueNumber = int (Value, 16)
 845                 else:
 846                     ValueNumber = int (Value)
 847             except:
 848                 EdkLogger.error("build", AUTOGEN_ERROR,
 849                                 "PCD value is not valid dec or hex number for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 850                                 ExtraData="[%s]" % str(Info))
 851             if Pcd.DatumType == 'UINT64':
 852                 if ValueNumber < 0:
 853                     EdkLogger.error("build", AUTOGEN_ERROR,
 854                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 855                                     ExtraData="[%s]" % str(Info))
 856                 elif ValueNumber >= 0x10000000000000000:
 857                     EdkLogger.error("build", AUTOGEN_ERROR,
 858                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 859                                     ExtraData="[%s]" % str(Info))
 860                 if not Value.endswith('ULL'):
 861                     Value += 'ULL'
 862             elif Pcd.DatumType == 'UINT32':
 863                 if ValueNumber < 0:
 864                     EdkLogger.error("build", AUTOGEN_ERROR,
 865                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 866                                     ExtraData="[%s]" % str(Info))
 867                 elif ValueNumber >= 0x100000000:
 868                     EdkLogger.error("build", AUTOGEN_ERROR,
 869                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 870                                     ExtraData="[%s]" % str(Info))
 871                 if not Value.endswith('U'):
 872                     Value += 'U'
 873             elif Pcd.DatumType == 'UINT16':
 874                 if ValueNumber < 0:
 875                     EdkLogger.error("build", AUTOGEN_ERROR,
 876                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 877                                     ExtraData="[%s]" % str(Info))
 878                 elif ValueNumber >= 0x10000:
 879                     EdkLogger.error("build", AUTOGEN_ERROR,
 880                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 881                                     ExtraData="[%s]" % str(Info))
 882                 if not Value.endswith('U'):
 883                     Value += 'U'
 884             elif Pcd.DatumType == 'UINT8':
 885                 if ValueNumber < 0:
 886                     EdkLogger.error("build", AUTOGEN_ERROR,
 887                                     "PCD can't be set to negative value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 888                                     ExtraData="[%s]" % str(Info))
 889                 elif ValueNumber >= 0x100:
 890                     EdkLogger.error("build", AUTOGEN_ERROR,
 891                                     "Too large PCD value for datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 892                                     ExtraData="[%s]" % str(Info))
 893                 if not Value.endswith('U'):
 894                     Value += 'U'
 895         if Pcd.DatumType == 'VOID*':
 896             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':
 897                 EdkLogger.error("build", AUTOGEN_ERROR,
 898                                 "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 899                                 ExtraData="[%s]" % str(Info))
 900
 901             ArraySize = int(Pcd.MaxDatumSize, 0)
 902             if Value[0] == '{':
 903                 Type = '(VOID *)'
 904             else:
 905                 if Value[0] == 'L':
 906                     Unicode = True
 907                 Value = Value.lstrip('L')   #.strip('"')
 908                 Value = eval(Value)         # translate escape character
 909                 NewValue = '{'
 910                 for Index in range(0,len(Value)):
 911                     if Unicode:
 912                         NewValue = NewValue + str(ord(Value[Index]) % 0x10000) + ', '
 913                     else:
 914                         NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '
 915                 if Unicode:
 916                     ArraySize = ArraySize / 2;
 917
 918                 if ArraySize < (len(Value) + 1):
 919                     EdkLogger.error("build", AUTOGEN_ERROR,
 920                                     "The maximum size of VOID* type PCD '%s.%s' is less than its actual size occupied." % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
 921                                     ExtraData="[%s]" % str(Info))
 922                 Value = NewValue + '0 }'
 923             Array = '[%d]' % ArraySize
 924         #
 925         # skip casting for fixed at build since it breaks ARM assembly.
 926         # Long term we need PCD macros that work in assembly
 927         #
 928         elif Pcd.Type != TAB_PCDS_FIXED_AT_BUILD:
 929             Value = "((%s)%s)" % (Pcd.DatumType, Value)
 930
 931         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 932             PcdValueName = '_PCD_PATCHABLE_VALUE_' + Pcd.TokenCName
 933         else:
 934             PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName
 935
 936         if Pcd.DatumType == 'VOID*':
 937             #
 938             # For unicode, UINT16 array will be generated, so the alignment of unicode is guaranteed.
 939             #
 940             if Unicode:
 941                 AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))
 942                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
 943                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT16 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
 944                 AutoGenH.Append('extern %s UINT16 %s%s;\n' %(Const, PcdVariableName, Array))
 945                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
 946             else:
 947                 AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))
 948                 AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))
 949                 AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))
 950                 AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))
 951                 AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))
 952         elif Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 953             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
 954             AutoGenC.Append('volatile %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
 955             AutoGenH.Append('extern volatile %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
 956             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
 957         else:
 958             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))
 959             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))
 960             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))
 961             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))
 962
 963         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:
 964             if Pcd.DatumType == 'VOID*':
 965                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtr(_gPcd_BinaryPatch_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName))
 966             else:
 967                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
 968         else:
 969             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
 970
 971 ## Create code for library module PCDs
 972 #
 973 #   @param      Info        The ModuleAutoGen object
 974 #   @param      AutoGenC    The TemplateString object for C code
 975 #   @param      AutoGenH    The TemplateString object for header file
 976 #   @param      Pcd         The PCD object
 977 #
 978 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):
 979     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber
 980     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName
 981     TokenCName  = Pcd.TokenCName
 982     PcdTokenName = '_PCD_TOKEN_' + TokenCName
 983     #
 984     # Write PCDs
 985     #
 986     if Pcd.Type in gDynamicExPcd:
 987         TokenNumber = int(Pcd.TokenValue, 0)
 988     else:
 989         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:
 990             # If one of the Source built modules listed in the DSC is not listed in FDF modules,
 991             # and the INF lists a PCD can only use the PcdsDynamic access method (it is only
 992             # listed in the DEC file that declares the PCD as PcdsDynamic), then build tool will
 993             # report warning message notify the PI that they are attempting to build a module
 994             # that must be included in a flash image in order to be functional. These Dynamic PCD
 995             # will not be added into the Database unless it is used by other modules that are
 996             # included in the FDF file.
 997             # In this case, just assign an invalid token number to make it pass build.
 998             if Pcd.Type in PCD_DYNAMIC_TYPE_LIST:
 999                 TokenNumber = 0
1000             else:
1001                 EdkLogger.error("build", AUTOGEN_ERROR,
1002                                 "No generated token number for %s.%s\n" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1003                                 ExtraData="[%s]" % str(Info))
1004         else:
1005             TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]
1006
1007     if Pcd.Type not in gItemTypeStringDatabase:
1008         EdkLogger.error("build", AUTOGEN_ERROR,
1009                         "Unknown PCD type [%s] of PCD %s.%s" % (Pcd.Type, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1010                         ExtraData="[%s]" % str(Info))
1011     if Pcd.DatumType not in gDatumSizeStringDatabase:
1012         EdkLogger.error("build", AUTOGEN_ERROR,
1013                         "Unknown datum type [%s] of PCD %s.%s" % (Pcd.DatumType, Pcd.TokenSpaceGuidCName, Pcd.TokenCName),
1014                         ExtraData="[%s]" % str(Info))
1015
1016     DatumType   = Pcd.DatumType
1017     DatumSize   = gDatumSizeStringDatabaseH[DatumType]
1018     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]
1019     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName
1020     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName
1021
1022     Type = ''
1023     Array = ''
1024     if Pcd.DatumType == 'VOID*':
1025         Type = '(VOID *)'
1026         Array = '[]'
1027     PcdItemType = Pcd.Type
1028     PcdExCNameList  = []
1029     if PcdItemType in gDynamicExPcd:
1030         PcdExTokenName = '_PCD_TOKEN_' + TokenSpaceGuidCName + '_' + Pcd.TokenCName
1031         AutoGenH.Append('\n#define %s  %dU\n' % (PcdExTokenName, TokenNumber))
1032
1033         if Info.IsLibrary:
1034             PcdList = Info.LibraryPcdList
1035         else:
1036             PcdList = Info.ModulePcdList
1037         for PcdModule in PcdList:
1038             if PcdModule.Type in gDynamicExPcd:
1039                 PcdExCNameList.append(PcdModule.TokenCName)
1040         # Be compatible with the current code which using PcdGet/Set for DynamicEx Pcd.
1041         # If only PcdGet/Set used in all Pcds with different CName, it should succeed to build.
1042         # If PcdGet/Set used in the Pcds with different Guids but same CName, it should failed to build.
1043         if PcdExCNameList.count(Pcd.TokenCName) > 1:
1044             AutoGenH.Append('// Disabled the macros, as PcdToken and PcdGet/Set are not allowed in the case that more than one DynamicEx Pcds are different Guids but same CName.\n')
1045             AutoGenH.Append('// #define %s  %s\n' % (PcdTokenName, PcdExTokenName))
1046             AutoGenH.Append('// #define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1047             if Pcd.DatumType == 'VOID*':
1048                 AutoGenH.Append('// #define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1049             else:
1050                 AutoGenH.Append('// #define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1051         else:
1052             AutoGenH.Append('#define %s  %s\n' % (PcdTokenName, PcdExTokenName))
1053             AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1054             if Pcd.DatumType == 'VOID*':
1055                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1056             else:
1057                 AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))
1058     else:
1059         AutoGenH.Append('#define _PCD_TOKEN_%s  %dU\n' % (TokenCName, TokenNumber))
1060     if PcdItemType in gDynamicPcd:
1061         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))
1062         if DatumType == 'VOID*':
1063             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))
1064         else:
1065             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))
1066     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:
1067         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName
1068         AutoGenH.Append('extern volatile %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )
1069         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))
1070         AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))
1071     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:
1072         key = ".".join((Pcd.TokenSpaceGuidCName,Pcd.TokenCName))
1073
1074         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))
1075         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))
1076         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)
1077
1078         if PcdItemType == TAB_PCDS_FIXED_AT_BUILD and key in Info.ConstPcd:
1079             AutoGenH.Append('#define _PCD_VALUE_%s %s\n' %(TokenCName, Pcd.DefaultValue))
1080
1081
1082
1083 ## Create code for library constructor
1084 #
1085 #   @param      Info        The ModuleAutoGen object
1086 #   @param      AutoGenC    The TemplateString object for C code
1087 #   @param      AutoGenH    The TemplateString object for header file
1088 #
1089 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):
1090     #
1091     # Library Constructors
1092     #
1093     ConstructorPrototypeString = TemplateString()
1094     ConstructorCallingString = TemplateString()
1095     if Info.IsLibrary:
1096         DependentLibraryList = [Info.Module]
1097     else:
1098         DependentLibraryList = Info.DependentLibraryList
1099     for Lib in DependentLibraryList:
1100         if len(Lib.ConstructorList) <= 0:
1101             continue
1102         Dict = {'Function':Lib.ConstructorList}
1103         if Lib.ModuleType in ['BASE', 'SEC']:
1104             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1105             ConstructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1106         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1107             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1108             ConstructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1109         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1110                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1111             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1112             ConstructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1113
1114     if str(ConstructorPrototypeString) == '':
1115         ConstructorPrototypeList = []
1116     else:
1117         ConstructorPrototypeList = [str(ConstructorPrototypeString)]
1118     if str(ConstructorCallingString) == '':
1119         ConstructorCallingList = []
1120     else:
1121         ConstructorCallingList = [str(ConstructorCallingString)]
1122
1123     Dict = {
1124         'Type'              :   'Constructor',
1125         'FunctionPrototype' :   ConstructorPrototypeList,
1126         'FunctionCall'      :   ConstructorCallingList
1127     }
1128     if Info.IsLibrary:
1129         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1130     else:
1131         if Info.ModuleType in ['BASE', 'SEC']:
1132             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1133         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1134             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1135         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1136                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1137             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1138
1139 ## Create code for library destructor
1140 #
1141 #   @param      Info        The ModuleAutoGen object
1142 #   @param      AutoGenC    The TemplateString object for C code
1143 #   @param      AutoGenH    The TemplateString object for header file
1144 #
1145 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):
1146     #
1147     # Library Destructors
1148     #
1149     DestructorPrototypeString = TemplateString()
1150     DestructorCallingString = TemplateString()
1151     if Info.IsLibrary:
1152         DependentLibraryList = [Info.Module]
1153     else:
1154         DependentLibraryList = Info.DependentLibraryList
1155     for Index in range(len(DependentLibraryList)-1, -1, -1):
1156         Lib = DependentLibraryList[Index]
1157         if len(Lib.DestructorList) <= 0:
1158             continue
1159         Dict = {'Function':Lib.DestructorList}
1160         if Lib.ModuleType in ['BASE', 'SEC']:
1161             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'].Replace(Dict))
1162             DestructorCallingString.Append(gLibraryStructorCall['BASE'].Replace(Dict))
1163         elif Lib.ModuleType in ['PEI_CORE','PEIM']:
1164             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'].Replace(Dict))
1165             DestructorCallingString.Append(gLibraryStructorCall['PEI'].Replace(Dict))
1166         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1167                                 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION', 'SMM_CORE']:
1168             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'].Replace(Dict))
1169             DestructorCallingString.Append(gLibraryStructorCall['DXE'].Replace(Dict))
1170
1171     if str(DestructorPrototypeString) == '':
1172         DestructorPrototypeList = []
1173     else:
1174         DestructorPrototypeList = [str(DestructorPrototypeString)]
1175     if str(DestructorCallingString) == '':
1176         DestructorCallingList = []
1177     else:
1178         DestructorCallingList = [str(DestructorCallingString)]
1179
1180     Dict = {
1181         'Type'              :   'Destructor',
1182         'FunctionPrototype' :   DestructorPrototypeList,
1183         'FunctionCall'      :   DestructorCallingList
1184     }
1185     if Info.IsLibrary:
1186         AutoGenH.Append("${BEGIN}${FunctionPrototype}${END}", Dict)
1187     else:
1188         if Info.ModuleType in ['BASE', 'SEC']:
1189             AutoGenC.Append(gLibraryString['BASE'].Replace(Dict))
1190         elif Info.ModuleType in ['PEI_CORE','PEIM']:
1191             AutoGenC.Append(gLibraryString['PEI'].Replace(Dict))
1192         elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER',
1193                                  'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION','SMM_CORE']:
1194             AutoGenC.Append(gLibraryString['DXE'].Replace(Dict))
1195
1196
1197 ## Create code for ModuleEntryPoint
1198 #
1199 #   @param      Info        The ModuleAutoGen object
1200 #   @param      AutoGenC    The TemplateString object for C code
1201 #   @param      AutoGenH    The TemplateString object for header file
1202 #
1203 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):
1204     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1205         return
1206     #
1207     # Module Entry Points
1208     #
1209     NumEntryPoints = len(Info.Module.ModuleEntryPointList)
1210     if 'PI_SPECIFICATION_VERSION' in Info.Module.Specification:
1211         PiSpecVersion = Info.Module.Specification['PI_SPECIFICATION_VERSION']
1212     else:
1213         PiSpecVersion = '0x00000000'
1214     if 'UEFI_SPECIFICATION_VERSION' in Info.Module.Specification:
1215         UefiSpecVersion = Info.Module.Specification['UEFI_SPECIFICATION_VERSION']
1216     else:
1217         UefiSpecVersion = '0x00000000'
1218     Dict = {
1219         'Function'       :   Info.Module.ModuleEntryPointList,
1220         'PiSpecVersion'  :   PiSpecVersion + 'U',
1221         'UefiSpecVersion':   UefiSpecVersion + 'U'
1222     }
1223
1224     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE', 'SMM_CORE']:
1225         if Info.SourceFileList <> None and Info.SourceFileList <> []:
1226           if NumEntryPoints != 1:
1227               EdkLogger.error(
1228                   "build",
1229                   AUTOGEN_ERROR,
1230                   '%s must have exactly one entry point' % Info.ModuleType,
1231                   File=str(Info),
1232                   ExtraData= ", ".join(Info.Module.ModuleEntryPointList)
1233                   )
1234     if Info.ModuleType == 'PEI_CORE':
1235         AutoGenC.Append(gPeiCoreEntryPointString.Replace(Dict))
1236         AutoGenH.Append(gPeiCoreEntryPointPrototype.Replace(Dict))
1237     elif Info.ModuleType == 'DXE_CORE':
1238         AutoGenC.Append(gDxeCoreEntryPointString.Replace(Dict))
1239         AutoGenH.Append(gDxeCoreEntryPointPrototype.Replace(Dict))
1240     elif Info.ModuleType == 'SMM_CORE':
1241         AutoGenC.Append(gSmmCoreEntryPointString.Replace(Dict))
1242         AutoGenH.Append(gSmmCoreEntryPointPrototype.Replace(Dict))
1243     elif Info.ModuleType == 'PEIM':
1244         if NumEntryPoints < 2:
1245             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints].Replace(Dict))
1246         else:
1247             AutoGenC.Append(gPeimEntryPointString[2].Replace(Dict))
1248         AutoGenH.Append(gPeimEntryPointPrototype.Replace(Dict))
1249     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER']:
1250         if NumEntryPoints < 2:
1251             AutoGenC.Append(gUefiDriverEntryPointString[NumEntryPoints].Replace(Dict))
1252         else:
1253             AutoGenC.Append(gUefiDriverEntryPointString[2].Replace(Dict))
1254         AutoGenH.Append(gUefiDriverEntryPointPrototype.Replace(Dict))
1255     elif Info.ModuleType == 'DXE_SMM_DRIVER':
1256         if NumEntryPoints == 0:
1257             AutoGenC.Append(gDxeSmmEntryPointString[0].Replace(Dict))
1258         else:
1259             AutoGenC.Append(gDxeSmmEntryPointString[1].Replace(Dict))
1260         AutoGenH.Append(gDxeSmmEntryPointPrototype.Replace(Dict))
1261     elif Info.ModuleType == 'UEFI_APPLICATION':
1262         if NumEntryPoints < 2:
1263             AutoGenC.Append(gUefiApplicationEntryPointString[NumEntryPoints].Replace(Dict))
1264         else:
1265             AutoGenC.Append(gUefiApplicationEntryPointString[2].Replace(Dict))
1266         AutoGenH.Append(gUefiApplicationEntryPointPrototype.Replace(Dict))
1267
1268 ## Create code for ModuleUnloadImage
1269 #
1270 #   @param      Info        The ModuleAutoGen object
1271 #   @param      AutoGenC    The TemplateString object for C code
1272 #   @param      AutoGenH    The TemplateString object for header file
1273 #
1274 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):
1275     if Info.IsLibrary or Info.ModuleType in ['USER_DEFINED', 'SEC']:
1276         return
1277     #
1278     # Unload Image Handlers
1279     #
1280     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)
1281     Dict = {'Count':str(NumUnloadImage) + 'U', 'Function':Info.Module.ModuleUnloadImageList}
1282     if NumUnloadImage < 2:
1283         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage].Replace(Dict))
1284     else:
1285         AutoGenC.Append(gUefiUnloadImageString[2].Replace(Dict))
1286     AutoGenH.Append(gUefiUnloadImagePrototype.Replace(Dict))
1287
1288 ## Create code for GUID
1289 #
1290 #   @param      Info        The ModuleAutoGen object
1291 #   @param      AutoGenC    The TemplateString object for C code
1292 #   @param      AutoGenH    The TemplateString object for header file
1293 #
1294 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):
1295     if Info.IsLibrary:
1296         return
1297
1298     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1299         GuidType = "GUID"
1300     else:
1301         GuidType = "EFI_GUID"
1302
1303     if Info.GuidList:
1304         AutoGenC.Append("\n// Guids\n")
1305     #
1306     # GUIDs
1307     #
1308     for Key in Info.GuidList:
1309         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))
1310
1311 ## Create code for protocol
1312 #
1313 #   @param      Info        The ModuleAutoGen object
1314 #   @param      AutoGenC    The TemplateString object for C code
1315 #   @param      AutoGenH    The TemplateString object for header file
1316 #
1317 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):
1318     if Info.IsLibrary:
1319         return
1320
1321     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1322         GuidType = "GUID"
1323     else:
1324         GuidType = "EFI_GUID"
1325
1326     if Info.ProtocolList:
1327         AutoGenC.Append("\n// Protocols\n")
1328     #
1329     # Protocol GUIDs
1330     #
1331     for Key in Info.ProtocolList:
1332         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))
1333
1334 ## Create code for PPI
1335 #
1336 #   @param      Info        The ModuleAutoGen object
1337 #   @param      AutoGenC    The TemplateString object for C code
1338 #   @param      AutoGenH    The TemplateString object for header file
1339 #
1340 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):
1341     if Info.IsLibrary:
1342         return
1343
1344     if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1345         GuidType = "GUID"
1346     else:
1347         GuidType = "EFI_GUID"
1348
1349     if Info.PpiList:
1350         AutoGenC.Append("\n// PPIs\n")
1351     #
1352     # PPI GUIDs
1353     #
1354     for Key in Info.PpiList:
1355         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))
1356
1357 ## Create code for PCD
1358 #
1359 #   @param      Info        The ModuleAutoGen object
1360 #   @param      AutoGenC    The TemplateString object for C code
1361 #   @param      AutoGenH    The TemplateString object for header file
1362 #
1363 def CreatePcdCode(Info, AutoGenC, AutoGenH):
1364
1365     # Collect Token Space GUIDs used by DynamicEc PCDs
1366     TokenSpaceList = []
1367     for Pcd in Info.ModulePcdList:
1368         if Pcd.Type in gDynamicExPcd and Pcd.TokenSpaceGuidCName not in TokenSpaceList:
1369             TokenSpaceList += [Pcd.TokenSpaceGuidCName]
1370
1371     # Add extern declarations to AutoGen.h if one or more Token Space GUIDs were found
1372     if TokenSpaceList <> []:
1373         AutoGenH.Append("\n// Definition of PCD Token Space GUIDs used in this module\n\n")
1374         if Info.ModuleType in ["USER_DEFINED", "BASE"]:
1375             GuidType = "GUID"
1376         else:
1377             GuidType = "EFI_GUID"
1378         for Item in TokenSpaceList:
1379             AutoGenH.Append('extern %s %s;\n' % (GuidType, Item))
1380
1381     if Info.IsLibrary:
1382         if Info.ModulePcdList:
1383             AutoGenH.Append("\n// PCD definitions\n")
1384         for Pcd in Info.ModulePcdList:
1385             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)
1386         DynExPcdTokenNumberMapping (Info, AutoGenH)
1387     else:
1388         if Info.ModulePcdList:
1389             AutoGenH.Append("\n// Definition of PCDs used in this module\n")
1390             AutoGenC.Append("\n// Definition of PCDs used in this module\n")
1391         for Pcd in Info.ModulePcdList:
1392             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)
1393         DynExPcdTokenNumberMapping (Info, AutoGenH)
1394         if Info.LibraryPcdList:
1395             AutoGenH.Append("\n// Definition of PCDs used in libraries is in AutoGen.c\n")
1396             AutoGenC.Append("\n// Definition of PCDs used in libraries\n")
1397         for Pcd in Info.LibraryPcdList:
1398             CreateModulePcdCode(Info, AutoGenC, AutoGenC, Pcd)
1399     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)
1400
1401 ## Create code for unicode string definition
1402 #
1403 #   @param      Info        The ModuleAutoGen object
1404 #   @param      AutoGenC    The TemplateString object for C code
1405 #   @param      AutoGenH    The TemplateString object for header file
1406 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1407 #   @param      UniGenBinBuffer Buffer to store uni string package data
1408 #
1409 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH, UniGenCFlag, UniGenBinBuffer):
1410     WorkingDir = os.getcwd()
1411     os.chdir(Info.WorkspaceDir)
1412
1413     IncList = [Info.MetaFile.Dir]
1414     # Get all files under [Sources] section in inf file for EDK-II module
1415     EDK2Module = True
1416     SrcList = [F for F in Info.SourceFileList]
1417     if Info.AutoGenVersion < 0x00010005:
1418         EDK2Module = False
1419         # Get all files under the module directory for EDK-I module
1420         Cwd = os.getcwd()
1421         os.chdir(Info.MetaFile.Dir)
1422         for Root, Dirs, Files in os.walk("."):
1423             if 'CVS' in Dirs:
1424                 Dirs.remove('CVS')
1425             if '.svn' in Dirs:
1426                 Dirs.remove('.svn')
1427             for File in Files:
1428                 File = PathClass(os.path.join(Root, File), Info.MetaFile.Dir)
1429                 if File in SrcList:
1430                     continue
1431                 SrcList.append(File)
1432         os.chdir(Cwd)
1433
1434     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-c') > -1:
1435         CompatibleMode = True
1436     else:
1437         CompatibleMode = False
1438
1439     #
1440     # -s is a temporary option dedicated for building .UNI files with ISO 639-2 language codes of EDK Shell in EDK2
1441     #
1442     if 'BUILD' in Info.BuildOption and Info.BuildOption['BUILD']['FLAGS'].find('-s') > -1:
1443         if CompatibleMode:
1444             EdkLogger.error("build", AUTOGEN_ERROR,
1445                             "-c and -s build options should be used exclusively",
1446                             ExtraData="[%s]" % str(Info))
1447         ShellMode = True
1448     else:
1449         ShellMode = False
1450
1451     #RFC4646 is only for EDKII modules and ISO639-2 for EDK modules
1452     if EDK2Module:
1453         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.RFCLanguages]
1454     else:
1455         FilterInfo = [EDK2Module] + [Info.PlatformInfo.Platform.ISOLanguages]
1456     Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, Info.IncludePathList, ['.uni', '.inf'], Info.Name, CompatibleMode, ShellMode, UniGenCFlag, UniGenBinBuffer, FilterInfo)
1457     if CompatibleMode or UniGenCFlag:
1458         AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")
1459         AutoGenC.Append(Code)
1460         AutoGenC.Append("\n")
1461     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")
1462     AutoGenH.Append(Header)
1463     if CompatibleMode or UniGenCFlag:
1464         AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)
1465     os.chdir(WorkingDir)
1466
1467 ## Create common code
1468 #
1469 #   @param      Info        The ModuleAutoGen object
1470 #   @param      AutoGenC    The TemplateString object for C code
1471 #   @param      AutoGenH    The TemplateString object for header file
1472 #
1473 def CreateHeaderCode(Info, AutoGenC, AutoGenH):
1474     # file header
1475     AutoGenH.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.h'}))
1476     # header file Prologue
1477     AutoGenH.Append(gAutoGenHPrologueString.Replace({'File':'AUTOGENH','Guid':Info.Guid.replace('-','_')}))
1478     AutoGenH.Append(gAutoGenHCppPrologueString)
1479     if Info.AutoGenVersion >= 0x00010005:
1480         # header files includes
1481         AutoGenH.Append("#include <%s>\n" % gBasicHeaderFile)
1482         if Info.ModuleType in gModuleTypeHeaderFile \
1483            and gModuleTypeHeaderFile[Info.ModuleType][0] != gBasicHeaderFile:
1484             AutoGenH.Append("#include <%s>\n" % gModuleTypeHeaderFile[Info.ModuleType][0])
1485         #
1486         # if either PcdLib in [LibraryClasses] sections or there exist Pcd section, add PcdLib.h
1487         # As if modules only uses FixedPcd, then PcdLib is not needed in [LibraryClasses] section.
1488         #
1489         if 'PcdLib' in Info.Module.LibraryClasses or Info.Module.Pcds:
1490             AutoGenH.Append("#include <Library/PcdLib.h>\n")
1491
1492         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;')
1493         AutoGenH.Append('\nextern CHAR8 *gEfiCallerBaseName;\n\n')
1494
1495         if Info.IsLibrary:
1496             return
1497
1498         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))
1499
1500     if Info.IsLibrary:
1501         return
1502     # C file header
1503     AutoGenC.Append(gAutoGenHeaderString.Replace({'FileName':'AutoGen.c'}))
1504     if Info.AutoGenVersion >= 0x00010005:
1505         # C file header files includes
1506         if Info.ModuleType in gModuleTypeHeaderFile:
1507             for Inc in gModuleTypeHeaderFile[Info.ModuleType]:
1508                 AutoGenC.Append("#include <%s>\n" % Inc)
1509         else:
1510             AutoGenC.Append("#include <%s>\n" % gBasicHeaderFile)
1511
1512         #
1513         # Publish the CallerId Guid
1514         #
1515         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))
1516         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED CHAR8 *gEfiCallerBaseName = "%s";\n' % Info.Name)
1517
1518 ## Create common code for header file
1519 #
1520 #   @param      Info        The ModuleAutoGen object
1521 #   @param      AutoGenC    The TemplateString object for C code
1522 #   @param      AutoGenH    The TemplateString object for header file
1523 #
1524 def CreateFooterCode(Info, AutoGenC, AutoGenH):
1525     AutoGenH.Append(gAutoGenHEpilogueString)
1526
1527 ## Create code for a module
1528 #
1529 #   @param      Info        The ModuleAutoGen object
1530 #   @param      AutoGenC    The TemplateString object for C code
1531 #   @param      AutoGenH    The TemplateString object for header file
1532 #   @param      UniGenCFlag     UniString is generated into AutoGen C file when it is set to True
1533 #   @param      UniGenBinBuffer Buffer to store uni string package data
1534 #
1535 def CreateCode(Info, AutoGenC, AutoGenH, StringH, UniGenCFlag, UniGenBinBuffer):
1536     CreateHeaderCode(Info, AutoGenC, AutoGenH)
1537
1538     if Info.AutoGenVersion >= 0x00010005:
1539         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)
1540         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)
1541         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)
1542         CreatePcdCode(Info, AutoGenC, AutoGenH)
1543         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)
1544         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)
1545         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)
1546         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)
1547
1548     if Info.UnicodeFileList:
1549         FileName = "%sStrDefs.h" % Info.Name
1550         StringH.Append(gAutoGenHeaderString.Replace({'FileName':FileName}))
1551         StringH.Append(gAutoGenHPrologueString.Replace({'File':'STRDEFS', 'Guid':Info.Guid.replace('-','_')}))
1552         CreateUnicodeStringCode(Info, AutoGenC, StringH, UniGenCFlag, UniGenBinBuffer)
1553         StringH.Append("\n#endif\n")
1554         AutoGenH.Append('#include "%s"\n' % FileName)
1555
1556     CreateFooterCode(Info, AutoGenC, AutoGenH)
1557
1558     # no generation of AutoGen.c for Edk modules without unicode file
1559     if Info.AutoGenVersion < 0x00010005 and len(Info.UnicodeFileList) == 0:
1560         AutoGenC.String = ''
1561
1562 ## Create the code file
1563 #
1564 #   @param      FilePath     The path of code file
1565 #   @param      Content      The content of code file
1566 #   @param      IsBinaryFile The flag indicating if the file is binary file or not
1567 #
1568 #   @retval     True        If file content is changed or file doesn't exist
1569 #   @retval     False       If the file exists and the content is not changed
1570 #
1571 def Generate(FilePath, Content, IsBinaryFile):
1572     return SaveFileOnChange(FilePath, Content, IsBinaryFile)
1573