Remove unused PCD file.
[mirror_edk2.git] / 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