Tools/Source/GenBuild/org/tianocore/build/pcd/action/CollectPCDAction.java

   1 /** @file
   2   CollectPCDAction class.
   3
   4   This action class is to collect PCD information from MSA, SPD, FPD xml file.
   5   This class will be used for wizard and build tools, So it can *not* inherit
   6   from buildAction or wizardAction.
   7
   8 Copyright (c) 2006, Intel Corporation
   9 All rights reserved. This program and the accompanying materials
  10 are licensed and made available under the terms and conditions of the BSD License
  11 which accompanies this distribution.  The full text of the license may be found at
  12 http://opensource.org/licenses/bsd-license.php
  13
  14 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  15 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  16
  17 **/
  18 package org.tianocore.build.pcd.action;
  19
  20 import java.io.BufferedReader;
  21 import java.io.File;
  22 import java.io.FileReader;
  23 import java.io.IOException;
  24 import java.math.BigInteger;
  25 import java.util.ArrayList;
  26 import java.util.Collections;
  27 import java.util.Comparator;
  28 import java.util.HashMap;
  29 import java.util.List;
  30 import java.util.Map;
  31 import java.util.UUID;
  32
  33 import org.apache.xmlbeans.XmlException;
  34 import org.apache.xmlbeans.XmlObject;
  35 import org.tianocore.DynamicPcdBuildDefinitionsDocument;
  36 import org.tianocore.DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions;
  37 import org.tianocore.DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData;
  38 import org.tianocore.DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo;
  39 import org.tianocore.FrameworkModulesDocument;
  40 import org.tianocore.FrameworkPlatformDescriptionDocument;
  41 import org.tianocore.FrameworkPlatformDescriptionDocument.FrameworkPlatformDescription;
  42 import org.tianocore.ModuleSADocument;
  43 import org.tianocore.ModuleSADocument.ModuleSA;
  44 import org.tianocore.PackageSurfaceAreaDocument;
  45 import org.tianocore.PcdBuildDefinitionDocument.PcdBuildDefinition;
  46 import org.tianocore.build.global.GlobalData;
  47 import org.tianocore.build.global.SurfaceAreaQuery;
  48 import org.tianocore.build.pcd.action.ActionMessage;
  49 import org.tianocore.build.pcd.entity.DynamicTokenValue;
  50 import org.tianocore.build.pcd.entity.MemoryDatabaseManager;
  51 import org.tianocore.build.pcd.entity.SkuInstance;
  52 import org.tianocore.build.pcd.entity.Token;
  53 import org.tianocore.build.pcd.entity.UsageInstance;
  54 import org.tianocore.build.pcd.exception.EntityException;
  55
  56 class StringTable {
  57     private ArrayList<String>   al;
  58     private ArrayList<String>   alComments;
  59     private String              phase;
  60     int                         len;
  61     int                         bodyStart;
  62     int                         bodyLineNum;
  63
  64     public StringTable (String phase) {
  65         this.phase = phase;
  66         al = new ArrayList<String>();
  67         alComments = new ArrayList<String>();
  68         len = 0;
  69         bodyStart = 0;
  70         bodyLineNum = 0;
  71     }
  72
  73     public String getSizeMacro () {
  74         return String.format(PcdDatabase.StringTableSizeMacro, phase, getSize());
  75     }
  76
  77     private int getSize () {
  78         //
  79         // We have at least one Unicode Character in the table.
  80         //
  81         return len == 0 ? 1 : len;
  82     }
  83
  84     public int getTableLen () {
  85         return al.size() == 0 ? 1 : al.size();
  86     }
  87
  88     public String getExistanceMacro () {
  89         return String.format(PcdDatabase.StringTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
  90     }
  91
  92     public String getTypeDeclaration () {
  93
  94         String output;
  95
  96         final String stringTable = "StringTable";
  97         final String tab = "\t";
  98         final String newLine = ";\r\n";
  99
 100         output =  "/* StringTable */\r\n";
 101
 102         if (al.size() == 0) {
 103             output += tab + String.format("UINT16 %s[1] /* StringTable is Empty */", stringTable) + newLine;
 104         }
 105
 106         for (int i = 0; i < al.size(); i++) {
 107             String str = al.get(i);
 108
 109             if (i == 0) {
 110                 //
 111                 // StringTable is a well-known name in the PCD DXE driver
 112                 //
 113                 output += tab + String.format("UINT16       %s[%d] /* %s */", stringTable, str.length() + 1, alComments.get(i)) + newLine;
 114             } else {
 115                 output += tab + String.format("UINT16       %s_%d[%d] /* %s */", stringTable, i, str.length() + 1, alComments.get(i)) + newLine;
 116             }
 117         }
 118
 119         return output;
 120
 121     }
 122
 123     public ArrayList<String> getInstantiation () {
 124         ArrayList<String> output = new ArrayList<String>();
 125
 126         output.add("/* StringTable */");
 127
 128         if (al.size() == 0) {
 129             output.add("{ 0 }");
 130         } else {
 131             String str;
 132
 133             for (int i = 0; i < al.size(); i++) {
 134                 str = String.format("L\"%s\" /* %s */", al.get(i), alComments.get(i));
 135                 if (i != al.size() - 1) {
 136                     str += ",";
 137                 }
 138                 output.add(str);
 139             }
 140         }
 141
 142         return output;
 143     }
 144
 145     public int add (String str, Token token) {
 146         int i;
 147
 148         i = len;
 149         //
 150         // Include the NULL character at the end of String
 151         //
 152         len += str.length() + 1;
 153         al.add(str);
 154         alComments.add(token.getPrimaryKeyString());
 155
 156         return i;
 157     }
 158 }
 159
 160 class SizeTable {
 161     private ArrayList<Integer>  al;
 162     private ArrayList<String>   alComments;
 163     private String              phase;
 164     private int                 len;
 165     private int             bodyStart;
 166     private int             bodyLineNum;
 167
 168     public SizeTable (String phase) {
 169         this.phase = phase;
 170         al = new ArrayList<Integer>();
 171         alComments = new ArrayList<String>();
 172         len = 0;
 173         bodyStart = 0;
 174         bodyLineNum = 0;
 175     }
 176
 177     public String getTypeDeclaration () {
 178         return String.format(PcdDatabase.SizeTableDeclaration, phase);
 179     }
 180
 181     public ArrayList<String> getInstantiation () {
 182         ArrayList<String> Output = new ArrayList<String>();
 183
 184         Output.add("/* SizeTable */");
 185         Output.add("{");
 186         bodyStart = 2;
 187
 188         if (al.size() == 0) {
 189             Output.add("0");
 190         } else {
 191             for (int index = 0; index < al.size(); index++) {
 192                 Integer n = al.get(index);
 193                 String str = n.toString();
 194
 195                 if (index != (al.size() - 1)) {
 196                     str += ",";
 197                 }
 198
 199                 str += " /* " + alComments.get(index) + " */";
 200                 Output.add(str);
 201                 bodyLineNum++;
 202
 203             }
 204         }
 205         Output.add("}");
 206
 207         return Output;
 208     }
 209
 210     public int getBodyStart() {
 211         return bodyStart;
 212     }
 213
 214     public int getBodyLineNum () {
 215         return bodyLineNum;
 216     }
 217
 218     public int add (Token token) {
 219         int index = len;
 220
 221         len++;
 222         al.add(token.datumSize);
 223         alComments.add(token.getPrimaryKeyString());
 224
 225         return index;
 226     }
 227
 228     private int getDatumSize(Token token) {
 229         /*
 230         switch (token.datumType) {
 231         case Token.DATUM_TYPE.UINT8:
 232             return 1;
 233         default:
 234             return 0;
 235         }
 236         */
 237         return 0;
 238     }
 239
 240     public int getTableLen () {
 241         return al.size() == 0 ? 1 : al.size();
 242     }
 243
 244 }
 245
 246 class GuidTable {
 247     private ArrayList<UUID> al;
 248     private ArrayList<String> alComments;
 249     private String          phase;
 250     private int             len;
 251     private int             bodyStart;
 252     private int             bodyLineNum;
 253
 254     public GuidTable (String phase) {
 255         this.phase = phase;
 256         al = new ArrayList<UUID>();
 257         alComments = new ArrayList<String>();
 258         len = 0;
 259         bodyStart = 0;
 260         bodyLineNum = 0;
 261     }
 262
 263     public String getSizeMacro () {
 264         return String.format(PcdDatabase.GuidTableSizeMacro, phase, getSize());
 265     }
 266
 267     private int getSize () {
 268         return (al.size() == 0)? 1 : al.size();
 269     }
 270
 271     public String getExistanceMacro () {
 272         return String.format(PcdDatabase.GuidTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 273     }
 274
 275     public String getTypeDeclaration () {
 276         return String.format(PcdDatabase.GuidTableDeclaration, phase);
 277     }
 278
 279     private String getUuidCString (UUID uuid) {
 280         String[]  guidStrArray;
 281
 282         guidStrArray =(uuid.toString()).split("-");
 283
 284         return String.format("{ 0x%s, 0x%s, 0x%s, { 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s } }",
 285                                          guidStrArray[0],
 286                                          guidStrArray[1],
 287                                          guidStrArray[2],
 288                                         (guidStrArray[3].substring(0, 2)),
 289                                         (guidStrArray[3].substring(2, 4)),
 290                                         (guidStrArray[4].substring(0, 2)),
 291                                         (guidStrArray[4].substring(2, 4)),
 292                                         (guidStrArray[4].substring(4, 6)),
 293                                         (guidStrArray[4].substring(6, 8)),
 294                                         (guidStrArray[4].substring(8, 10)),
 295                                         (guidStrArray[4].substring(10, 12))
 296                                         );
 297     }
 298
 299     public ArrayList<String> getInstantiation () {
 300         ArrayList<String> Output = new ArrayList<String>();
 301
 302         Output.add("/* GuidTable */");
 303         Output.add("{");
 304         bodyStart = 2;
 305
 306         if (al.size() == 0) {
 307             Output.add(getUuidCString(new UUID(0, 0)));
 308         }
 309
 310         for (Object u : al) {
 311             UUID uuid = (UUID)u;
 312             String str = getUuidCString(uuid);
 313
 314             if (al.indexOf(u) != (al.size() - 1)) {
 315                 str += ",";
 316             }
 317             Output.add(str);
 318             bodyLineNum++;
 319
 320         }
 321         Output.add("}");
 322
 323         return Output;
 324     }
 325
 326     public int getBodyStart() {
 327         return bodyStart;
 328     }
 329
 330     public int getBodyLineNum () {
 331         return bodyLineNum;
 332     }
 333
 334     public int add (UUID uuid, String name) {
 335         int index = len;
 336         //
 337         // Include the NULL character at the end of String
 338         //
 339         len++;
 340         al.add(uuid);
 341
 342         return index;
 343     }
 344
 345     public int getTableLen () {
 346         return al.size() == 0 ? 0 : al.size();
 347     }
 348
 349 }
 350
 351 class SkuIdTable {
 352     private ArrayList<Integer[]> al;
 353     private ArrayList<String>    alComment;
 354     private String               phase;
 355     private int                  len;
 356     private int                   bodyStart;
 357     private int                   bodyLineNum;
 358
 359     public SkuIdTable (String phase) {
 360         this.phase = phase;
 361         al = new ArrayList<Integer[]>();
 362         alComment = new ArrayList<String>();
 363         bodyStart = 0;
 364         bodyLineNum = 0;
 365         len = 0;
 366     }
 367
 368     public String getSizeMacro () {
 369         return String.format(PcdDatabase.SkuIdTableSizeMacro, phase, getSize());
 370     }
 371
 372     private int getSize () {
 373         return (al.size() == 0)? 1 : al.size();
 374     }
 375
 376     public String getExistanceMacro () {
 377         return String.format(PcdDatabase.SkuTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 378     }
 379
 380     public String getTypeDeclaration () {
 381         return String.format(PcdDatabase.SkuIdTableDeclaration, phase);
 382     }
 383
 384     public ArrayList<String> getInstantiation () {
 385         ArrayList<String> Output = new ArrayList<String> ();
 386
 387         Output.add("/* SkuIdTable */");
 388         Output.add("{");
 389         bodyStart = 2;
 390
 391         if (al.size() == 0) {
 392             Output.add("0");
 393         }
 394
 395         for (int index = 0; index < al.size(); index++) {
 396             String str;
 397
 398             str = "/* " + alComment.get(index) + "*/ ";
 399             str += "/* MaxSku */ ";
 400
 401
 402             Integer[] ia = al.get(index);
 403
 404             str += ia[0].toString() + ", ";
 405             for (int index2 = 1; index2 < ia.length; index2++) {
 406                str += ia[index2].toString();
 407                if (index != al.size() - 1) {
 408                    str += ", ";
 409                }
 410             }
 411
 412             Output.add(str);
 413             bodyLineNum++;
 414
 415         }
 416
 417         Output.add("}");
 418
 419         return Output;
 420     }
 421
 422     public int add (Token token) {
 423
 424         int index;
 425
 426         Integer [] skuIds = new Integer[token.skuData.size() + 1];
 427         skuIds[0] = new Integer(token.skuData.size());
 428         for (index = 1; index < skuIds.length; index++) {
 429             skuIds[index] = new Integer(token.skuData.get(index - 1).id);
 430         }
 431
 432         index = len;
 433
 434         len += skuIds.length;
 435         al.add(skuIds);
 436         alComment.add(token.getPrimaryKeyString());
 437
 438         return index;
 439     }
 440
 441     public int getTableLen () {
 442         return al.size() == 0 ? 1 : al.size();
 443     }
 444
 445 }
 446
 447 class LocalTokenNumberTable {
 448     private ArrayList<String>    al;
 449     private ArrayList<String>    alComment;
 450     private String               phase;
 451     private int                  len;
 452
 453     public LocalTokenNumberTable (String phase) {
 454         this.phase = phase;
 455         al = new ArrayList<String>();
 456         alComment = new ArrayList<String>();
 457
 458         len = 0;
 459     }
 460
 461     public String getSizeMacro () {
 462         return String.format(PcdDatabase.LocalTokenNumberTableSizeMacro, phase, getSize())
 463                         + String.format(PcdDatabase.LocalTokenNumberSizeMacro, phase, al.size());
 464     }
 465
 466     public int getSize () {
 467         return (al.size() == 0)? 1 : al.size();
 468     }
 469
 470     public String getExistanceMacro () {
 471         return String.format(PcdDatabase.DatabaseExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 472     }
 473
 474     public String getTypeDeclaration () {
 475         return String.format(PcdDatabase.LocalTokenNumberTableDeclaration, phase);
 476     }
 477
 478     public ArrayList<String> getInstantiation () {
 479         ArrayList<String> output = new ArrayList<String>();
 480
 481         output.add("/* LocalTokenNumberTable */");
 482         output.add("{");
 483
 484         if (al.size() == 0) {
 485             output.add("0");
 486         }
 487
 488         for (int index = 0; index < al.size(); index++) {
 489             String str;
 490
 491             str = (String)al.get(index);
 492
 493             str += " /* " + alComment.get(index) + " */ ";
 494
 495
 496             if (index != (al.size() - 1)) {
 497                 str += ",";
 498             }
 499
 500             output.add(str);
 501
 502         }
 503
 504         output.add("}");
 505
 506         return output;
 507     }
 508
 509     public int add (Token token) {
 510         int index = len;
 511         String str;
 512
 513         len++;
 514
 515         str =  String.format(PcdDatabase.offsetOfStrTemplate, phase, token.hasDefaultValue() ? "Init" : "Uninit", token.getPrimaryKeyString());
 516
 517         if (token.isUnicodeStringType()) {
 518             str += " | PCD_TYPE_STRING";
 519         }
 520
 521         if (token.isSkuEnable()) {
 522             str += " | PCD_TYPE_SKU_ENABLED";
 523         }
 524
 525         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {
 526             str += " | PCD_TYPE_HII";
 527         }
 528
 529         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {
 530             str += " | PCD_TYPE_VPD";
 531         }
 532
 533         al.add(str);
 534         alComment.add(token.getPrimaryKeyString());
 535
 536         return index;
 537     }
 538 }
 539
 540 class ExMapTable {
 541
 542     class ExTriplet {
 543         public Integer guidTableIdx;
 544         public Long exTokenNumber;
 545         public Long localTokenIdx;
 546
 547         public ExTriplet (int guidTableIdx, long exTokenNumber, long localTokenIdx) {
 548             this.guidTableIdx = new Integer(guidTableIdx);
 549             this.exTokenNumber = new Long(exTokenNumber);
 550             this.localTokenIdx = new Long(localTokenIdx);
 551         }
 552     }
 553
 554     private ArrayList<ExTriplet> al;
 555     private ArrayList<String>    alComment;
 556     private String               phase;
 557     private int                  len;
 558     private int                   bodyStart;
 559     private int                   bodyLineNum;
 560     private int                   base;
 561
 562     public ExMapTable (String phase) {
 563         this.phase = phase;
 564         al = new ArrayList<ExTriplet>();
 565         alComment = new ArrayList<String>();
 566         bodyStart = 0;
 567         bodyLineNum = 0;
 568         len = 0;
 569     }
 570
 571     public String getSizeMacro () {
 572         return String.format(PcdDatabase.ExMapTableSizeMacro, phase, getTableLen())
 573              + String.format(PcdDatabase.ExTokenNumber, phase, al.size());
 574     }
 575
 576     private int getSize () {
 577         return (al.size() == 0)? 1 : al.size();
 578     }
 579
 580     public String getExistanceMacro () {
 581         return String.format(PcdDatabase.ExMapTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 582     }
 583
 584     public String getTypeDeclaration () {
 585         return String.format(PcdDatabase.ExMapTableDeclaration, phase);
 586     }
 587
 588     public ArrayList<String> getInstantiation () {
 589         ArrayList<String> Output = new ArrayList<String>();
 590
 591         Output.add("/* ExMapTable */");
 592         Output.add("{");
 593         bodyStart = 2;
 594
 595         if (al.size() == 0) {
 596             Output.add("{0, 0, 0}");
 597         }
 598
 599         int index;
 600         for (index = 0; index < al.size(); index++) {
 601             String str;
 602
 603             ExTriplet e = (ExTriplet)al.get(index);
 604
 605             str = "{ " + e.exTokenNumber.toString() + ", ";
 606             str += e.localTokenIdx.toString() + ", ";
 607             str += e.guidTableIdx.toString();
 608
 609             str += " /* " + alComment.get(index) + " */";
 610
 611             if (index != al.size() - 1) {
 612                 str += ",";
 613             }
 614
 615             Output.add(str);
 616             bodyLineNum++;
 617
 618         }
 619
 620         Output.add("}");
 621
 622         return Output;
 623     }
 624
 625     public int add (int localTokenIdx, long exTokenNum, int guidTableIdx, String name) {
 626         int index = len;
 627
 628         len++;
 629         al.add(new ExTriplet(guidTableIdx, exTokenNum, localTokenIdx));
 630         alComment.add(name);
 631
 632         return index;
 633     }
 634
 635     public int getTableLen () {
 636         return al.size() == 0 ? 1 : al.size();
 637     }
 638
 639 }
 640
 641 class PcdDatabase {
 642
 643     public final static String ExMapTableDeclaration            = "DYNAMICEX_MAPPING ExMapTable[%s_EXMAPPING_TABLE_SIZE];\r\n";
 644     public final static String GuidTableDeclaration             = "EFI_GUID          GuidTable[%s_GUID_TABLE_SIZE];\r\n";
 645     public final static String LocalTokenNumberTableDeclaration = "UINT32            LocalTokenNumberTable[%s_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r\n";
 646     public final static String StringTableDeclaration           = "UINT16            StringTable[%s_STRING_TABLE_SIZE];\r\n";
 647     public final static String SizeTableDeclaration             = "UINT16            SizeTable[%s_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r\n";
 648     public final static String SkuIdTableDeclaration              = "UINT8             SkuIdTable[%s_SKUID_TABLE_SIZE];\r\n";
 649
 650
 651     public final static String ExMapTableSizeMacro              = "#define %s_EXMAPPING_TABLE_SIZE  %d\r\n";
 652     public final static String ExTokenNumber                    = "#define %s_EX_TOKEN_NUMBER       %d\r\n";
 653     public final static String GuidTableSizeMacro               = "#define %s_GUID_TABLE_SIZE         %d\r\n";
 654     public final static String LocalTokenNumberTableSizeMacro   = "#define %s_LOCAL_TOKEN_NUMBER_TABLE_SIZE            %d\r\n";
 655     public final static String LocalTokenNumberSizeMacro                = "#define %s_LOCAL_TOKEN_NUMBER            %d\r\n";
 656     public final static String StringTableSizeMacro             = "#define %s_STRING_TABLE_SIZE       %d\r\n";
 657     public final static String SkuIdTableSizeMacro              = "#define %s_SKUID_TABLE_SIZE        %d\r\n";
 658
 659
 660     public final static String ExMapTableExistenceMacro         = "#define %s_EXMAP_TABLE_EMPTY    %s\r\n";
 661     public final static String GuidTableExistenceMacro          = "#define %s_GUID_TABLE_EMPTY     %s\r\n";
 662     public final static String DatabaseExistenceMacro           = "#define %s_DATABASE_EMPTY       %s\r\n";
 663     public final static String StringTableExistenceMacro        = "#define %s_STRING_TABLE_EMPTY   %s\r\n";
 664     public final static String SkuTableExistenceMacro           = "#define %s_SKUID_TABLE_EMPTY    %s\r\n";
 665
 666     public final static String offsetOfSkuHeadStrTemplate       = "offsetof(%s_PCD_DATABASE, %s.%s_SkuDataTable)";
 667     public final static String offsetOfStrTemplate              = "offsetof(%s_PCD_DATABASE, %s.%s)";
 668
 669     private StringTable stringTable;
 670     private GuidTable   guidTable;
 671     private LocalTokenNumberTable localTokenNumberTable;
 672     private SkuIdTable  skuIdTable;
 673     private SizeTable   sizeTable;
 674     private ExMapTable  exMapTable;
 675
 676     private ArrayList<Token> alTokens;
 677     private String phase;
 678     private int assignedTokenNumber;
 679
 680     //
 681     // After Major changes done to the PCD
 682     // database generation class PcdDatabase
 683     // Please increment the version and please
 684     // also update the version number in PCD
 685     // service PEIM and DXE driver accordingly.
 686     //
 687     private final int version = 1;
 688
 689     private String hString;
 690     private String cString;
 691
 692
 693     class AlignmentSizeComp implements Comparator<Token> {
 694         public int compare (Token a, Token b) {
 695             return getAlignmentSize(b)
 696                     - getAlignmentSize(a);
 697         }
 698     }
 699
 700     public PcdDatabase (ArrayList<Token> alTokens, String exePhase, int startLen) {
 701        phase = exePhase;
 702
 703        stringTable = new StringTable(phase);
 704        guidTable = new GuidTable(phase);
 705        localTokenNumberTable = new LocalTokenNumberTable(phase);
 706        skuIdTable = new SkuIdTable(phase);
 707        sizeTable = new SizeTable(phase);
 708        exMapTable = new ExMapTable(phase);
 709
 710        assignedTokenNumber = startLen;
 711        this.alTokens = alTokens;
 712     }
 713
 714     private void getTwoGroupsOfTokens (ArrayList<Token> alTokens, List<Token> initTokens, List<Token> uninitTokens) {
 715         for (int i = 0; i < alTokens.size(); i++) {
 716             Token t = (Token)alTokens.get(i);
 717             if (t.hasDefaultValue()) {
 718                 initTokens.add(t);
 719             } else {
 720                 uninitTokens.add(t);
 721             }
 722         }
 723
 724         return;
 725     }
 726
 727     private int getAlignmentSize (Token token) {
 728         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {
 729             return 2;
 730         }
 731
 732         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {
 733             return 4;
 734         }
 735
 736         if (token.isUnicodeStringType()) {
 737             return 2;
 738         }
 739
 740         switch (token.datumType) {
 741             case UINT8:
 742                 return 1;
 743             case UINT16:
 744                 return 2;
 745             case UINT32:
 746                 return 4;
 747             case UINT64:
 748                 return 8;
 749             case POINTER:
 750                 return 1;
 751             case BOOLEAN:
 752                 return 1;
 753             }
 754             return 1;
 755      }
 756
 757     public String getCString () {
 758         return cString;
 759     }
 760
 761     public String getHString () {
 762         return hString;
 763     }
 764
 765      public void genCode ()
 766         throws EntityException {
 767
 768         final String newLine                        = "\r\n";
 769         final String declNewLine                    = ";\r\n";
 770         final String tab                            = "\t";
 771         final String commaNewLine                   = ", \r\n";
 772
 773         int i;
 774         ArrayList<String> decla;
 775         ArrayList<String> inst;
 776
 777         String macroStr   = "";
 778         String initDeclStr = "";
 779         String initInstStr = "";
 780         String uninitDeclStr = "";
 781
 782         List<Token> initTokens = new ArrayList<Token> ();
 783         List<Token> uninitTokens = new ArrayList<Token> ();
 784
 785         HashMap <String, ArrayList<String>> initCode = new HashMap<String, ArrayList<String>> ();
 786         HashMap <String, ArrayList<String>> uninitCode = new HashMap<String, ArrayList<String>> ();
 787
 788         getTwoGroupsOfTokens (alTokens, initTokens, uninitTokens);
 789
 790         //
 791         // Generate Structure Declaration for PcdTokens without Default Value
 792         // PEI_PCD_DATABASE_INIT
 793         //
 794         java.util.Comparator<Token> comparator = new AlignmentSizeComp();
 795         java.util.Collections.sort(initTokens, comparator);
 796         initCode = processTokens(initTokens);
 797
 798         //
 799         // Generate Structure Declaration for PcdTokens without Default Value
 800         // PEI_PCD_DATABASE_UNINIT
 801         //
 802         java.util.Collections.sort(uninitTokens, comparator);
 803         uninitCode = processTokens(uninitTokens);
 804
 805         //
 806         // Generate size info Macro for all Tables
 807         //
 808         macroStr += guidTable.getSizeMacro();
 809         macroStr += stringTable.getSizeMacro();
 810         macroStr += skuIdTable.getSizeMacro();
 811         macroStr += localTokenNumberTable.getSizeMacro();
 812         macroStr += exMapTable.getSizeMacro();
 813
 814         //
 815         // Generate existance info Macro for all Tables
 816         //
 817         macroStr += guidTable.getExistanceMacro();
 818         macroStr += stringTable.getExistanceMacro();
 819         macroStr += skuIdTable.getExistanceMacro();
 820         macroStr += localTokenNumberTable.getExistanceMacro();
 821         macroStr += exMapTable.getExistanceMacro();
 822
 823         //
 824         // Generate Structure Declaration for PcdTokens with Default Value
 825         // for example PEI_PCD_DATABASE_INIT
 826         //
 827         initDeclStr += "typedef struct {" + newLine;
 828             {
 829                 initDeclStr += tab + exMapTable.getTypeDeclaration();
 830                 initDeclStr += tab + guidTable.getTypeDeclaration();
 831                 initDeclStr += tab + localTokenNumberTable.getTypeDeclaration();
 832                 initDeclStr += tab + stringTable.getTypeDeclaration();
 833                 initDeclStr += tab + sizeTable.getTypeDeclaration();
 834                 initDeclStr += tab + skuIdTable.getTypeDeclaration();
 835                 if (phase.equalsIgnoreCase("PEI")) {
 836                     initDeclStr += tab + "SKU_ID            SystemSkuId;" + newLine;
 837                 }
 838
 839                 decla = initCode.get(new String("Declaration"));
 840                 for (i = 0; i < decla.size(); i++)  {
 841                     initDeclStr += tab + decla.get(i) + declNewLine;
 842                 }
 843
 844                 //
 845                 // Generate Structure Declaration for PcdToken with SkuEnabled
 846                 //
 847                 decla = initCode.get("DeclarationForSku");
 848
 849                 for (i = 0; i < decla.size(); i++) {
 850                     initDeclStr += tab + decla.get(i) + declNewLine;
 851                 }
 852             }
 853         initDeclStr += String.format("} %s_PCD_DATABASE_INIT;\r\n\r\n", phase);
 854
 855         //
 856         // Generate MACRO for structure intialization of PCDTokens with Default Value
 857         // The sequence must match the sequence of declaration of the memembers in the structure
 858         String tmp = String.format("%s_PCD_DATABASE_INIT g%sPcdDbInit = { ", phase.toUpperCase(), phase.toUpperCase());
 859         initInstStr +=  tmp + newLine;
 860         initInstStr += tab + genInstantiationStr(exMapTable.getInstantiation()) + commaNewLine;
 861         initInstStr += tab + genInstantiationStr(guidTable.getInstantiation()) + commaNewLine;
 862         initInstStr += tab + genInstantiationStr(localTokenNumberTable.getInstantiation()) + commaNewLine;
 863         initInstStr += tab + genInstantiationStr(stringTable.getInstantiation()) + commaNewLine;
 864         initInstStr += tab + genInstantiationStr(sizeTable.getInstantiation()) + commaNewLine;
 865         initInstStr += tab + genInstantiationStr(skuIdTable.getInstantiation()) + commaNewLine;
 866         //
 867         // For SystemSkuId
 868         //
 869         if (phase.equalsIgnoreCase("PEI")) {
 870             initInstStr += tab + "0" + tab + "/* SystemSkuId */" + commaNewLine;
 871         }
 872
 873         inst = initCode.get("Instantiation");
 874         for (i = 0; i < inst.size(); i++) {
 875             initInstStr += tab + inst.get(i) + commaNewLine;
 876         }
 877
 878         inst = initCode.get("InstantiationForSku");
 879         for (i = 0; i < inst.size(); i++) {
 880             initInstStr += tab + inst.get(i);
 881             if (i != inst.size() - 1) {
 882                 initInstStr += commaNewLine;
 883             }
 884         }
 885
 886         initInstStr += "};";
 887
 888         uninitDeclStr += "typedef struct {" + newLine;
 889             {
 890                 decla = uninitCode.get("Declaration");
 891                 if (decla.size() == 0) {
 892                     uninitDeclStr += "UINT8 dummy /* The UINT struct is empty */" + declNewLine;
 893                 } else {
 894
 895                     for (i = 0; i < decla.size(); i++) {
 896                         uninitDeclStr += tab + decla.get(i) + declNewLine;
 897                     }
 898
 899                     decla = uninitCode.get("DeclarationForSku");
 900
 901                     for (i = 0; i < decla.size(); i++) {
 902                         uninitDeclStr += tab + decla.get(i) + declNewLine;
 903                     }
 904                 }
 905             }
 906         uninitDeclStr += String.format("} %s_PCD_DATABASE_UNINIT;\r\n\r\n", phase);
 907
 908         cString = initInstStr + newLine;
 909         hString = macroStr      + newLine
 910               + initDeclStr   + newLine
 911               + uninitDeclStr + newLine
 912               + newLine;
 913
 914         hString += String.format("#define PCD_%s_SERVICE_DRIVER_VERSION                 %d", phase, version);
 915
 916     }
 917
 918     private String genInstantiationStr (ArrayList<String> alStr) {
 919         String str = "";
 920         for (int i = 0; i< alStr.size(); i++) {
 921             str += "\t" + alStr.get(i);
 922             if (i != alStr.size() - 1) {
 923                 str += "\r\n";
 924             }
 925         }
 926
 927         return str;
 928     }
 929
 930     private HashMap<String, ArrayList<String>> processTokens (List<Token> alToken)
 931         throws EntityException {
 932
 933         HashMap <String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>();
 934
 935         ArrayList<String> decl = new ArrayList<String>();
 936         ArrayList<String> declForSkuEnableType = new ArrayList<String>();
 937         ArrayList<String> inst = new ArrayList<String>();
 938         ArrayList<String> instForSkuEnableType = new ArrayList<String>();
 939
 940         for (int index = 0; index < alToken.size(); index++) {
 941             Token token = alToken.get(index);
 942
 943             if (token.isSkuEnable()) {
 944                 //
 945                 // BugBug: Schema only support Data type now
 946                 //
 947                 int tableIdx;
 948
 949                 tableIdx = skuIdTable.add(token);
 950
 951                 decl.add(getSkuEnabledTypeDeclaration(token));
 952                 if (token.hasDefaultValue()) {
 953                     inst.add(getSkuEnabledTypeInstantiaion(token, tableIdx));
 954                 }
 955
 956                 declForSkuEnableType.add(getDataTypeDeclarationForSkuEnabled(token));
 957                 if (token.hasDefaultValue()) {
 958                     instForSkuEnableType.add(getDataTypeInstantiationForSkuEnabled(token));
 959                 }
 960
 961             } else {
 962                 if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {
 963                     decl.add(getVariableEnableTypeDeclaration(token));
 964                     inst.add(getVariableEnableInstantiation(token));
 965                 } else if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {
 966                     decl.add(getVpdEnableTypeDeclaration(token));
 967                     inst.add(getVpdEnableTypeInstantiation(token));
 968                 } else if (token.isUnicodeStringType()) {
 969                     decl.add(getStringTypeDeclaration(token));
 970                     inst.add(getStringTypeInstantiation(stringTable.add(token.getStringTypeString(), token), token));
 971                 }
 972                 else {
 973                     decl.add(getDataTypeDeclaration(token));
 974                     if (token.hasDefaultValue()) {
 975                         inst.add(getDataTypeInstantiation(token));
 976                     }
 977                 }
 978             }
 979
 980             sizeTable.add(token);
 981             localTokenNumberTable.add(token);
 982             token.tokenNumber = assignedTokenNumber++;
 983
 984         }
 985
 986         map.put("Declaration",  decl);
 987         map.put("DeclarationForSku", declForSkuEnableType);
 988         map.put("Instantiation", inst);
 989         map.put("InstantiationForSku", instForSkuEnableType);
 990
 991         return map;
 992     }
 993
 994     private String getSkuEnabledTypeDeclaration (Token token) {
 995         return String.format("SKU_HEAD %s;\r\n", token.getPrimaryKeyString());
 996     }
 997
 998     private String getSkuEnabledTypeInstantiaion (Token token, int SkuTableIdx) {
 999
1000         String offsetof = String.format(PcdDatabase.offsetOfSkuHeadStrTemplate, phase, token.hasDefaultValue()? "Init" : "Uninit", token.getPrimaryKeyString());
1001         return String.format("{ %s, %d }", offsetof, SkuTableIdx);
1002     }
1003
1004     private String getDataTypeDeclarationForSkuEnabled (Token token) {
1005         String typeStr = "";
1006
1007         if (token.datumType == Token.DATUM_TYPE.UINT8) {
1008             typeStr = "UINT8 %s_%s[%d];\r\n";
1009         } else if (token.datumType == Token.DATUM_TYPE.UINT16) {
1010             typeStr = "UINT16 %s_%s[%d];\r\n";
1011         } else if (token.datumType == Token.DATUM_TYPE.UINT32) {
1012             typeStr = "UINT32 %s_%s[%d];\r\n";
1013         } else if (token.datumType == Token.DATUM_TYPE.UINT64) {
1014             typeStr = "UINT64 %s_%s[%d];\r\n";
1015         } else if (token.datumType == Token.DATUM_TYPE.BOOLEAN) {
1016             typeStr = "BOOLEAN %s_%s[%d];\r\n";
1017         } else if (token.datumType == Token.DATUM_TYPE.POINTER) {
1018             return String.format("UINT8 %s_%s[%d];\r\n", token.getPrimaryKeyString(), "SkuDataTable", token.datumSize * token.skuData.size());
1019         }
1020
1021         return String.format(typeStr, token.getPrimaryKeyString(), "SkuDataTable", token.skuData.size());
1022
1023     }
1024
1025     private String getDataTypeInstantiationForSkuEnabled (Token token) {
1026         String str = "";
1027
1028         if (token.datumType == Token.DATUM_TYPE.POINTER) {
1029             return String.format("UINT8 %s_%s[%d]", token.getPrimaryKeyString(), "SkuDataTable", token.datumSize * token.skuData.size());
1030         } else {
1031             str = "{ ";
1032             for (int idx = 0; idx < token.skuData.size(); idx++) {
1033                 str += token.skuData.get(idx).toString();
1034                 if (idx != token.skuData.size() - 1) {
1035                     str += ", ";
1036                 }
1037             }
1038             str += "}";
1039
1040             return str;
1041         }
1042
1043     }
1044
1045     private String getDataTypeInstantiation (Token token) {
1046
1047         if (token.datumType == Token.DATUM_TYPE.POINTER) {
1048             return String.format("%s /* %s */", token.getDefaultSku().value, token.getPrimaryKeyString());
1049         } else {
1050             return String.format("%s /* %s */", token.getDefaultSku().value, token.getPrimaryKeyString());
1051         }
1052     }
1053
1054
1055     private String getDataTypeDeclaration (Token token) {
1056
1057         String typeStr = "";
1058
1059         if (token.datumType == Token.DATUM_TYPE.UINT8) {
1060             typeStr = "UINT8";
1061         } else if (token.datumType == Token.DATUM_TYPE.UINT16) {
1062             typeStr = "UINT16";
1063         } else if (token.datumType == Token.DATUM_TYPE.UINT32) {
1064             typeStr = "UINT32";
1065         } else if (token.datumType == Token.DATUM_TYPE.UINT64) {
1066             typeStr = "UINT64";
1067         } else if (token.datumType == Token.DATUM_TYPE.BOOLEAN) {
1068             typeStr = "BOOLEAN";
1069         } else if (token.datumType == Token.DATUM_TYPE.POINTER) {
1070             return String.format("UINT8 %s[%d]", token.getPrimaryKeyString(), token.datumSize);
1071         } else {
1072         }
1073
1074         return String.format("%s    %s", typeStr, token.getPrimaryKeyString());
1075     }
1076
1077     private String getVpdEnableTypeDeclaration (Token token) {
1078         return String.format("VPD_HEAD %s", token.getPrimaryKeyString());
1079     }
1080
1081     private String getVpdEnableTypeInstantiation (Token token) {
1082         return String.format("{ %s } /* %s */", token.getDefaultSku().vpdOffset,
1083                                                 token.getPrimaryKeyString());
1084     }
1085
1086     private String getStringTypeDeclaration (Token token) {
1087         return String.format("UINT16  %s", token.getPrimaryKeyString());
1088     }
1089
1090     private String getStringTypeInstantiation (int StringTableIdx, Token token) {
1091         return String.format ("%d /* %s */", StringTableIdx,
1092                                              token.getPrimaryKeyString());
1093     }
1094
1095
1096     private String getVariableEnableTypeDeclaration (Token token) {
1097       return String.format("VARIABLE_HEAD  %s", token.getPrimaryKeyString());
1098     }
1099
1100     private String getVariableEnableInstantiation (Token token)
1101         throws EntityException {
1102         //
1103         // Need scott fix
1104         //
1105         return String.format("{ %d, %d, %s } /* %s */", guidTable.add(token.getDefaultSku().variableGuid, token.getPrimaryKeyString()),
1106                                                         stringTable.add(token.getDefaultSku().getStringOfVariableName(), token),
1107                                                         token.getDefaultSku().variableOffset,
1108                                                         token.getPrimaryKeyString());
1109     }
1110
1111     public int getTotalTokenNumber () {
1112         return sizeTable.getTableLen();
1113     }
1114
1115     public static String getPcdDatabaseCommonDefinitions ()
1116         throws EntityException {
1117
1118         String retStr = "";
1119         try {
1120             File file = new File(GlobalData.getWorkspacePath() + File.separator +
1121                                  "Tools" + File.separator +
1122                                  "Conf" + File.separator +
1123                                  "Pcd" + File.separator +
1124                                  "PcdDatabaseCommonDefinitions.sample");
1125             FileReader reader = new FileReader(file);
1126             BufferedReader  in = new BufferedReader(reader);
1127             String str;
1128             while ((str = in.readLine()) != null) {
1129                 retStr = retStr +"\r\n" + str;
1130             }
1131         } catch (Exception ex) {
1132             throw new EntityException("Fatal error when generating PcdDatabase Common Definitions");
1133         }
1134
1135         return retStr;
1136     }
1137
1138     public static String getPcdDxeDatabaseDefinitions ()
1139         throws EntityException {
1140
1141         String retStr = "";
1142         try {
1143             File file = new File(GlobalData.getWorkspacePath() + File.separator +
1144                                  "Tools" + File.separator +
1145                                  "Conf" + File.separator +
1146                                  "Pcd" + File.separator +
1147                                  "PcdDatabaseDxeDefinitions.sample");
1148             FileReader reader = new FileReader(file);
1149             BufferedReader  in = new BufferedReader(reader);
1150             String str;
1151             while ((str = in.readLine()) != null) {
1152                 retStr = retStr +"\r\n" + str;
1153             }
1154         } catch (Exception ex) {
1155             throw new EntityException("Fatal error when generating PcdDatabase Dxe Definitions");
1156         }
1157
1158         return retStr;
1159     }
1160
1161     public static String getPcdPeiDatabaseDefinitions ()
1162         throws EntityException {
1163
1164         String retStr = "";
1165         try {
1166             File file = new File(GlobalData.getWorkspacePath() + File.separator +
1167                                  "Tools" + File.separator +
1168                                  "Conf" + File.separator +
1169                                  "Pcd" + File.separator +
1170                                  "PcdDatabasePeiDefinitions.sample");
1171             FileReader reader = new FileReader(file);
1172             BufferedReader  in = new BufferedReader(reader);
1173             String str;
1174             while ((str = in.readLine()) != null) {
1175                 retStr = retStr +"\r\n" + str;
1176             }
1177         } catch (Exception ex) {
1178             throw new EntityException("Fatal error when generating PcdDatabase Pei Definitions");
1179         }
1180
1181         return retStr;
1182     }
1183
1184 }
1185
1186 class ModuleInfo {
1187     public ModuleSADocument.ModuleSA module;
1188     public UsageInstance.MODULE_TYPE type;
1189
1190     public ModuleInfo (ModuleSADocument.ModuleSA module, UsageInstance.MODULE_TYPE type) {
1191         this.module = module;
1192         this.type   = type;
1193     }
1194 }
1195
1196 /** This action class is to collect PCD information from MSA, SPD, FPD xml file.
1197     This class will be used for wizard and build tools, So it can *not* inherit
1198     from buildAction or UIAction.
1199 **/
1200 public class CollectPCDAction {
1201     /// memoryDatabase hold all PCD information collected from SPD, MSA, FPD.
1202     private MemoryDatabaseManager dbManager;
1203
1204     /// Workspacepath hold the workspace information.
1205     private String                workspacePath;
1206
1207     /// FPD file is the root file.
1208     private String                fpdFilePath;
1209
1210     /// Message level for CollectPCDAction.
1211     private int                   originalMessageLevel;
1212
1213     /// Cache the fpd docment instance for private usage.
1214     private FrameworkPlatformDescriptionDocument fpdDocInstance;
1215
1216     /**
1217       Set WorkspacePath parameter for this action class.
1218
1219       @param workspacePath parameter for this action
1220     **/
1221     public void setWorkspacePath(String workspacePath) {
1222         this.workspacePath = workspacePath;
1223     }
1224
1225     /**
1226       Set action message level for CollectPcdAction tool.
1227
1228       The message should be restored when this action exit.
1229
1230       @param actionMessageLevel parameter for this action
1231     **/
1232     public void setActionMessageLevel(int actionMessageLevel) {
1233         originalMessageLevel       = ActionMessage.messageLevel;
1234         ActionMessage.messageLevel = actionMessageLevel;
1235     }
1236
1237     /**
1238       Set FPDFileName parameter for this action class.
1239
1240       @param fpdFilePath    fpd file path
1241     **/
1242     public void setFPDFilePath(String fpdFilePath) {
1243         this.fpdFilePath = fpdFilePath;
1244     }
1245
1246     /**
1247       Common function interface for outer.
1248
1249       @param workspacePath The path of workspace of current build or analysis.
1250       @param fpdFilePath   The fpd file path of current build or analysis.
1251       @param messageLevel  The message level for this Action.
1252
1253       @throws  Exception The exception of this function. Because it can *not* be predict
1254                          where the action class will be used. So only Exception can be throw.
1255
1256     **/
1257     public void perform(String workspacePath, String fpdFilePath,
1258                         int messageLevel) throws Exception {
1259         setWorkspacePath(workspacePath);
1260         setFPDFilePath(fpdFilePath);
1261         setActionMessageLevel(messageLevel);
1262         checkParameter();
1263         execute();
1264         ActionMessage.messageLevel = originalMessageLevel;
1265     }
1266
1267     /**
1268       Core execution function for this action class.
1269
1270       This function work flows will be:
1271       1) Collect and prepocess PCD information from FPD file, all PCD
1272       information will be stored into memory database.
1273       2) Generate 3 strings for
1274         a) All modules using Dynamic(Ex) PCD entry.(Token Number)
1275         b) PEI PCDDatabase (C Structure) for PCD Service PEIM.
1276         c) DXE PCD Database (C structure) for PCD Service DXE.
1277
1278
1279       @throws  EntityException Exception indicate failed to execute this action.
1280
1281     **/
1282     private void execute() throws EntityException {
1283         //
1284         // Get memoryDatabaseManager instance from GlobalData.
1285         // The memoryDatabaseManager should be initialized for whatever build
1286         // tools or wizard tools
1287         //
1288         if((dbManager = GlobalData.getPCDMemoryDBManager()) == null) {
1289             throw new EntityException("The instance of PCD memory database manager is null");
1290         }
1291
1292         //
1293         // Collect all PCD information defined in FPD file.
1294         // Evenry token defind in FPD will be created as an token into
1295         // memory database.
1296         //
1297         createTokenInDBFromFPD();
1298
1299         //
1300         // Call Private function genPcdDatabaseSourceCode (void); ComponentTypeBsDriver
1301         // 1) Generate for PEI, DXE PCD DATABASE's definition and initialization.
1302         //
1303         genPcdDatabaseSourceCode ();
1304
1305     }
1306
1307     /**
1308       This function generates source code for PCD Database.
1309
1310       @param void
1311       @throws EntityException  If the token does *not* exist in memory database.
1312
1313     **/
1314     private void genPcdDatabaseSourceCode()
1315         throws EntityException {
1316         String PcdCommonHeaderString = PcdDatabase.getPcdDatabaseCommonDefinitions ();
1317
1318         ArrayList<Token> alPei = new ArrayList<Token> ();
1319         ArrayList<Token> alDxe = new ArrayList<Token> ();
1320
1321         dbManager.getTwoPhaseDynamicRecordArray(alPei, alDxe);
1322         PcdDatabase pcdPeiDatabase = new PcdDatabase (alPei, "PEI", 0);
1323         pcdPeiDatabase.genCode();
1324         dbManager.PcdPeimHString        = PcdCommonHeaderString + pcdPeiDatabase.getHString()
1325                                             + PcdDatabase.getPcdPeiDatabaseDefinitions();
1326         dbManager.PcdPeimCString        = pcdPeiDatabase.getCString();
1327
1328         PcdDatabase pcdDxeDatabase = new PcdDatabase (alDxe,
1329                                                       "DXE",
1330                                                       alPei.size()
1331                                                       );
1332         pcdDxeDatabase.genCode();
1333         dbManager.PcdDxeHString   = dbManager.PcdPeimHString + pcdDxeDatabase.getHString()
1334                                       + PcdDatabase.getPcdDxeDatabaseDefinitions();
1335         dbManager.PcdDxeCString   = pcdDxeDatabase.getCString();
1336     }
1337
1338     /**
1339       Get component array from FPD.
1340
1341       This function maybe provided by some Global class.
1342
1343       @return List<ModuleInfo> the component array.
1344
1345      */
1346     private List<ModuleInfo> getComponentsFromFPD()
1347         throws EntityException {
1348         HashMap<String, XmlObject>  map         = new HashMap<String, XmlObject>();
1349         List<ModuleInfo>            allModules  = new ArrayList<ModuleInfo>();
1350         ModuleInfo                  current     = null;
1351         int                         index       = 0;
1352         org.tianocore.Components    components  = null;
1353         FrameworkModulesDocument.FrameworkModules fModules = null;
1354         java.util.List<ModuleSADocument.ModuleSA> modules  = null;
1355
1356
1357         if (fpdDocInstance == null) {
1358             try {
1359                 fpdDocInstance = (FrameworkPlatformDescriptionDocument)XmlObject.Factory.parse(new File(fpdFilePath));
1360             } catch(IOException ioE) {
1361                 throw new EntityException("File IO error for xml file:" + fpdFilePath + "\n" + ioE.getMessage());
1362             } catch(XmlException xmlE) {
1363                 throw new EntityException("Can't parse the FPD xml fle:" + fpdFilePath + "\n" + xmlE.getMessage());
1364             }
1365
1366         }
1367
1368         //
1369         // Check whether FPD contians <FramworkModules>
1370         //
1371         fModules = fpdDocInstance.getFrameworkPlatformDescription().getFrameworkModules();
1372         if (fModules == null) {
1373             return null;
1374         }
1375
1376         //
1377         // BUGBUG: The following is work around code, the final component type should be get from
1378         // GlobalData class.
1379         //
1380         components = fModules.getSEC();
1381         if (components != null) {
1382             modules = components.getModuleSAList();
1383             for (index = 0; index < modules.size(); index ++) {
1384                 allModules.add(new ModuleInfo(modules.get(index), UsageInstance.MODULE_TYPE.SEC));
1385             }
1386         }
1387
1388         components = fModules.getPEICORE();
1389         if (components != null) {
1390             modules = components.getModuleSAList();
1391             for (index = 0; index < modules.size(); index ++) {
1392                 allModules.add(new ModuleInfo(modules.get(index), UsageInstance.MODULE_TYPE.PEI_CORE));
1393             }
1394         }
1395
1396         components = fModules.getPEIM();
1397         if (components != null) {
1398             modules = components.getModuleSAList();
1399             for (index = 0; index < modules.size(); index ++) {
1400                 allModules.add(new ModuleInfo(modules.get(index), UsageInstance.MODULE_TYPE.PEIM));
1401             }
1402         }
1403
1404         components = fModules.getDXECORE();
1405         if (components != null) {
1406             modules = components.getModuleSAList();
1407             for (index = 0; index < modules.size(); index ++) {
1408                 allModules.add(new ModuleInfo(modules.get(index), UsageInstance.MODULE_TYPE.DXE_CORE));
1409             }
1410         }
1411
1412         components = fModules.getDXEDRIVERS();
1413         if (components != null) {
1414             modules = components.getModuleSAList();
1415             for (index = 0; index < modules.size(); index ++) {
1416                 allModules.add(new ModuleInfo(modules.get(index), UsageInstance.MODULE_TYPE.DXE_DRIVERS));
1417             }
1418         }
1419
1420         components = fModules.getOTHERCOMPONENTS();
1421         if (components != null) {
1422             modules = components.getModuleSAList();
1423             for (index = 0; index < modules.size(); index ++) {
1424                 allModules.add(new ModuleInfo(modules.get(index), UsageInstance.MODULE_TYPE.OTHER_COMPONENTS));
1425             }
1426         }
1427
1428         return allModules;
1429     }
1430
1431     /**
1432       Create token instance object into memory database, the token information
1433       comes for FPD file. Normally, FPD file will contain all token platform
1434       informations.
1435
1436       @return FrameworkPlatformDescriptionDocument   The FPD document instance for furture usage.
1437
1438       @throws EntityException                        Failed to parse FPD xml file.
1439
1440     **/
1441     private void createTokenInDBFromFPD()
1442         throws EntityException {
1443         int                                 index             = 0;
1444         int                                 index2            = 0;
1445         int                                 pcdIndex          = 0;
1446         List<PcdBuildDefinition.PcdData>    pcdBuildDataArray = new ArrayList<PcdBuildDefinition.PcdData>();
1447         PcdBuildDefinition.PcdData          pcdBuildData      = null;
1448         Token                               token             = null;
1449         SkuInstance                         skuInstance       = null;
1450         int                                 skuIndex          = 0;
1451         List<ModuleInfo>                    modules           = null;
1452         String                              primaryKey        = null;
1453         String                              exceptionString   = null;
1454         UsageInstance                       usageInstance     = null;
1455         String                              primaryKey1       = null;
1456         String                              primaryKey2       = null;
1457         boolean                             isDuplicate       = false;
1458         Token.PCD_TYPE                      pcdType           = Token.PCD_TYPE.UNKNOWN;
1459         Token.DATUM_TYPE                    datumType         = Token.DATUM_TYPE.UNKNOWN;
1460         int                                 tokenNumber       = 0;
1461         String                              moduleName        = null;
1462         String                              datum             = null;
1463         int                                 maxDatumSize      = 0;
1464
1465         //
1466         // ----------------------------------------------
1467         // 1), Get all <ModuleSA> from FPD file.
1468         // ----------------------------------------------
1469         //
1470         modules = getComponentsFromFPD();
1471
1472         if (modules == null) {
1473             throw new EntityException("[FPD file error] No modules in FPD file, Please check whether there are elements in <FrameworkModules> in FPD file!");
1474         }
1475
1476         //
1477         // -------------------------------------------------------------------
1478         // 2), Loop all modules to process <PcdBuildDeclarations> for each module.
1479         // -------------------------------------------------------------------
1480         //
1481         for (index = 0; index < modules.size(); index ++) {
1482             isDuplicate =  false;
1483             for (index2 = 0; index2 < index; index2 ++) {
1484                 //
1485                 // BUGBUG: For transition schema, we can *not* get module's version from
1486                 // <ModuleSAs>, It is work around code.
1487                 //
1488                 primaryKey1 = UsageInstance.getPrimaryKey(modules.get(index).module.getModuleName(),
1489                                                           null,
1490                                                           null,
1491                                                           null,
1492                                                           modules.get(index).module.getArch().toString(),
1493                                                           null);
1494                 primaryKey2 = UsageInstance.getPrimaryKey(modules.get(index2).module.getModuleName(),
1495                                                           null,
1496                                                           null,
1497                                                           null,
1498                                                           modules.get(index2).module.getArch().toString(),
1499                                                           null);
1500                 if (primaryKey1.equalsIgnoreCase(primaryKey2)) {
1501                     isDuplicate = true;
1502                     break;
1503                 }
1504             }
1505
1506             if (isDuplicate) {
1507                 continue;
1508             }
1509
1510             //
1511             // It is legal for a module does not contains ANY pcd build definitions.
1512             //
1513             if (modules.get(index).module.getPcdBuildDefinition() == null) {
1514                 continue;
1515             }
1516
1517             pcdBuildDataArray = modules.get(index).module.getPcdBuildDefinition().getPcdDataList();
1518
1519             moduleName = modules.get(index).module.getModuleName();
1520
1521             //
1522             // ----------------------------------------------------------------------
1523             // 2.1), Loop all Pcd entry for a module and add it into memory database.
1524             // ----------------------------------------------------------------------
1525             //
1526             for (pcdIndex = 0; pcdIndex < pcdBuildDataArray.size(); pcdIndex ++) {
1527                 pcdBuildData = pcdBuildDataArray.get(pcdIndex);
1528                 primaryKey   = Token.getPrimaryKeyString(pcdBuildData.getCName(),
1529                                                          translateSchemaStringToUUID(pcdBuildData.getTokenSpaceGuid()));
1530                 pcdType      = Token.getpcdTypeFromString(pcdBuildData.getItemType().toString());
1531                 datumType    = Token.getdatumTypeFromString(pcdBuildData.getDatumType().toString());
1532                 tokenNumber  = Integer.decode(pcdBuildData.getToken().toString());
1533                 datum        = pcdBuildData.getValue();
1534                 maxDatumSize = pcdBuildData.getMaxDatumSize();
1535
1536                 if ((pcdType    == Token.PCD_TYPE.FEATURE_FLAG) &&
1537                     (datumType  != Token.DATUM_TYPE.BOOLEAN)){
1538                     exceptionString = String.format("[FPD file error] For PCD %s in module %s, the PCD type is FEATRUE_FLAG but "+
1539                                                     "datum type of this PCD entry is not BOOLEAN!",
1540                                                     pcdBuildData.getCName(),
1541                                                     moduleName);
1542                     throw new EntityException(exceptionString);
1543                 }
1544
1545                 //
1546                 // Check <TokenSpaceGuid> is exist? In future, because all schema verification will tools
1547                 // will check that, following checking code could be removed.
1548                 //
1549                 if (pcdBuildData.getTokenSpaceGuid() == null) {
1550                     exceptionString = String.format("[FPD file error] There is no <TokenSpaceGuid> for PCD %s in module %s! This is required!",
1551                                                     pcdBuildData.getCName(),
1552                                                     moduleName);
1553                     throw new EntityException(exceptionString);
1554                 }
1555
1556                 //
1557                 // -------------------------------------------------------------------------------------------
1558                 // 2.1.1), Do some necessary checking work for FixedAtBuild, FeatureFlag and PatchableInModule
1559                 // -------------------------------------------------------------------------------------------
1560                 //
1561                 if (!Token.isDynamic(pcdType)) {
1562                      //
1563                      // Value is required.
1564                      //
1565                      if (datum == null) {
1566                          exceptionString = String.format("[FPD file error] There is no value for PCD entry %s in module %s!",
1567                                                          pcdBuildData.getCName(),
1568                                                          moduleName);
1569                          throw new EntityException(exceptionString);
1570                      }
1571
1572                      //
1573                      // Check whether the datum size is matched datum type.
1574                      //
1575                      if ((exceptionString = verifyDatum(pcdBuildData.getCName(),
1576                                                         moduleName,
1577                                                         datum,
1578                                                         datumType,
1579                                                         maxDatumSize)) != null) {
1580                          throw new EntityException(exceptionString);
1581                      }
1582                 }
1583
1584                 //
1585                 // ---------------------------------------------------------------------------------
1586                 // 2.1.2), Create token or update token information for current anaylized PCD data.
1587                 // ---------------------------------------------------------------------------------
1588                 //
1589                 if (dbManager.isTokenInDatabase(primaryKey)) {
1590                     //
1591                     // If the token is already exist in database, do some necessary checking
1592                     // and add a usage instance into this token in database
1593                     //
1594                     token = dbManager.getTokenByKey(primaryKey);
1595
1596                     //
1597                     // checking for DatumType, DatumType should be unique for one PCD used in different
1598                     // modules.
1599                     //
1600                     if (token.datumType != datumType) {
1601                         exceptionString = String.format("[FPD file error] The datum type of PCD entry %s is %s, which is different with  %s defined in before!",
1602                                                         pcdBuildData.getCName(),
1603                                                         pcdBuildData.getDatumType().toString(),
1604                                                         Token.getStringOfdatumType(token.datumType));
1605                         throw new EntityException(exceptionString);
1606                     }
1607
1608                     //
1609                     // Check token number is valid
1610                     //
1611                     if (tokenNumber != token.tokenNumber) {
1612                         exceptionString = String.format("[FPD file error] The token number of PCD entry %s in module %s is different with same PCD entry in other modules!",
1613                                                         pcdBuildData.getCName(),
1614                                                         moduleName);
1615                         throw new EntityException(exceptionString);
1616                     }
1617
1618                     //
1619                     // For same PCD used in different modules, the PCD type should all be dynamic or non-dynamic.
1620                     //
1621                     if (token.isDynamicPCD != Token.isDynamic(pcdType)) {
1622                         exceptionString = String.format("[FPD file error] For PCD entry %s in module %s, you define dynamic or non-dynamic PCD type which"+
1623                                                         "is different with others module's",
1624                                                         token.cName,
1625                                                         moduleName);
1626                         throw new EntityException(exceptionString);
1627                     }
1628
1629                     if (token.isDynamicPCD) {
1630                         //
1631                         // Check datum is equal the datum in dynamic information.
1632                         // For dynamic PCD, you can do not write <Value> in sperated every <PcdBuildDefinition> in different <ModuleSA>,
1633                         // But if you write, the <Value> must be same as the value in <DynamicPcdBuildDefinitions>.
1634                         //
1635                         if (!token.isSkuEnable() &&
1636                             (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.DEFAULT_TYPE) &&
1637                             (datum != null)) {
1638                             if (!datum.equalsIgnoreCase(token.getDefaultSku().value)) {
1639                                 exceptionString = String.format("[FPD file error] For dynamic PCD %s in module %s, the datum in <ModuleSA> is "+
1640                                                                 "not equal to the datum in <DynamicPcdBuildDefinitions>, it is "+
1641                                                                 "illega! You could no set <Value> in <ModuleSA> for a dynamic PCD!",
1642                                                                 token.cName,
1643                                                                 moduleName);
1644                                 throw new EntityException(exceptionString);
1645                             }
1646                         }
1647
1648                         if ((maxDatumSize != 0) &&
1649                             (maxDatumSize != token.datumSize)){
1650                             exceptionString = String.format("[FPD file error] For dynamic PCD %s in module %s, the max datum size is %d which "+
1651                                                             "is different with <MaxDatumSize> %d defined in <DynamicPcdBuildDefinitions>!",
1652                                                             token.cName,
1653                                                             moduleName,
1654                                                             maxDatumSize,
1655                                                             token.datumSize);
1656                             throw new EntityException(exceptionString);
1657                         }
1658                     }
1659
1660                 } else {
1661                     //
1662                     // If the token is not in database, create a new token instance and add
1663                     // a usage instance into this token in database.
1664                     //
1665                     token = new Token(pcdBuildData.getCName(),
1666                                       translateSchemaStringToUUID(pcdBuildData.getTokenSpaceGuid()));
1667
1668                     token.datumType     = datumType;
1669                     token.tokenNumber   = tokenNumber;
1670                     token.isDynamicPCD  = Token.isDynamic(pcdType);
1671                     token.datumSize     = maxDatumSize;
1672
1673                     if (token.isDynamicPCD) {
1674                         //
1675                         // For Dynamic and Dynamic Ex type, need find the dynamic information
1676                         // in <DynamicPcdBuildDefinition> section in FPD file.
1677                         //
1678                         updateDynamicInformation(moduleName,
1679                                                  token,
1680                                                  datum,
1681                                                  maxDatumSize);
1682                     }
1683
1684                     dbManager.addTokenToDatabase(primaryKey, token);
1685                 }
1686
1687                 //
1688                 // -----------------------------------------------------------------------------------
1689                 // 2.1.3), Add the PcdType in current module into this Pcd token's supported PCD type.
1690                 // -----------------------------------------------------------------------------------
1691                 //
1692                 token.updateSupportPcdType(pcdType);
1693
1694                 //
1695                 // ------------------------------------------------
1696                 // 2.1.4), Create an usage instance for this token.
1697                 // ------------------------------------------------
1698                 //
1699                 usageInstance = new UsageInstance(token,
1700                                                   moduleName,
1701                                                   null,
1702                                                   null,
1703                                                   null,
1704                                                   modules.get(index).type,
1705                                                   pcdType,
1706                                                   modules.get(index).module.getArch().toString(),
1707                                                   null,
1708                                                   datum,
1709                                                   maxDatumSize);
1710                 token.addUsageInstance(usageInstance);
1711             }
1712         }
1713     }
1714
1715     /**
1716        Verify the datum value according its datum size and datum type, this
1717        function maybe moved to FPD verification tools in future.
1718
1719        @param cName
1720        @param moduleName
1721        @param datum
1722        @param datumType
1723        @param maxDatumSize
1724
1725        @return String
1726      */
1727     /***/
1728     public String verifyDatum(String            cName,
1729                               String            moduleName,
1730                               String            datum,
1731                               Token.DATUM_TYPE  datumType,
1732                               int               maxDatumSize) {
1733         String      exceptionString = null;
1734         int         value;
1735         BigInteger  value64;
1736         String      subStr;
1737         int         index;
1738
1739         if (moduleName == null) {
1740             moduleName = "section <DynamicPcdBuildDefinitions>";
1741         } else {
1742             moduleName = "module " + moduleName;
1743         }
1744
1745         if (maxDatumSize == 0) {
1746             exceptionString = String.format("[FPD file error] You maybe miss <MaxDatumSize> for PCD %s in %s",
1747                                             cName,
1748                                             moduleName);
1749             return exceptionString;
1750         }
1751
1752         switch (datumType) {
1753         case UINT8:
1754             if (maxDatumSize != 1) {
1755                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
1756                                                 "is UINT8, but datum size is %d, they are not matched!",
1757                                                  cName,
1758                                                  moduleName,
1759                                                  maxDatumSize);
1760                 return exceptionString;
1761             }
1762
1763             if (datum != null) {
1764                 try {
1765                     value = Integer.decode(datum);
1766                 } catch (NumberFormatException nfeExp) {
1767                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not valid "+
1768                                                     "digital format of UINT8",
1769                                                     cName,
1770                                                     moduleName);
1771                     return exceptionString;
1772                 }
1773                 if (value > 0xFF) {
1774                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s exceed"+
1775                                                     " the max size of UINT8 - 0xFF",
1776                                                     cName,
1777                                                     moduleName,
1778                                                     datum);
1779                     return exceptionString;
1780                 }
1781             }
1782             break;
1783         case UINT16:
1784             if (maxDatumSize != 2) {
1785                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
1786                                                 "is UINT16, but datum size is %d, they are not matched!",
1787                                                  cName,
1788                                                  moduleName,
1789                                                  maxDatumSize);
1790                 return exceptionString;
1791             }
1792             if (datum != null) {
1793                 try {
1794                     value = Integer.decode(datum);
1795                 } catch (NumberFormatException nfeExp) {
1796                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is "+
1797                                                     "not valid digital of UINT16",
1798                                                     cName,
1799                                                     moduleName);
1800                     return exceptionString;
1801                 }
1802                 if (value > 0xFFFF) {
1803                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s "+
1804                                                     "which exceed the range of UINT16 - 0xFFFF",
1805                                                     cName,
1806                                                     moduleName,
1807                                                     datum);
1808                     return exceptionString;
1809                 }
1810             }
1811             break;
1812         case UINT32:
1813             if (maxDatumSize != 4) {
1814                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
1815                                                 "is UINT32, but datum size is %d, they are not matched!",
1816                                                  cName,
1817                                                  moduleName,
1818                                                  maxDatumSize);
1819                 return exceptionString;
1820             }
1821
1822             if (datum != null) {
1823                 try {
1824                     if (datum.length() > 2) {
1825                         if ((datum.charAt(0) == '0')        &&
1826                             ((datum.charAt(1) == 'x') || (datum.charAt(1) == 'X'))){
1827                             subStr = datum.substring(2, datum.length());
1828                             value64 = new BigInteger(subStr, 16);
1829                         } else {
1830                             value64 = new BigInteger(datum);
1831                         }
1832                     } else {
1833                         value64 = new BigInteger(datum);
1834                     }
1835                 } catch (NumberFormatException nfeExp) {
1836                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not "+
1837                                                     "valid digital of UINT32",
1838                                                     cName,
1839                                                     moduleName);
1840                     return exceptionString;
1841                 }
1842
1843                 if (value64.bitLength() > 32) {
1844                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s which "+
1845                                                     "exceed the range of UINT32 - 0xFFFFFFFF",
1846                                                     cName,
1847                                                     moduleName,
1848                                                     datum);
1849                     return exceptionString;
1850                 }
1851             }
1852             break;
1853         case UINT64:
1854             if (maxDatumSize != 8) {
1855                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
1856                                                 "is UINT64, but datum size is %d, they are not matched!",
1857                                                  cName,
1858                                                  moduleName,
1859                                                  maxDatumSize);
1860                 return exceptionString;
1861             }
1862
1863             if (datum != null) {
1864                 try {
1865                     if (datum.length() > 2) {
1866                         if ((datum.charAt(0) == '0')        &&
1867                             ((datum.charAt(1) == 'x') || (datum.charAt(1) == 'X'))){
1868                             subStr = datum.substring(2, datum.length());
1869                             value64 = new BigInteger(subStr, 16);
1870                         } else {
1871                             value64 = new BigInteger(datum);
1872                         }
1873                     } else {
1874                         value64 = new BigInteger(datum);
1875                     }
1876                 } catch (NumberFormatException nfeExp) {
1877                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not valid"+
1878                                                     " digital of UINT64",
1879                                                     cName,
1880                                                     moduleName);
1881                     return exceptionString;
1882                 }
1883
1884                 if (value64.bitLength() > 64) {
1885                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s "+
1886                                                     "exceed the range of UINT64 - 0xFFFFFFFFFFFFFFFF",
1887                                                     cName,
1888                                                     moduleName,
1889                                                     datum);
1890                     return exceptionString;
1891                 }
1892             }
1893             break;
1894         case BOOLEAN:
1895             if (maxDatumSize != 1) {
1896                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
1897                                                 "is BOOLEAN, but datum size is %d, they are not matched!",
1898                                                  cName,
1899                                                  moduleName,
1900                                                  maxDatumSize);
1901                 return exceptionString;
1902             }
1903
1904             if (datum != null) {
1905                 if (!(datum.equalsIgnoreCase("TRUE") ||
1906                      datum.equalsIgnoreCase("FALSE"))) {
1907                     exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
1908                                                     "is BOOELAN, but value is not 'true'/'TRUE' or 'FALSE'/'false'",
1909                                                     cName,
1910                                                     moduleName);
1911                     return exceptionString;
1912                 }
1913
1914             }
1915             break;
1916         case POINTER:
1917             if (datum == null) {
1918                 break;
1919             }
1920
1921             char    ch     = datum.charAt(0);
1922             int     start, end;
1923             String  strValue;
1924             //
1925             // For void* type PCD, only three datum is support:
1926             // 1) Unicode: string with start char is "L"
1927             // 2) Ansci: String start char is ""
1928             // 3) byte array: String start char "{"
1929             //
1930             if (ch == 'L') {
1931                 start       = datum.indexOf('\"');
1932                 end         = datum.lastIndexOf('\"');
1933                 if ((start > end)           ||
1934                     (end   > datum.length())||
1935                     ((start == end) && (datum.length() > 0))) {
1936                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID* and datum is "+
1937                                                     "a UNICODE string because start with L\", but format maybe"+
1938                                                     "is not right, correct UNICODE string is L\"...\"!",
1939                                                     cName,
1940                                                     moduleName);
1941                     return exceptionString;
1942                 }
1943
1944                 strValue    = datum.substring(start + 1, end);
1945                 if ((strValue.length() * 2) > maxDatumSize) {
1946                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is "+
1947                                                     "a UNICODE string, but the datum size is %d exceed to <MaxDatumSize> : %d",
1948                                                     cName,
1949                                                     moduleName,
1950                                                     strValue.length() * 2,
1951                                                     maxDatumSize);
1952                     return exceptionString;
1953                 }
1954             } else if (ch == '\"'){
1955                 start       = datum.indexOf('\"');
1956                 end         = datum.lastIndexOf('\"');
1957                 if ((start > end)           ||
1958                     (end   > datum.length())||
1959                     ((start == end) && (datum.length() > 0))) {
1960                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID* and datum is "+
1961                                                     "a ANSCII string because start with \", but format maybe"+
1962                                                     "is not right, correct ANSIC string is \"...\"!",
1963                                                     cName,
1964                                                     moduleName);
1965                     return exceptionString;
1966                 }
1967                 strValue    = datum.substring(start + 1, end);
1968                 if ((strValue.length()) > maxDatumSize) {
1969                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is "+
1970                                                     "a ANSCI string, but the datum size is %d which exceed to <MaxDatumSize> : %d",
1971                                                     cName,
1972                                                     moduleName,
1973                                                     strValue.length(),
1974                                                     maxDatumSize);
1975                     return exceptionString;
1976                 }
1977             } else if (ch =='{') {
1978                 String[]  strValueArray;
1979
1980                 start           = datum.indexOf('{');
1981                 end             = datum.lastIndexOf('}');
1982                 strValue        = datum.substring(start + 1, end);
1983                 strValue        = strValue.trim();
1984                 if (strValue.length() == 0) {
1985                     break;
1986                 }
1987                 strValueArray   = strValue.split(",");
1988                 for (index = 0; index < strValueArray.length; index ++) {
1989                     try{
1990                         value = Integer.decode(strValueArray[index].trim());
1991                     } catch (NumberFormatException nfeEx) {
1992                         exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and "+
1993                                                          "it is byte array in fact. For every byte in array should be a valid"+
1994                                                          "byte digital, but element %s is not a valid byte digital!",
1995                                                          cName,
1996                                                          moduleName,
1997                                                          strValueArray[index]);
1998                         return exceptionString;
1999                     }
2000                     if (value > 0xFF) {
2001                         exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, "+
2002                                                         "it is byte array in fact. But the element of %s exceed the byte range",
2003                                                         cName,
2004                                                         moduleName,
2005                                                         strValueArray[index]);
2006                         return exceptionString;
2007                     }
2008                 }
2009
2010                 if (strValueArray.length > maxDatumSize) {
2011                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is byte"+
2012                                                     "array, but the number of bytes is %d which exceed to <MaxDatumSzie> : %d!",
2013                                                     cName,
2014                                                     moduleName,
2015                                                     strValueArray.length,
2016                                                     maxDatumSize);
2017                     return exceptionString;
2018                 }
2019             } else {
2020                 exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*. For VOID* type, you have three format choise:\n "+
2021                                                 "1) UNICODE string: like L\"xxxx\";\r\n"+
2022                                                 "2) ANSIC string: like \"xxx\";\r\n"+
2023                                                 "3) Byte array: like {0x2, 0x45, 0x23}\r\n"+
2024                                                 "But the datum in seems does not following above format!",
2025                                                 cName,
2026                                                 moduleName);
2027                 return exceptionString;
2028             }
2029             break;
2030         default:
2031             exceptionString = String.format("[FPD file error] For PCD entry %s in %s, datum type is unknown, it should be one of "+
2032                                             "UINT8, UINT16, UINT32, UINT64, VOID*, BOOLEAN",
2033                                             cName,
2034                                             moduleName);
2035             return exceptionString;
2036         }
2037         return null;
2038     }
2039
2040     /**
2041        Get dynamic information for a dynamic PCD from <DynamicPcdBuildDefinition> seciton in FPD file.
2042
2043        This function should be implemented in GlobalData in future.
2044
2045        @param token         The token instance which has hold module's PCD information
2046        @param moduleName    The name of module who will use this Dynamic PCD.
2047
2048        @return DynamicPcdBuildDefinitions.PcdBuildData
2049      */
2050     /***/
2051     private DynamicPcdBuildDefinitions.PcdBuildData getDynamicInfoFromFPD(Token     token,
2052                                                                           String    moduleName)
2053         throws EntityException {
2054         int    index             = 0;
2055         String exceptionString   = null;
2056         String dynamicPrimaryKey = null;
2057         DynamicPcdBuildDefinitions                    dynamicPcdBuildDefinitions = null;
2058         List<DynamicPcdBuildDefinitions.PcdBuildData> dynamicPcdBuildDataArray   = null;
2059
2060         //
2061         // If FPD document is not be opened, open and initialize it.
2062         //
2063         if (fpdDocInstance == null) {
2064             try {
2065                 fpdDocInstance = (FrameworkPlatformDescriptionDocument)XmlObject.Factory.parse(new File(fpdFilePath));
2066             } catch(IOException ioE) {
2067                 throw new EntityException("File IO error for xml file:" + fpdFilePath + "\n" + ioE.getMessage());
2068             } catch(XmlException xmlE) {
2069                 throw new EntityException("Can't parse the FPD xml fle:" + fpdFilePath + "\n" + xmlE.getMessage());
2070             }
2071         }
2072
2073         dynamicPcdBuildDefinitions = fpdDocInstance.getFrameworkPlatformDescription().getDynamicPcdBuildDefinitions();
2074         if (dynamicPcdBuildDefinitions == null) {
2075             exceptionString = String.format("[FPD file error] There are no <PcdDynamicBuildDescriptions> in FPD file but contains Dynamic type "+
2076                                             "PCD entry %s in module %s!",
2077                                             token.cName,
2078                                             moduleName);
2079             throw new EntityException(exceptionString);
2080         }
2081
2082         dynamicPcdBuildDataArray = dynamicPcdBuildDefinitions.getPcdBuildDataList();
2083         for (index = 0; index < dynamicPcdBuildDataArray.size(); index ++) {
2084             //
2085             // Check <TokenSpaceGuid> is exist? In future, because all schema verification will tools
2086             // will check that, following checking code could be removed.
2087             //
2088             if (dynamicPcdBuildDataArray.get(index).getTokenSpaceGuid() == null) {
2089                 exceptionString = String.format("[FPD file error] There is no <TokenSpaceGuid> for PCD %s in <DynamicPcdBuildDefinitions>! This is required!",
2090                                                 dynamicPcdBuildDataArray.get(index).getCName());
2091                 throw new EntityException(exceptionString);
2092             }
2093
2094             dynamicPrimaryKey = Token.getPrimaryKeyString(dynamicPcdBuildDataArray.get(index).getCName(),
2095                                                           translateSchemaStringToUUID(dynamicPcdBuildDataArray.get(index).getTokenSpaceGuid()));
2096             if (dynamicPrimaryKey.equalsIgnoreCase(token.getPrimaryKeyString())) {
2097                 return dynamicPcdBuildDataArray.get(index);
2098             }
2099         }
2100
2101         return null;
2102     }
2103
2104     /**
2105        Update dynamic information for PCD entry.
2106
2107        Dynamic information is retrieved from <PcdDynamicBuildDeclarations> in
2108        FPD file.
2109
2110        @param moduleName        The name of the module who use this PCD
2111        @param token             The token instance
2112        @param datum             The <datum> in module's PCD information
2113        @param maxDatumSize      The <maxDatumSize> in module's PCD information
2114
2115        @return Token
2116      */
2117     private Token updateDynamicInformation(String   moduleName,
2118                                            Token    token,
2119                                            String   datum,
2120                                            int      maxDatumSize)
2121         throws EntityException {
2122         int                 index           = 0;
2123         int                 offset;
2124         String              exceptionString = null;
2125         DynamicTokenValue   dynamicValue;
2126         SkuInstance         skuInstance     = null;
2127         String              temp;
2128         boolean             hasSkuId0       = false;
2129         Token.PCD_TYPE      pcdType         = Token.PCD_TYPE.UNKNOWN;
2130         int                 tokenNumber     = 0;
2131
2132         List<DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo>   skuInfoList = null;
2133         DynamicPcdBuildDefinitions.PcdBuildData                 dynamicInfo = null;
2134
2135         dynamicInfo = getDynamicInfoFromFPD(token, moduleName);
2136         if (dynamicInfo == null) {
2137             exceptionString = String.format("[FPD file error] For Dynamic PCD %s used by module %s, "+
2138                                             "there is no dynamic information in <DynamicPcdBuildDefinitions> "+
2139                                             "in FPD file, but it is required!",
2140                                             token.cName,
2141                                             moduleName);
2142             throw new EntityException(exceptionString);
2143         }
2144
2145         token.datumSize = dynamicInfo.getMaxDatumSize();
2146
2147         exceptionString = verifyDatum(token.cName,
2148                                       moduleName,
2149                                       null,
2150                                       token.datumType,
2151                                       token.datumSize);
2152         if (exceptionString != null) {
2153             throw new EntityException(exceptionString);
2154         }
2155
2156         if ((maxDatumSize != 0) &&
2157             (maxDatumSize != token.datumSize)) {
2158             exceptionString = String.format("FPD file error] For dynamic PCD %s, the datum size in module %s is %d, but "+
2159                                             "the datum size in <DynamicPcdBuildDefinitions> is %d, they are not match!",
2160                                             token.cName,
2161                                             moduleName,
2162                                             maxDatumSize,
2163                                             dynamicInfo.getMaxDatumSize());
2164             throw new EntityException(exceptionString);
2165         }
2166         tokenNumber = Integer.decode(dynamicInfo.getToken().toString());
2167         if (tokenNumber != token.tokenNumber) {
2168             exceptionString = String.format("[FPD file error] For dynamic PCD %s, the token number in module %s is 0x%x, but"+
2169                                             "in <DynamicPcdBuildDefinictions>, the token number is 0x%x, they are not match!",
2170                                             token.cName,
2171                                             moduleName,
2172                                             token.tokenNumber,
2173                                             tokenNumber);
2174             throw new EntityException(exceptionString);
2175         }
2176
2177         pcdType = Token.getpcdTypeFromString(dynamicInfo.getItemType().toString());
2178         if (pcdType == Token.PCD_TYPE.DYNAMIC_EX) {
2179             token.dynamicExTokenNumber = tokenNumber;
2180         }
2181
2182         skuInfoList = dynamicInfo.getSkuInfoList();
2183
2184         //
2185         // Loop all sku data
2186         //
2187         for (index = 0; index < skuInfoList.size(); index ++) {
2188             skuInstance = new SkuInstance();
2189             //
2190             // Although SkuId in schema is BigInteger, but in fact, sku id is 32 bit value.
2191             //
2192             temp = skuInfoList.get(index).getSkuId().toString();
2193             skuInstance.id = Integer.decode(temp);
2194             if (skuInstance.id == 0) {
2195                 hasSkuId0 = true;
2196             }
2197             //
2198             // Judge whether is DefaultGroup at first, because most case is DefautlGroup.
2199             //
2200             if (skuInfoList.get(index).getValue() != null) {
2201                 skuInstance.value.setValue(skuInfoList.get(index).getValue());
2202                 if ((exceptionString = verifyDatum(token.cName,
2203                                                    null,
2204                                                    skuInfoList.get(index).getValue(),
2205                                                    token.datumType,
2206                                                    token.datumSize)) != null) {
2207                     throw new EntityException(exceptionString);
2208                 }
2209
2210                 token.skuData.add(skuInstance);
2211
2212                 //
2213                 // Judege wether is same of datum between module's information
2214                 // and dynamic information.
2215                 //
2216                 if (datum != null) {
2217                     if ((skuInstance.id == 0)                                   &&
2218                         !datum.equalsIgnoreCase(skuInfoList.get(index).getValue())) {
2219                         exceptionString = "[FPD file error] For dynamic PCD " + token.cName + ", the value in module " + moduleName + " is " + datum.toString() + " but the "+
2220                                           "value of sku 0 data in <DynamicPcdBuildDefinition> is " + skuInstance.value.value + ". They are must be same!"+
2221                                           " or you could not define value for a dynamic PCD in every <ModuleSA>!";
2222                         throw new EntityException(exceptionString);
2223                     }
2224                 }
2225                 continue;
2226             }
2227
2228             //
2229             // Judge whether is HII group case.
2230             //
2231             if (skuInfoList.get(index).getVariableName() != null) {
2232                 exceptionString = null;
2233                 if (skuInfoList.get(index).getVariableGuid() == null) {
2234                     exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+
2235                                                     "file, who use HII, but there is no <VariableGuid> defined for Sku %d data!",
2236                                                     token.cName,
2237                                                     index);
2238
2239                 }
2240
2241                 if (skuInfoList.get(index).getVariableOffset() == null) {
2242                     exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+
2243                                                     "file, who use HII, but there is no <VariableOffset> defined for Sku %d data!",
2244                                                     token.cName,
2245                                                     index);
2246                 }
2247
2248                 if (skuInfoList.get(index).getHiiDefaultValue() == null) {
2249                     exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+
2250                                                     "file, who use HII, but there is no <HiiDefaultValue> defined for Sku %d data!",
2251                                                     token.cName,
2252                                                     index);
2253                 }
2254
2255                 if (exceptionString != null) {
2256                     throw new EntityException(exceptionString);
2257                 }
2258
2259                 if ((exceptionString = verifyDatum(token.cName,
2260                                                    null,
2261                                                    skuInfoList.get(index).getHiiDefaultValue(),
2262                                                    token.datumType,
2263                                                    token.datumSize)) != null) {
2264                     throw new EntityException(exceptionString);
2265                 }
2266
2267                 offset = Integer.decode(skuInfoList.get(index).getVariableOffset());
2268                 if (offset > 0xFFFF) {
2269                     throw new EntityException(String.format("[FPD file error] For dynamic PCD %s ,  the variable offset defined in sku %d data "+
2270                                                             "exceed 64K, it is not allowed!",
2271                                                             token.cName,
2272                                                             index));
2273                 }
2274
2275                 skuInstance.value.setHiiData(skuInfoList.get(index).getVariableName(),
2276                                              translateSchemaStringToUUID(skuInfoList.get(index).getVariableGuid().toString()),
2277                                              skuInfoList.get(index).getVariableOffset(),
2278                                              skuInfoList.get(index).getHiiDefaultValue());
2279                 token.skuData.add(skuInstance);
2280                 continue;
2281             }
2282
2283             if (skuInfoList.get(index).getVpdOffset() != null) {
2284                 skuInstance.value.setVpdData(skuInfoList.get(index).getVpdOffset());
2285                 token.skuData.add(skuInstance);
2286                 continue;
2287             }
2288
2289             exceptionString = String.format("[FPD file error] For dynamic PCD %s, the dynamic info must "+
2290                                             "be one of 'DefaultGroup', 'HIIGroup', 'VpdGroup'.",
2291                                             token.cName);
2292             throw new EntityException(exceptionString);
2293         }
2294
2295         if (!hasSkuId0) {
2296             exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions>, there are "+
2297                                             "no sku id = 0 data, which is required for every dynamic PCD",
2298                                             token.cName);
2299             throw new EntityException(exceptionString);
2300         }
2301
2302         return token;
2303     }
2304
2305     /**
2306        Translate the schema string to UUID instance.
2307
2308        In schema, the string of UUID is defined as following two types string:
2309         1) GuidArrayType: pattern = 0x[a-fA-F0-9]{1,8},( )*0x[a-fA-F0-9]{1,4},(
2310         )*0x[a-fA-F0-9]{1,4}(,( )*\{)?(,?( )*0x[a-fA-F0-9]{1,2}){8}( )*(\})?
2311
2312         2) GuidNamingConvention: pattern =
2313         [a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}
2314
2315        This function will convert string and create uuid instance.
2316
2317        @param uuidString    UUID string in XML file
2318
2319        @return UUID         UUID instance
2320     **/
2321     private UUID translateSchemaStringToUUID(String uuidString)
2322         throws EntityException {
2323         String      temp;
2324         String[]    splitStringArray;
2325         int         index;
2326         int         chIndex;
2327         int         chLen;
2328
2329         if (uuidString == null) {
2330             return null;
2331         }
2332
2333         if (uuidString.length() == 0) {
2334             return null;
2335         }
2336
2337         if (uuidString.equals("0") ||
2338             uuidString.equalsIgnoreCase("0x0")) {
2339             return new UUID(0, 0);
2340         }
2341
2342         //
2343         // If the UUID schema string is GuidArrayType type then need translate
2344         // to GuidNamingConvention type at first.
2345         //
2346         if ((uuidString.charAt(0) == '0') && ((uuidString.charAt(1) == 'x') || (uuidString.charAt(1) == 'X'))) {
2347             splitStringArray = uuidString.split("," );
2348             if (splitStringArray.length != 11) {
2349                 throw new EntityException ("[FPD file error] Wrong format for UUID string: " + uuidString);
2350             }
2351
2352             //
2353             // Remove blank space from these string and remove header string "0x"
2354             //
2355             for (index = 0; index < 11; index ++) {
2356                 splitStringArray[index] = splitStringArray[index].trim();
2357                 splitStringArray[index] = splitStringArray[index].substring(2, splitStringArray[index].length());
2358             }
2359
2360             //
2361             // Add heading '0' to normalize the string length
2362             //
2363             for (index = 3; index < 11; index ++) {
2364                 chLen = splitStringArray[index].length();
2365                 for (chIndex = 0; chIndex < 2 - chLen; chIndex ++) {
2366                     splitStringArray[index] = "0" + splitStringArray[index];
2367                 }
2368             }
2369
2370             //
2371             // construct the final GuidNamingConvention string
2372             //
2373             temp = String.format("%s-%s-%s-%s%s-%s%s%s%s%s%s",
2374                                  splitStringArray[0],
2375                                  splitStringArray[1],
2376                                  splitStringArray[2],
2377                                  splitStringArray[3],
2378                                  splitStringArray[4],
2379                                  splitStringArray[5],
2380                                  splitStringArray[6],
2381                                  splitStringArray[7],
2382                                  splitStringArray[8],
2383                                  splitStringArray[9],
2384                                  splitStringArray[10]);
2385             uuidString = temp;
2386         }
2387
2388         return UUID.fromString(uuidString);
2389     }
2390
2391     /**
2392       check parameter for this action.
2393
2394       @throws EntityException  Bad parameter.
2395     **/
2396     private void checkParameter() throws EntityException {
2397         File file = null;
2398
2399         if((fpdFilePath    == null) ||(workspacePath  == null)) {
2400             throw new EntityException("WorkspacePath and FPDFileName should be blank for CollectPCDAtion!");
2401         }
2402
2403         if(fpdFilePath.length() == 0 || workspacePath.length() == 0) {
2404             throw new EntityException("WorkspacePath and FPDFileName should be blank for CollectPCDAtion!");
2405         }
2406
2407         file = new File(workspacePath);
2408         if(!file.exists()) {
2409             throw new EntityException("WorkpacePath " + workspacePath + " does not exist!");
2410         }
2411
2412         file = new File(fpdFilePath);
2413
2414         if(!file.exists()) {
2415             throw new EntityException("FPD File " + fpdFilePath + " does not exist!");
2416         }
2417     }
2418
2419     /**
2420       Test case function
2421
2422       @param argv  parameter from command line
2423     **/
2424     public static void main(String argv[]) throws EntityException {
2425         CollectPCDAction ca = new CollectPCDAction();
2426         ca.setWorkspacePath("m:/tianocore_latest/edk2");
2427         ca.setFPDFilePath("m:/tianocore_latest/edk2/EdkNt32Pkg/Nt32.fpd");
2428         ca.setActionMessageLevel(ActionMessage.MAX_MESSAGE_LEVEL);
2429         GlobalData.initInfo("Tools" + File.separator + "Conf" + File.separator + "FrameworkDatabase.db",
2430                             "m:/tianocore_latest/edk2");
2431         ca.execute();
2432     }
2433 }