Tools/Source/GenBuild/org/tianocore/build/pcd/entity/Token.java

   1 /** @file
   2   Token class.
   3
   4   This module contains all classes releted to PCD token.
   5
   6 Copyright (c) 2006, Intel Corporation
   7 All rights reserved. This program and the accompanying materials
   8 are licensed and made available under the terms and conditions of the BSD License
   9 which accompanies this distribution.  The full text of the license may be found at
  10 http://opensource.org/licenses/bsd-license.php
  11
  12 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16 package org.tianocore.build.pcd.entity;
  17
  18 import java.math.BigInteger;
  19 import java.util.ArrayList;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.UUID;
  24
  25 import org.tianocore.build.pcd.exception.EntityException;
  26
  27 /** This class is to descript a PCD token object. The information of a token mainly
  28     comes from MSA, SPD and setting produced by platform developer.
  29 **/
  30 public class Token {
  31     ///
  32     /// Enumeration macro defintion for PCD type.
  33     /// BUGBUG: Not use upcase charater is to facility for reading. It may be changed
  34     ///         in coding review.
  35     public enum             PCD_TYPE {FEATURE_FLAG, FIXED_AT_BUILD, PATCHABLE_IN_MODULE, DYNAMIC,
  36                                       DYNAMIC_EX, UNKNOWN}
  37
  38     ///
  39     /// Enumeration macro definition for datum type. All type mainly comes from ProcessBind.h.
  40     /// Wizard maybe expand this type as "int, unsigned int, short, unsigned short etc" in
  41     /// prompt dialog.
  42     ///
  43     public enum             DATUM_TYPE {UINT8, UINT16, UINT32, UINT64, BOOLEAN, POINTER, UNKNOWN}
  44
  45     ///
  46     /// Enumeration macor defintion for usage of PCD
  47     ///
  48     public enum             PCD_USAGE {ALWAYS_PRODUCED, ALWAYS_CONSUMED, SOMETIMES_PRODUCED,
  49                                        SOMETIMES_CONSUMED, UNKNOWN}
  50
  51     ///
  52     /// cName is to identify a PCD entry and will be used for generating autogen.h/autogen.c.
  53     /// cName will be defined in MSA, SPD and FPD, can be regarded as primary key with token space guid.
  54     ///
  55     public String           cName;
  56
  57     ///
  58     /// Token space name is the guid defined by token itself in package or module level. This
  59     /// name mainly for DynamicEx type. For other PCD type token, his token space name is the
  60     /// assignedtokenSpaceName as follows.
  61     /// tokenSpaceName is defined in MSA, SPD, FPD, can be regarded as primary key with cName.
  62     ///
  63     public UUID             tokenSpaceName;
  64
  65     ///
  66     /// tokenNumber is allocated by platform. tokenNumber indicate an index for this token in
  67     /// platform token space. For Dynamic, dynamicEx type, this number will be re-adjust by
  68     /// PCD run-time database autogen tools.
  69     ///
  70     public long              tokenNumber;
  71
  72     ///
  73     /// This token number is retrieved from FPD file for DynamicEx type.
  74     ///
  75     public long              dynamicExTokenNumber;
  76
  77     ///
  78     /// All supported PCD type, this value can be retrieved from SPD
  79     /// Currently, only record all PCD type for this token in FPD file.
  80     ///
  81     public List<PCD_TYPE>   supportedPcdType;
  82
  83     ///
  84     /// If the token's item type is Dynamic or DynamicEx type, isDynamicPCD
  85     /// is true.
  86     ///
  87     public boolean          isDynamicPCD;
  88
  89     ///
  90     /// datumSize is to descript the fix size or max size for this token.
  91     /// datumSize is defined in SPD.
  92     ///
  93     public int              datumSize;
  94
  95     ///
  96     /// datum type is to descript what type can be expressed by a PCD token.
  97     /// For same PCD used in different module, the datum type should be unique.
  98     /// So it belong memeber to Token class.
  99     ///
 100     public DATUM_TYPE       datumType;
 101
 102     ///
 103     /// skuData contains all value for SkuNumber of token.
 104     /// This field is for Dynamic or DynamicEx type PCD,
 105     ///
 106     public List<SkuInstance> skuData;
 107
 108     ///
 109     /// consumers array record all module private information who consume this PCD token.
 110     ///
 111     public Map<String, UsageInstance>  consumers;
 112
 113     public Token(String cName, UUID tokenSpaceName) {
 114         UUID    nullUUID = new UUID(0, 0);
 115
 116         this.cName                  = cName;
 117         this.tokenSpaceName         = (tokenSpaceName == null) ? nullUUID : tokenSpaceName;
 118         this.tokenNumber            = 0;
 119         this.datumType              = DATUM_TYPE.UNKNOWN;
 120         this.datumSize              = -1;
 121         this.skuData                = new ArrayList<SkuInstance>();
 122
 123         this.consumers              = new HashMap<String, UsageInstance>();
 124         this.supportedPcdType       = new ArrayList<PCD_TYPE>();
 125     }
 126
 127     /**
 128       updateSupportPcdType
 129
 130       SupportPcdType should be gotten from SPD file actually, but now it just
 131       record all PCD type for this token in FPD file.
 132
 133       @param pcdType    new PCD type found in FPD file for this token.
 134     **/
 135     public void updateSupportPcdType(PCD_TYPE pcdType) {
 136         int     index = 0;
 137         boolean found = false;
 138         for (index = 0; index < this.supportedPcdType.size(); index ++) {
 139             if (this.supportedPcdType.get(index) == pcdType) {
 140                 found = true;
 141                 break;
 142             }
 143         }
 144         if (!found) {
 145             this.supportedPcdType.add(pcdType);
 146         }
 147     }
 148
 149     /**
 150        Judge whether pcdType is belong to dynamic type. Dynamic type includes
 151        DYNAMIC and DYNAMIC_EX.
 152
 153        @param pcdType
 154
 155        @return boolean
 156      */
 157     public static boolean isDynamic(PCD_TYPE pcdType) {
 158         if ((pcdType == PCD_TYPE.DYNAMIC   ) ||
 159             (pcdType == PCD_TYPE.DYNAMIC_EX)) {
 160             return true;
 161         }
 162
 163         return false;
 164     }
 165
 166     public boolean isDynamicEx() {
 167
 168         for (int i = 0; i < supportedPcdType.size(); i++) {
 169             if (supportedPcdType.get(i) == PCD_TYPE.DYNAMIC_EX) {
 170                 return true;
 171             }
 172         }
 173
 174         return false;
 175     }
 176
 177     /**
 178       Use "TokencName + "-" + SpaceTokenName" as primary key when adding token into database
 179
 180       @param   cName                     Token name.
 181       @param   tokenSpaceName            The token space guid defined in MSA or SPD
 182       @param   platformtokenSpaceName    The token space guid for current platform token space,
 183
 184       @return  primary key for this token in token database.
 185     **/
 186     public static String getPrimaryKeyString(String cName, UUID tokenSpaceName) {
 187         UUID  nullUUID = new UUID(0, 0);
 188
 189         if (tokenSpaceName == null) {
 190             return cName + "_" + nullUUID.toString().replace('-', '_');
 191         } else {
 192             return cName + "_" + tokenSpaceName.toString().replace('-', '_');
 193         }
 194     }
 195
 196     /**
 197        If skudata list contains more than one data, then Sku mechanism is enable.
 198
 199        @return boolean
 200      */
 201     public boolean isSkuEnable() {
 202         if (this.skuData.size() > 1) {
 203             return true;
 204         }
 205         return false;
 206     }
 207
 208     public boolean isHiiEnable() {
 209         if (getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {
 210             return true;
 211         }
 212         return false;
 213     }
 214
 215     public boolean isVpdEnable() {
 216         if (getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {
 217             return true;
 218         }
 219         return false;
 220     }
 221
 222     /**
 223        Get the token primary key in token database.
 224
 225        @return String
 226      */
 227     public String getPrimaryKeyString () {
 228         return Token.getPrimaryKeyString(cName, tokenSpaceName);
 229     }
 230
 231     /**
 232       Judge datumType is valid
 233
 234       @param type  The datumType want to be judged.
 235
 236       @retval TRUE  - The type is valid.
 237       @retval FALSE - The type is invalid.
 238     **/
 239     public static boolean isValiddatumType(DATUM_TYPE type) {
 240         if ((type.ordinal() < DATUM_TYPE.UINT8.ordinal() ) ||
 241             (type.ordinal() > DATUM_TYPE.POINTER.ordinal())) {
 242             return false;
 243         }
 244         return true;
 245     }
 246
 247     /**
 248       Judge pcdType is valid
 249
 250       @param  type The PCdType want to be judged.
 251
 252       @retval TRUE  - The type is valid.
 253       @retval FALSE - The type is invalid.
 254     **/
 255     public static boolean isValidpcdType(PCD_TYPE  type) {
 256         if ((type.ordinal() < PCD_TYPE.FEATURE_FLAG.ordinal() ) ||
 257             (type.ordinal() > PCD_TYPE.DYNAMIC_EX.ordinal())) {
 258             return false;
 259         }
 260         return true;
 261     }
 262
 263     /**
 264       Add an usage instance for token
 265
 266       @param usageInstance   The usage instance
 267
 268       @retval TRUE  - Success to add usage instance.
 269       @retval FALSE - Fail to add usage instance
 270     **/
 271     public boolean addUsageInstance(UsageInstance usageInstance)
 272         throws EntityException {
 273         String exceptionStr;
 274
 275         if (isUsageInstanceExist(usageInstance.moduleName,
 276                                  usageInstance.moduleGUID,
 277                                  usageInstance.packageName,
 278                                  usageInstance.packageGUID,
 279                                  usageInstance.arch,
 280                                  usageInstance.version)) {
 281             exceptionStr = String.format("PCD %s for module %s has already exist in database, Please check all PCD build entries "+
 282                                          "in modules %s in <ModuleSA> to make sure no duplicated definitions!",
 283                                          usageInstance.parentToken.cName,
 284                                          usageInstance.moduleName,
 285                                          usageInstance.moduleName);
 286             throw new EntityException(exceptionStr);
 287         }
 288
 289         consumers.put(usageInstance.getPrimaryKey(), usageInstance);
 290         return true;
 291     }
 292
 293     /**
 294        Judge whether exist an usage instance for this token
 295
 296        @param moduleName    the name of module
 297        @param moduleGuid    the GUID name of modules
 298        @param packageName   the name of package contains this module
 299        @param packageGuid   the GUID name of package contains this module
 300        @param arch          the architecture string
 301        @param version       the version string
 302
 303        @return boolean      whether exist an usage instance for this token.
 304      */
 305     public boolean isUsageInstanceExist(String moduleName,
 306                                         UUID   moduleGuid,
 307                                         String packageName,
 308                                         UUID   packageGuid,
 309                                         String arch,
 310                                         String version) {
 311         String keyStr = UsageInstance.getPrimaryKey(moduleName,
 312                                                     moduleGuid,
 313                                                     packageName,
 314                                                     packageGuid,
 315                                                     arch,
 316                                                     version);
 317         return (consumers.get(keyStr) != null);
 318     }
 319
 320     /**
 321       Get the PCD_TYPE according to the string of PCD_TYPE
 322
 323       @param pcdTypeStr    The string of PCD_TYPE
 324
 325       @return PCD_TYPE
 326     **/
 327     public static PCD_TYPE getpcdTypeFromString(String pcdTypeStr) {
 328         if (pcdTypeStr == null) {
 329             return PCD_TYPE.UNKNOWN;
 330         }
 331
 332         if (pcdTypeStr.equalsIgnoreCase("FEATURE_FLAG")) {
 333             return PCD_TYPE.FEATURE_FLAG;
 334         } else if (pcdTypeStr.equalsIgnoreCase("FIXED_AT_BUILD")) {
 335             return PCD_TYPE.FIXED_AT_BUILD;
 336         } else if (pcdTypeStr.equalsIgnoreCase("PATCHABLE_IN_MODULE")) {
 337             return PCD_TYPE.PATCHABLE_IN_MODULE;
 338         } else if (pcdTypeStr.equalsIgnoreCase("DYNAMIC")) {
 339             return PCD_TYPE.DYNAMIC;
 340         } else if (pcdTypeStr.equalsIgnoreCase("DYNAMIC_EX")) {
 341             return PCD_TYPE.DYNAMIC_EX;
 342         } else {
 343             return PCD_TYPE.UNKNOWN;
 344         }
 345     }
 346
 347     /**
 348       Get the string of given datumType. This string will be used for generating autogen files
 349
 350       @param datumType   Given datumType
 351
 352       @return The string of datum type.
 353     **/
 354     public static String getStringOfdatumType(DATUM_TYPE  datumType) {
 355         switch (datumType) {
 356         case UINT8:
 357             return "UINT8";
 358         case UINT16:
 359             return "UINT16";
 360         case UINT32:
 361             return "UINT32";
 362         case UINT64:
 363             return "UINT64";
 364         case POINTER:
 365             return "POINTER";
 366         case BOOLEAN:
 367             return "BOOLEAN";
 368         }
 369         return "UNKNOWN";
 370     }
 371
 372     /**
 373       Get the datumType according to a string.
 374
 375       @param datumTypeStr    The string of datumType
 376
 377       @return DATUM_TYPE
 378     **/
 379     public static DATUM_TYPE getdatumTypeFromString(String datumTypeStr) {
 380         if (datumTypeStr.equalsIgnoreCase("UINT8")) {
 381             return DATUM_TYPE.UINT8;
 382         } else if (datumTypeStr.equalsIgnoreCase("UINT16")) {
 383             return DATUM_TYPE.UINT16;
 384         } else if (datumTypeStr.equalsIgnoreCase("UINT32")) {
 385             return DATUM_TYPE.UINT32;
 386         } else if (datumTypeStr.equalsIgnoreCase("UINT64")) {
 387             return DATUM_TYPE.UINT64;
 388         } else if (datumTypeStr.equalsIgnoreCase("VOID*")) {
 389             return DATUM_TYPE.POINTER;
 390         } else if (datumTypeStr.equalsIgnoreCase("BOOLEAN")) {
 391             return DATUM_TYPE.BOOLEAN;
 392         }
 393         return DATUM_TYPE.UNKNOWN;
 394     }
 395
 396     /**
 397       Get string of given pcdType
 398
 399       @param pcdType  The given PcdType
 400
 401       @return The string of PCD_TYPE.
 402     **/
 403     public static String getStringOfpcdType(PCD_TYPE pcdType) {
 404         switch (pcdType) {
 405         case FEATURE_FLAG:
 406             return "FEATURE_FLAG";
 407         case FIXED_AT_BUILD:
 408             return "FIXED_AT_BUILD";
 409         case PATCHABLE_IN_MODULE:
 410             return "PATCHABLE_IN_MODULE";
 411         case DYNAMIC:
 412             return "DYNAMIC";
 413         case DYNAMIC_EX:
 414             return "DYNAMIC_EX";
 415         }
 416         return "UNKNOWN";
 417     }
 418
 419     /**
 420       Get the PCD_USAGE according to a string
 421
 422       @param usageStr  The string of PCD_USAGE
 423
 424       @return The PCD_USAGE
 425     **/
 426     public static PCD_USAGE getUsageFromString(String usageStr) {
 427         if (usageStr == null) {
 428             return PCD_USAGE.UNKNOWN;
 429         }
 430
 431         if (usageStr.equalsIgnoreCase("ALWAYS_PRODUCED")) {
 432             return PCD_USAGE.ALWAYS_PRODUCED;
 433         } else if (usageStr.equalsIgnoreCase("SOMETIMES_PRODUCED")) {
 434             return PCD_USAGE.SOMETIMES_PRODUCED;
 435         } else if (usageStr.equalsIgnoreCase("ALWAYS_CONSUMED")) {
 436             return PCD_USAGE.ALWAYS_CONSUMED;
 437         } else if (usageStr.equalsIgnoreCase("SOMETIMES_CONSUMED")) {
 438             return PCD_USAGE.SOMETIMES_CONSUMED;
 439         }
 440
 441         return PCD_USAGE.UNKNOWN;
 442     }
 443
 444     /**
 445       Get the string of given PCD_USAGE
 446
 447       @param   usage   The given PCD_USAGE
 448
 449       @return The string of PDC_USAGE.
 450     **/
 451     public static String getStringOfUsage(PCD_USAGE usage) {
 452         switch (usage) {
 453         case ALWAYS_PRODUCED:
 454             return "ALWAYS_PRODUCED";
 455         case ALWAYS_CONSUMED:
 456             return "ALWAYS_CONSUMED";
 457         case SOMETIMES_PRODUCED:
 458             return "SOMETIMES_PRODUCED";
 459         case SOMETIMES_CONSUMED:
 460             return "SOMETIMES_CONSUMED";
 461         }
 462         return "UNKNOWN";
 463     }
 464
 465     /**
 466       Get the Defined datumType string for autogen. The string is for generating some MACROs in Autogen.h
 467
 468       @param datumType The given datumType
 469
 470       @return string of datum type for autogen.
 471     **/
 472     public static String GetAutogenDefinedatumTypeString(DATUM_TYPE datumType) {
 473         switch (datumType) {
 474
 475         case UINT8:
 476             return "8";
 477         case UINT16:
 478             return "16";
 479         case BOOLEAN:
 480             return "BOOL";
 481         case POINTER:
 482             return "PTR";
 483         case UINT32:
 484             return "32";
 485         case UINT64:
 486             return "64";
 487         default:
 488             return null;
 489         }
 490     }
 491
 492     /**
 493       Get the datumType String for Autogen. This string will be used for generating defintions of PCD token in autogen
 494
 495       @param datumType   The given datumType
 496
 497       @return string of datum type.
 498     **/
 499
 500     public static String getAutogendatumTypeString(DATUM_TYPE datumType) {
 501         switch (datumType) {
 502         case UINT8:
 503             return "UINT8";
 504         case UINT16:
 505             return "UINT16";
 506         case UINT32:
 507             return "UINT32";
 508         case UINT64:
 509             return "UINT64";
 510         case POINTER:
 511             return "VOID*";
 512         case BOOLEAN:
 513             return "BOOLEAN";
 514         }
 515         return null;
 516     }
 517
 518     /**
 519       Get the datumType string for generating some MACROs in autogen file of Library
 520
 521       @param   datumType  The given datumType
 522
 523       @return String of datum for genrating bit charater.
 524     **/
 525     public static String getAutogenLibrarydatumTypeString(DATUM_TYPE datumType) {
 526         switch (datumType) {
 527         case UINT8:
 528             return "8";
 529         case UINT16:
 530             return "16";
 531         case BOOLEAN:
 532             return "Bool";
 533         case POINTER:
 534             return "Ptr";
 535         case UINT32:
 536             return "32";
 537         case UINT64:
 538             return "64";
 539         default:
 540             return null;
 541         }
 542     }
 543
 544     /**
 545       UUID defined in Schems is object, this function is to tranlate this object
 546       to UUID data.
 547
 548       @param uuidObj The object comes from schema.
 549
 550       @return The traslated UUID instance.
 551     **/
 552     public static UUID getGUIDFromSchemaObject(Object uuidObj) {
 553         UUID uuid;
 554         if (uuidObj.toString().equalsIgnoreCase("0")) {
 555             uuid = new UUID(0,0);
 556         } else {
 557             uuid = UUID.fromString(uuidObj.toString());
 558         }
 559
 560         return uuid;
 561     }
 562
 563     public DynamicTokenValue getDefaultSku() {
 564         DynamicTokenValue dynamicData;
 565         int               index;
 566         for (index = 0; index < this.skuData.size(); index ++) {
 567             if (skuData.get(index).id == 0) {
 568                 return skuData.get(index).value;
 569             }
 570         }
 571
 572         return null;
 573     }
 574
 575     public int getSkuIdCount () {
 576         return this.skuData.size();
 577     }
 578
 579     private void getCurrentSizeFromDefaultValue (String str, ArrayList<Integer> al) {
 580         if (isValidNullValue(str)) {
 581             al.add(new Integer(0));
 582         } else {
 583             //
 584             // isValidNullValue has already make sure that str here
 585             // always contain a valid default value of the following 3
 586             // cases:
 587             // 1) "Hello world" //Assci string
 588             // 2) L"Hello" //Unicode string
 589             // 3) {0x01, 0x02, 0x03} //Byte stream
 590             //
 591             if (str.startsWith("\"")) {
 592                 al.add(new Integer(str.length() - 2));
 593             } else if (str.startsWith("L\"")){
 594                 //
 595                 // Unicode is 2 bytes each.
 596                 //
 597                 al.add(new Integer((str.length() - 3) * 2));
 598             } else if (str.startsWith("{")) {
 599                 //
 600                 // We count the number of "," in the string.
 601                 // The number of byte is one plus the number of
 602                 // comma.
 603                 //
 604                 String str2 = str;
 605
 606                 int cnt = 0;
 607                 int pos = 0;
 608                 pos = str2.indexOf(",", 0);
 609                 while (pos != -1) {
 610                     cnt++;
 611                     pos++;
 612                     pos = str2.indexOf(",", pos);
 613                 }
 614                 cnt++;
 615                 al.add(new Integer(cnt));
 616             }
 617         }
 618     }
 619     //
 620     // This method can be used to get the MAX and current size
 621     // for pointer type dynamic(ex) PCD entry
 622     //
 623     public ArrayList<Integer> getPointerTypeSize () {
 624         ArrayList<Integer> al = new ArrayList<Integer>();
 625
 626         //
 627         // For VPD_enabled and HII_enabled, we can only return the MAX size.
 628         // For the default DATA type dynamic PCD entry, we will return
 629         // the MAX size and current size for each SKU_ID.
 630         //
 631         al.add(new Integer(this.datumSize));
 632
 633         if (!this.isVpdEnable()) {
 634             int idx;
 635             if (this.isHiiEnable()){
 636                 for (idx = 0; idx < this.skuData.size(); idx++) {
 637                     String str = this.skuData.get(idx).value.hiiDefaultValue;
 638                     getCurrentSizeFromDefaultValue(str, al);
 639                 }
 640             } else {
 641                 for (idx = 0; idx < this.skuData.size(); idx++) {
 642                     String str = this.skuData.get(idx).value.value;
 643                     getCurrentSizeFromDefaultValue(str, al);
 644                 }
 645             }
 646         }
 647
 648         return al;
 649     }
 650
 651     /**
 652        Get default value for a token, For HII type, HiiDefaultValue of default
 653        SKU 0 will be returned; For Default type, the defaultvalue of default SKU
 654        0 will be returned.
 655
 656        @return String
 657      */
 658     public String getDynamicDefaultValue() {
 659         DynamicTokenValue dynamicData = getDefaultSku();
 660         if (hasDefaultValue()) {
 661             switch (dynamicData.type) {
 662             case DEFAULT_TYPE:
 663                 return dynamicData.value;
 664             }
 665         }
 666
 667         return null;
 668     }
 669
 670     //
 671     // BugBug: We need change this algorithm accordingly when schema is updated
 672     //          to support no default value.
 673     //
 674     public boolean hasDefaultValue () {
 675         int               value         = 0;
 676         boolean           isInteger     = true;
 677         DynamicTokenValue dynamicValue  = null;
 678
 679         if (isSkuEnable()) {
 680             return true;
 681         }
 682
 683         if (this.isDynamicPCD) {
 684             dynamicValue = getDefaultSku();
 685             switch (dynamicValue.type) {
 686             case HII_TYPE:
 687                 return true;
 688             case VPD_TYPE:
 689                 return true;
 690             case DEFAULT_TYPE:
 691                 return !isValidNullValue(dynamicValue.value);
 692             }
 693         }
 694
 695         return false;
 696     }
 697
 698     public boolean isValidNullValue(String judgedValue) {
 699         String      subStr;
 700         BigInteger  bigIntValue;
 701
 702         switch (datumType) {
 703         case UINT8:
 704         case UINT16:
 705         case UINT32:
 706             if (judgedValue.length() > 2) {
 707                 if ((judgedValue.charAt(0) == '0')        &&
 708                     ((judgedValue.charAt(1) == 'x') || (judgedValue.charAt(1) == 'X'))){
 709                     subStr      = judgedValue.substring(2, judgedValue.length());
 710                     bigIntValue = new BigInteger(subStr, 16);
 711                 } else {
 712                     bigIntValue = new BigInteger(judgedValue);
 713                 }
 714             } else {
 715                 bigIntValue = new BigInteger(judgedValue);
 716             }
 717             if (bigIntValue.bitCount() == 0) {
 718                 return true;
 719             }
 720             break;
 721         case UINT64:
 722             if (judgedValue.length() > 2){
 723                 if ((judgedValue.charAt(0) == '0') &&
 724                     ((judgedValue.charAt(1) == 'x') ||
 725                      (judgedValue.charAt(1) == 'X'))) {
 726                     bigIntValue = new BigInteger(judgedValue.substring(2, judgedValue.length()),  16);
 727                     if (bigIntValue.bitCount() == 0) {
 728                         return true;
 729                     }
 730                 } else {
 731                     bigIntValue = new BigInteger(judgedValue);
 732                     if (bigIntValue.bitCount() == 0) {
 733                         return true;
 734                     }
 735                 }
 736             } else  {
 737                 bigIntValue = new BigInteger(judgedValue);
 738                 if (bigIntValue.bitCount() == 0) {
 739                     return true;
 740                 }
 741             }
 742             break;
 743         case BOOLEAN:
 744             if (judgedValue.equalsIgnoreCase("false")) {
 745                 return true;
 746             }
 747             break;
 748         case POINTER:
 749             if (judgedValue.equalsIgnoreCase("")        ||
 750                 judgedValue.equalsIgnoreCase("\"\"")   ||
 751                 judgedValue.equalsIgnoreCase("L\"\"")   ||
 752                 (judgedValue.length() == 0)             ||
 753                 judgedValue.equalsIgnoreCase("{}")) {
 754                 return true;
 755             }
 756         }
 757         return false;
 758     }
 759
 760     public boolean isHiiDefaultValueUnicodeStringType() {
 761         DynamicTokenValue dynamicData = getDefaultSku();
 762
 763         if (dynamicData == null)
 764             return false;
 765
 766         return dynamicData.hiiDefaultValue.startsWith("L\"")
 767                 && dynamicData.hiiDefaultValue.endsWith("\"");
 768     }
 769
 770     public boolean isHiiDefaultValueASCIIStringType() {
 771         DynamicTokenValue dynamicData = getDefaultSku();
 772
 773         if (dynamicData == null)
 774             return false;
 775
 776         return dynamicData.hiiDefaultValue.startsWith("\"")
 777         && dynamicData.hiiDefaultValue.endsWith("\"");
 778     }
 779
 780     /**
 781        Judege whether current value is UNICODE string type.
 782        @return boolean
 783      */
 784     public boolean isUnicodeStringType () {
 785         String str = getDynamicDefaultValue();
 786
 787         if (str == null) {
 788             return false;
 789         }
 790
 791         if (datumType == Token.DATUM_TYPE.POINTER &&
 792             str.startsWith("L\"") &&
 793             str.endsWith("\"")) {
 794             return true;
 795         }
 796
 797         return false;
 798     }
 799
 800     public boolean isASCIIStringType () {
 801         String str = getDynamicDefaultValue();
 802
 803         if (str == null) {
 804             return false;
 805         }
 806
 807         if (datumType == Token.DATUM_TYPE.POINTER &&
 808             str.startsWith("\"") &&
 809             str.endsWith("\"")) {
 810             return true;
 811         }
 812
 813         return false;
 814     }
 815
 816     public boolean isByteStreamType () {
 817         String str = getDynamicDefaultValue();
 818
 819         if (str == null) {
 820             return false;
 821         }
 822
 823         if (datumType == Token.DATUM_TYPE.POINTER &&
 824             str.startsWith("{") &&
 825             str.endsWith("}")) {
 826             return true;
 827         }
 828
 829         return false;
 830
 831     }
 832
 833     public String getStringTypeString () {
 834         return getDefaultSku().value.substring(2, getDefaultSku().value.length() - 1);
 835     }
 836 }
 837
 838
 839
 840