MdePkg/Library/BasePcdLibNull/PcdLib.c

   1 /** @file
   2   A emptry template implementation of PCD Library.
   3
   4   Copyright (c) 2006 - 2008, 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
  15 #include <Base.h>
  16
  17 #include <Library/DebugLib.h>
  18 #include <Library/PcdLib.h>
  19 #include <Library/BaseMemoryLib.h>
  20
  21
  22 /**
  23   This function provides a means by which SKU support can be established in the PCD infrastructure.
  24
  25   Sets the current SKU in the PCD database to the value specified by SkuId.  SkuId is returned.
  26
  27   @param[in]  SkuId The SKU value that will be used when the PCD service will retrieve and
  28                     set values associated with a PCD token.
  29
  30   If SkuId >= 0x100, then ASSERT().
  31
  32   @return Return the SKU ID that just be set.
  33
  34 **/
  35 UINTN
  36 EFIAPI
  37 LibPcdSetSku (
  38   IN UINTN   SkuId
  39   )
  40 {
  41   ASSERT (FALSE);
  42
  43   return 0;
  44 }
  45
  46 /**
  47   This function provides a means by which to retrieve a value for a given PCD token.
  48
  49   Returns the 8-bit value for the token specified by TokenNumber.
  50
  51   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
  52
  53   @return Returns the 8-bit value for the token specified by TokenNumber.
  54
  55 **/
  56 UINT8
  57 EFIAPI
  58 LibPcdGet8 (
  59   IN UINTN             TokenNumber
  60   )
  61 {
  62   ASSERT (FALSE);
  63
  64   return 0;
  65 }
  66
  67
  68
  69 /**
  70   This function provides a means by which to retrieve a value for a given PCD token.
  71
  72   Returns the 16-bit value for the token specified by TokenNumber.
  73
  74   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
  75
  76   @return Returns the 16-bit value for the token specified by TokenNumber.
  77
  78 **/
  79 UINT16
  80 EFIAPI
  81 LibPcdGet16 (
  82   IN UINTN             TokenNumber
  83   )
  84 {
  85   ASSERT (FALSE);
  86
  87   return 0;
  88 }
  89
  90
  91
  92 /**
  93   This function provides a means by which to retrieve a value for a given PCD token.
  94
  95   Returns the 32-bit value for the token specified by TokenNumber.
  96
  97   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
  98
  99   @return Returns the 32-bit value for the token specified by TokenNumber.
 100
 101 **/
 102 UINT32
 103 EFIAPI
 104 LibPcdGet32 (
 105   IN UINTN             TokenNumber
 106   )
 107 {
 108   ASSERT (FALSE);
 109
 110   return 0;
 111 }
 112
 113
 114
 115 /**
 116   This function provides a means by which to retrieve a value for a given PCD token.
 117
 118   Returns the 64-bit value for the token specified by TokenNumber.
 119
 120   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 121
 122   @return Returns the 64-bit value for the token specified by TokenNumber.
 123
 124 **/
 125 UINT64
 126 EFIAPI
 127 LibPcdGet64 (
 128   IN UINTN             TokenNumber
 129   )
 130 {
 131   ASSERT (FALSE);
 132
 133   return 0;
 134 }
 135
 136
 137
 138 /**
 139   This function provides a means by which to retrieve a value for a given PCD token.
 140
 141   Returns the pointer to the buffer of the token specified by TokenNumber.
 142
 143   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 144
 145   @return Returns the pointer to the token specified by TokenNumber.
 146
 147 **/
 148 VOID *
 149 EFIAPI
 150 LibPcdGetPtr (
 151   IN UINTN             TokenNumber
 152   )
 153 {
 154   ASSERT (FALSE);
 155
 156   return 0;
 157 }
 158
 159
 160
 161 /**
 162   This function provides a means by which to retrieve a value for a given PCD token.
 163
 164   Returns the Boolean value of the token specified by TokenNumber.
 165
 166   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 167
 168   @return Returns the Boolean value of the token specified by TokenNumber.
 169
 170 **/
 171 BOOLEAN
 172 EFIAPI
 173 LibPcdGetBool (
 174   IN UINTN             TokenNumber
 175   )
 176 {
 177   ASSERT (FALSE);
 178
 179   return 0;
 180 }
 181
 182
 183
 184 /**
 185   This function provides a means by which to retrieve the size of a given PCD token.
 186
 187   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 188
 189   @return Returns the size of the token specified by TokenNumber.
 190
 191 **/
 192 UINTN
 193 EFIAPI
 194 LibPcdGetSize (
 195   IN UINTN             TokenNumber
 196   )
 197 {
 198   ASSERT (FALSE);
 199
 200   return 0;
 201 }
 202
 203
 204
 205 /**
 206   This function provides a means by which to retrieve a value for a given PCD token.
 207
 208   Returns the 8-bit value for the token specified by TokenNumber and Guid.
 209
 210   If Guid is NULL, then ASSERT().
 211
 212   @param[in]  Guid Pointer to a 128-bit unique value that designates
 213               which namespace to retrieve a value from.
 214   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 215
 216   @return Return the UINT8.
 217
 218 **/
 219 UINT8
 220 EFIAPI
 221 LibPcdGetEx8 (
 222   IN CONST GUID        *Guid,
 223   IN UINTN             TokenNumber
 224   )
 225 {
 226   ASSERT (FALSE);
 227
 228   return 0;
 229 }
 230
 231
 232
 233 /**
 234   This function provides a means by which to retrieve a value for a given PCD token.
 235
 236   Returns the 16-bit value for the token specified by TokenNumber and Guid.
 237
 238   If Guid is NULL, then ASSERT().
 239
 240   @param[in]  Guid Pointer to a 128-bit unique value that designates
 241               which namespace to retrieve a value from.
 242   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 243
 244   @return Return the UINT16.
 245
 246 **/
 247 UINT16
 248 EFIAPI
 249 LibPcdGetEx16 (
 250   IN CONST GUID        *Guid,
 251   IN UINTN             TokenNumber
 252   )
 253 {
 254   ASSERT (FALSE);
 255
 256   return 0;
 257 }
 258
 259
 260
 261 /**
 262   Returns the 32-bit value for the token specified by TokenNumber and Guid.
 263   If Guid is NULL, then ASSERT().
 264
 265   @param[in]  Guid Pointer to a 128-bit unique value that designates
 266               which namespace to retrieve a value from.
 267   @param[in]  TokenNumber The PCD token number to retrieve a current value for.
 268
 269   @return Return the UINT32.
 270
 271 **/
 272 UINT32
 273 EFIAPI
 274 LibPcdGetEx32 (
 275   IN CONST GUID        *Guid,
 276   IN UINTN             TokenNumber
 277   )
 278 {
 279   ASSERT (FALSE);
 280
 281   return 0;
 282 }
 283
 284
 285
 286 /**
 287   This function provides a means by which to retrieve a value for a given PCD token.
 288
 289   Returns the 64-bit value for the token specified by TokenNumber and Guid.
 290
 291   If Guid is NULL, then ASSERT().
 292
 293   @param[in]  Guid          Pointer to a 128-bit unique value that designates
 294                             which namespace to retrieve a value from.
 295   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 296
 297   @return Return the UINT64.
 298
 299 **/
 300 UINT64
 301 EFIAPI
 302 LibPcdGetEx64 (
 303   IN CONST GUID        *Guid,
 304   IN UINTN             TokenNumber
 305   )
 306 {
 307   ASSERT (FALSE);
 308
 309   return 0;
 310 }
 311
 312
 313
 314 /**
 315   This function provides a means by which to retrieve a value for a given PCD token.
 316
 317   Returns the pointer to the buffer of token specified by TokenNumber and Guid.
 318
 319   If Guid is NULL, then ASSERT().
 320
 321   @param[in]  Guid          Pointer to a 128-bit unique value that designates
 322                             which namespace to retrieve a value from.
 323   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 324
 325   @return Return the VOID* pointer.
 326
 327 **/
 328 VOID *
 329 EFIAPI
 330 LibPcdGetExPtr (
 331   IN CONST GUID        *Guid,
 332   IN UINTN             TokenNumber
 333   )
 334 {
 335   ASSERT (FALSE);
 336
 337   return 0;
 338 }
 339
 340
 341
 342 /**
 343   This function provides a means by which to retrieve a value for a given PCD token.
 344
 345   Returns the Boolean value of the token specified by TokenNumber and Guid.
 346
 347   If Guid is NULL, then ASSERT().
 348
 349   @param[in]  Guid          Pointer to a 128-bit unique value that designates
 350                             which namespace to retrieve a value from.
 351   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 352
 353   @return Return the BOOLEAN.
 354
 355 **/
 356 BOOLEAN
 357 EFIAPI
 358 LibPcdGetExBool (
 359   IN CONST GUID        *Guid,
 360   IN UINTN             TokenNumber
 361   )
 362 {
 363   ASSERT (FALSE);
 364
 365   return 0;
 366 }
 367
 368
 369
 370 /**
 371   This function provides a means by which to retrieve the size of a given PCD token.
 372
 373   Returns the size of the token specified by TokenNumber and Guid.
 374
 375   If Guid is NULL, then ASSERT().
 376
 377   @param[in]  Guid          Pointer to a 128-bit unique value that designates
 378                             which namespace to retrieve a value from.
 379   @param[in]  TokenNumber   The PCD token number to retrieve a current value for.
 380
 381   @return Return the size.
 382
 383 **/
 384 UINTN
 385 EFIAPI
 386 LibPcdGetExSize (
 387   IN CONST GUID        *Guid,
 388   IN UINTN             TokenNumber
 389   )
 390 {
 391   ASSERT (FALSE);
 392
 393   return 0;
 394 }
 395
 396
 397
 398 /**
 399   This function provides a means by which to set a value for a given PCD token.
 400
 401   Sets the 8-bit value for the token specified by TokenNumber
 402   to the value specified by Value.  Value is returned.
 403
 404   @param[in]  TokenNumber   The PCD token number to set a current value for.
 405   @param[in]  Value         The 8-bit value to set.
 406
 407   @return Return the value been set.
 408
 409 **/
 410 UINT8
 411 EFIAPI
 412 LibPcdSet8 (
 413   IN UINTN             TokenNumber,
 414   IN UINT8             Value
 415   )
 416 {
 417   ASSERT (FALSE);
 418
 419   return 0;
 420 }
 421
 422
 423
 424 /**
 425   This function provides a means by which to set a value for a given PCD token.
 426
 427   Sets the 16-bit value for the token specified by TokenNumber
 428   to the value specified by Value.  Value is returned.
 429
 430   @param[in]  TokenNumber   The PCD token number to set a current value for.
 431   @param[in]  Value         The 16-bit value to set.
 432
 433   @return Return the value been set.
 434
 435 **/
 436 UINT16
 437 EFIAPI
 438 LibPcdSet16 (
 439   IN UINTN             TokenNumber,
 440   IN UINT16            Value
 441   )
 442 {
 443   ASSERT (FALSE);
 444
 445   return 0;
 446 }
 447
 448
 449
 450 /**
 451   This function provides a means by which to set a value for a given PCD token.
 452
 453   Sets the 32-bit value for the token specified by TokenNumber
 454   to the value specified by Value.  Value is returned.
 455
 456   @param[in]  TokenNumber   The PCD token number to set a current value for.
 457   @param[in]  Value         The 32-bit value to set.
 458
 459   @return Return the value been set.
 460
 461 **/
 462 UINT32
 463 EFIAPI
 464 LibPcdSet32 (
 465   IN UINTN             TokenNumber,
 466   IN UINT32            Value
 467   )
 468 {
 469   ASSERT (FALSE);
 470
 471   return 0;
 472 }
 473
 474
 475
 476 /**
 477   This function provides a means by which to set a value for a given PCD token.
 478
 479   Sets the 64-bit value for the token specified by TokenNumber
 480   to the value specified by Value.  Value is returned.
 481
 482   @param[in]  TokenNumber   The PCD token number to set a current value for.
 483   @param[in]  Value         The 64-bit value to set.
 484
 485   @return Return the value been set.
 486
 487 **/
 488 UINT64
 489 EFIAPI
 490 LibPcdSet64 (
 491   IN UINTN             TokenNumber,
 492   IN UINT64            Value
 493   )
 494 {
 495   ASSERT (FALSE);
 496
 497   return 0;
 498 }
 499
 500
 501
 502 /**
 503   This function provides a means by which to set a value for a given PCD token.
 504
 505   Sets a buffer for the token specified by TokenNumber to the value
 506   specified by Buffer and SizeOfBuffer.  Buffer is returned.
 507   If SizeOfBuffer is greater than the maximum size support by TokenNumber,
 508   then set SizeOfBuffer to the maximum size supported by TokenNumber and
 509   return NULL to indicate that the set operation was not actually performed.
 510
 511   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to the
 512   maximum size supported by TokenName and NULL must be returned.
 513
 514   If SizeOfBuffer is NULL, then ASSERT().
 515   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 516
 517   @param[in]      TokenNumber   The PCD token number to set a current value for.
 518   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
 519   @param[in]      Buffer        A pointer to the buffer to set.
 520
 521   @return Return the pointer for the buffer been set.
 522
 523 **/
 524 VOID *
 525 EFIAPI
 526 LibPcdSetPtr (
 527   IN        UINTN             TokenNumber,
 528   IN OUT    UINTN             *SizeOfBuffer,
 529   IN CONST  VOID              *Buffer
 530   )
 531 {
 532   ASSERT (FALSE);
 533
 534   return NULL;
 535 }
 536
 537
 538
 539 /**
 540   This function provides a means by which to set a value for a given PCD token.
 541
 542   Sets the Boolean value for the token specified by TokenNumber
 543   to the value specified by Value.  Value is returned.
 544
 545   @param[in]  TokenNumber   The PCD token number to set a current value for.
 546   @param[in]  Value         The boolean value to set.
 547
 548   @return Return the value been set.
 549
 550 **/
 551 BOOLEAN
 552 EFIAPI
 553 LibPcdSetBool (
 554   IN UINTN             TokenNumber,
 555   IN BOOLEAN           Value
 556   )
 557 {
 558   ASSERT (FALSE);
 559
 560   return FALSE;
 561 }
 562
 563
 564
 565 /**
 566   This function provides a means by which to set a value for a given PCD token.
 567
 568   Sets the 8-bit value for the token specified by TokenNumber and
 569   Guid to the value specified by Value. Value is returned.
 570
 571   If Guid is NULL, then ASSERT().
 572
 573   @param[in]  Guid          Pointer to a 128-bit unique value that
 574                             designates which namespace to set a value from.
 575   @param[in]  TokenNumber   The PCD token number to set a current value for.
 576   @param[in]  Value         The 8-bit value to set.
 577
 578   @return Return the value been set.
 579
 580 **/
 581 UINT8
 582 EFIAPI
 583 LibPcdSetEx8 (
 584   IN CONST GUID        *Guid,
 585   IN UINTN             TokenNumber,
 586   IN UINT8             Value
 587   )
 588 {
 589   ASSERT (FALSE);
 590
 591   return 0;
 592 }
 593
 594
 595
 596 /**
 597   This function provides a means by which to set a value for a given PCD token.
 598
 599   Sets the 16-bit value for the token specified by TokenNumber and
 600   Guid to the value specified by Value. Value is returned.
 601
 602   If Guid is NULL, then ASSERT().
 603
 604   @param[in]  Guid          Pointer to a 128-bit unique value that
 605                             designates which namespace to set a value from.
 606   @param[in]  TokenNumber   The PCD token number to set a current value for.
 607   @param[in]  Value         The 16-bit value to set.
 608
 609   @return Return the value been set.
 610
 611 **/
 612 UINT16
 613 EFIAPI
 614 LibPcdSetEx16 (
 615   IN CONST GUID        *Guid,
 616   IN UINTN             TokenNumber,
 617   IN UINT16            Value
 618   )
 619 {
 620   ASSERT (FALSE);
 621
 622   return 0;
 623 }
 624
 625
 626
 627 /**
 628   This function provides a means by which to set a value for a given PCD token.
 629
 630   Sets the 32-bit value for the token specified by TokenNumber and
 631   Guid to the value specified by Value. Value is returned.
 632
 633   If Guid is NULL, then ASSERT().
 634
 635   @param[in]  Guid          Pointer to a 128-bit unique value that
 636                             designates which namespace to set a value from.
 637   @param[in]  TokenNumber   The PCD token number to set a current value for.
 638   @param[in]  Value         The 32-bit value to set.
 639
 640   @return Return the value been set.
 641
 642 **/
 643 UINT32
 644 EFIAPI
 645 LibPcdSetEx32 (
 646   IN CONST GUID        *Guid,
 647   IN UINTN             TokenNumber,
 648   IN UINT32            Value
 649   )
 650 {
 651   ASSERT (FALSE);
 652
 653   return 0;
 654 }
 655
 656
 657
 658 /**
 659   This function provides a means by which to set a value for a given PCD token.
 660
 661   Sets the 64-bit value for the token specified by TokenNumber and
 662   Guid to the value specified by Value. Value is returned.
 663   If Guid is NULL, then ASSERT().
 664
 665   @param[in]  Guid          Pointer to a 128-bit unique value that
 666                             designates which namespace to set a value from.
 667   @param[in]  TokenNumber   The PCD token number to set a current value for.
 668   @param[in]  Value         The 64-bit value to set.
 669
 670   @return Return the value been set.
 671
 672 **/
 673 UINT64
 674 EFIAPI
 675 LibPcdSetEx64 (
 676   IN CONST GUID        *Guid,
 677   IN UINTN             TokenNumber,
 678   IN UINT64            Value
 679   )
 680 {
 681   ASSERT (FALSE);
 682
 683   return 0;
 684 }
 685
 686
 687
 688 /**
 689   This function provides a means by which to set a value for a given PCD token.
 690
 691   Sets a buffer for the token specified by TokenNumber to the value specified by
 692   Buffer and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than
 693   the maximum size support by TokenNumber, then set SizeOfBuffer to the maximum size
 694   supported by TokenNumber and return NULL to indicate that the set operation
 695   was not actually performed.
 696
 697   If Guid is NULL, then ASSERT().
 698   If SizeOfBuffer is NULL, then ASSERT().
 699   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 700
 701   @param[in]  Guid              Pointer to a 128-bit unique value that
 702                                 designates which namespace to set a value from.
 703   @param[in]  TokenNumber       The PCD token number to set a current value for.
 704   @param[in, out] SizeOfBuffer  The size, in bytes, of Buffer.
 705   @param[in]  Buffer            A pointer to the buffer to set.
 706
 707   @return Return the pinter to the buffer been set.
 708
 709 **/
 710 VOID *
 711 EFIAPI
 712 LibPcdSetExPtr (
 713   IN      CONST GUID        *Guid,
 714   IN      UINTN             TokenNumber,
 715   IN OUT  UINTN             *SizeOfBuffer,
 716   IN      VOID              *Buffer
 717   )
 718 {
 719   ASSERT (FALSE);
 720
 721   return NULL;
 722 }
 723
 724
 725
 726 /**
 727   This function provides a means by which to set a value for a given PCD token.
 728
 729   Sets the Boolean value for the token specified by TokenNumber and
 730   Guid to the value specified by Value. Value is returned.
 731
 732   If Guid is NULL, then ASSERT().
 733
 734   @param[in]  Guid          Pointer to a 128-bit unique value that
 735                             designates which namespace to set a value from.
 736   @param[in]  TokenNumber   The PCD token number to set a current value for.
 737   @param[in]  Value         The Boolean value to set.
 738
 739   @return Return the value been set.
 740
 741 **/
 742 BOOLEAN
 743 EFIAPI
 744 LibPcdSetExBool (
 745   IN CONST GUID        *Guid,
 746   IN UINTN             TokenNumber,
 747   IN BOOLEAN           Value
 748   )
 749 {
 750   ASSERT (FALSE);
 751
 752   return FALSE;
 753 }
 754
 755
 756
 757 /**
 758   Set up a notification function that is called when a specified token is set.
 759
 760   When the token specified by TokenNumber and Guid is set,
 761   then notification function specified by NotificationFunction is called.
 762   If Guid is NULL, then the default token space is used.
 763
 764   If NotificationFunction is NULL, then ASSERT().
 765
 766   @param[in]  Guid      Pointer to a 128-bit unique value that designates which
 767                         namespace to set a value from.  If NULL, then the default
 768                         token space is used.
 769   @param[in]  TokenNumber   The PCD token number to monitor.
 770   @param[in]  NotificationFunction  The function to call when the token
 771                                     specified by Guid and TokenNumber is set.
 772
 773 **/
 774 VOID
 775 EFIAPI
 776 LibPcdCallbackOnSet (
 777   IN CONST GUID               *Guid,       OPTIONAL
 778   IN UINTN                    TokenNumber,
 779   IN PCD_CALLBACK             NotificationFunction
 780   )
 781 {
 782   ASSERT (FALSE);
 783 }
 784
 785
 786
 787 /**
 788   Disable a notification function that was established with LibPcdCallbackonSet().
 789
 790   Disable a notification function that was previously established with LibPcdCallbackOnSet().
 791
 792   If NotificationFunction is NULL, then ASSERT().
 793   If LibPcdCallbackOnSet() was not previously called with Guid, TokenNumber,
 794   and NotificationFunction, then ASSERT().
 795
 796   @param[in]  Guid          Specify the GUID token space.
 797   @param[in]  TokenNumber   Specify the token number.
 798   @param[in]  NotificationFunction The callback function to be unregistered.
 799
 800 **/
 801 VOID
 802 EFIAPI
 803 LibPcdCancelCallback (
 804   IN CONST GUID               *Guid,       OPTIONAL
 805   IN UINTN                    TokenNumber,
 806   IN PCD_CALLBACK             NotificationFunction
 807   )
 808 {
 809   ASSERT (FALSE);
 810 }
 811
 812
 813
 814 /**
 815   Retrieves the next token in a token space.
 816
 817   Retrieves the next PCD token number from the token space specified by Guid.
 818   If Guid is NULL, then the default token space is used.  If TokenNumber is 0,
 819   then the first token number is returned.  Otherwise, the token number that
 820   follows TokenNumber in the token space is returned.  If TokenNumber is the last
 821   token number in the token space, then 0 is returned.
 822
 823   If TokenNumber is not 0 and is not in the token space specified by Guid, then ASSERT().
 824
 825   @param[in]  Guid        Pointer to a 128-bit unique value that designates which namespace
 826                           to set a value from.  If NULL, then the default token space is used.
 827   @param[in]  TokenNumber The previous PCD token number.  If 0, then retrieves the first PCD
 828                           token number.
 829
 830   @return The next valid token number.
 831
 832 **/
 833 UINTN
 834 EFIAPI
 835 LibPcdGetNextToken (
 836   IN CONST GUID               *Guid,       OPTIONAL
 837   IN UINTN                    TokenNumber
 838   )
 839 {
 840   ASSERT (FALSE);
 841
 842   return 0;
 843 }
 844
 845
 846
 847 /**
 848   Used to retrieve the list of available PCD token space GUIDs.
 849
 850   Returns the PCD token space GUID that follows TokenSpaceGuid in the list of token spaces
 851   in the platform.
 852   If TokenSpaceGuid is NULL, then a pointer to the first PCD token spaces returned.
 853   If TokenSpaceGuid is the last PCD token space GUID in the list, then NULL is returned.
 854
 855   @param  TokenSpaceGuid  Pointer to the a PCD token space GUID
 856
 857   @return The next valid token namespace.
 858
 859 **/
 860 GUID *
 861 EFIAPI
 862 LibPcdGetNextTokenSpace (
 863   IN CONST GUID  *TokenSpaceGuid
 864   )
 865 {
 866   ASSERT (FALSE);
 867
 868   return NULL;
 869 }
 870
 871
 872 /**
 873   Sets a value of a patchable PCD entry that is type pointer.
 874
 875   Sets the PCD entry specified by PatchVariable to the value specified by Buffer
 876   and SizeOfBuffer.  Buffer is returned.  If SizeOfBuffer is greater than
 877   MaximumDatumSize, then set SizeOfBuffer to MaximumDatumSize and return
 878   NULL to indicate that the set operation was not actually performed.
 879   If SizeOfBuffer is set to MAX_ADDRESS, then SizeOfBuffer must be set to
 880   MaximumDatumSize and NULL must be returned.
 881
 882   If PatchVariable is NULL, then ASSERT().
 883   If SizeOfBuffer is NULL, then ASSERT().
 884   If SizeOfBuffer > 0 and Buffer is NULL, then ASSERT().
 885
 886   @param[in] PatchVariable      A pointer to the global variable in a module that is
 887                                 the target of the set operation.
 888   @param[in] MaximumDatumSize   The maximum size allowed for the PCD entry specified by PatchVariable.
 889   @param[in, out] SizeOfBuffer  A pointer to the size, in bytes, of Buffer.
 890   @param[in] Buffer             A pointer to the buffer to used to set the target variable.
 891
 892   @return Return the pointer to the buffer been set.
 893
 894 **/
 895 VOID *
 896 EFIAPI
 897 LibPatchPcdSetPtr (
 898   IN        VOID        *PatchVariable,
 899   IN        UINTN       MaximumDatumSize,
 900   IN OUT    UINTN       *SizeOfBuffer,
 901   IN CONST  VOID        *Buffer
 902   )
 903 {
 904   ASSERT (PatchVariable != NULL);
 905   ASSERT (SizeOfBuffer  != NULL);
 906
 907   if (*SizeOfBuffer > 0) {
 908     ASSERT (Buffer != NULL);
 909   }
 910
 911   if ((*SizeOfBuffer > MaximumDatumSize) ||
 912       (*SizeOfBuffer == MAX_ADDRESS)) {
 913     *SizeOfBuffer = MaximumDatumSize;
 914     return NULL;
 915   }
 916
 917   CopyMem (PatchVariable, Buffer, *SizeOfBuffer);
 918
 919   return (VOID *) Buffer;
 920 }
 921