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.Iterator;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.Set;
  33 import java.util.UUID;
  34 import java.util.regex.Matcher;
  35 import java.util.regex.Pattern;
  36
  37 import org.apache.xmlbeans.XmlException;
  38 import org.apache.xmlbeans.XmlObject;
  39 import org.tianocore.DynamicPcdBuildDefinitionsDocument;
  40 import org.tianocore.DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions;
  41 import org.tianocore.DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData;
  42 import org.tianocore.DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo;
  43 import org.tianocore.FrameworkModulesDocument;
  44 import org.tianocore.PcdDeclarationsDocument;
  45 import org.tianocore.PlatformSurfaceAreaDocument;
  46 import org.tianocore.PcdBuildDefinitionDocument;
  47 import org.tianocore.PlatformSurfaceAreaDocument.PlatformSurfaceArea;
  48 import org.tianocore.ModuleSADocument;
  49 import org.tianocore.ModuleSADocument.ModuleSA;
  50 import org.tianocore.PackageSurfaceAreaDocument;
  51 import org.tianocore.PcdBuildDefinitionDocument.PcdBuildDefinition;
  52 import org.tianocore.build.autogen.CommonDefinition;
  53 import org.tianocore.build.global.GlobalData;
  54 import org.tianocore.build.global.SurfaceAreaQuery;
  55 import org.tianocore.build.id.FpdModuleIdentification;
  56 import org.tianocore.build.pcd.action.ActionMessage;
  57 import org.tianocore.build.pcd.entity.DynamicTokenValue;
  58 import org.tianocore.build.pcd.entity.MemoryDatabaseManager;
  59 import org.tianocore.build.pcd.entity.SkuInstance;
  60 import org.tianocore.build.pcd.entity.Token;
  61 import org.tianocore.build.pcd.entity.UsageInstance;
  62 import org.tianocore.build.pcd.exception.EntityException;
  63 import org.tianocore.logger.EdkLog;
  64 import org.tianocore.ModuleTypeDef;
  65
  66 class CStructTypeDeclaration {
  67     String key;
  68     int alignmentSize;
  69     String cCode;
  70     boolean initTable;
  71
  72     public CStructTypeDeclaration (String key, int alignmentSize, String cCode, boolean initTable) {
  73         this.key = key;
  74         this.alignmentSize = alignmentSize;
  75         this.cCode = cCode;
  76         this.initTable = initTable;
  77     }
  78 }
  79
  80 class StringTable {
  81     private ArrayList<String>   al;
  82     private ArrayList<String>   alComments;
  83     private String              phase;
  84     int                         len;
  85
  86     public StringTable (String phase) {
  87         this.phase = phase;
  88         al = new ArrayList<String>();
  89         alComments = new ArrayList<String>();
  90         len = 0;
  91     }
  92
  93     public String getSizeMacro () {
  94         return String.format(PcdDatabase.StringTableSizeMacro, phase, getSize());
  95     }
  96
  97     private int getSize () {
  98         //
  99         // We have at least one Unicode Character in the table.
 100         //
 101         return len == 0 ? 1 : len;
 102     }
 103
 104     public int getTableLen () {
 105         return al.size() == 0 ? 1 : al.size();
 106     }
 107
 108     public String getExistanceMacro () {
 109         return String.format(PcdDatabase.StringTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 110     }
 111
 112     public void genCodeNew (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable) {
 113         final String stringTable = "StringTable";
 114         final String tab         = "\t";
 115         final String newLine     = "\r\n";
 116         final String commaNewLine = ",\r\n";
 117
 118         CStructTypeDeclaration decl;
 119
 120         String cDeclCode = "";
 121         String cInstCode = "";
 122
 123         //
 124         // If we have a empty StringTable
 125         //
 126         if (al.size() == 0) {
 127             cDeclCode += String.format("%-20s%s[1]; /* StringTable is empty */", "UINT16", stringTable) + newLine;
 128             decl = new CStructTypeDeclaration (
 129                                                 stringTable,
 130                                                 2,
 131                                                 cDeclCode,
 132                                                 true
 133                                         );
 134             declaList.add(decl);
 135
 136             cInstCode = String.format("/* %s */", stringTable) + newLine + tab + "{ 0 }";
 137             instTable.put(stringTable, cInstCode);
 138         } else {
 139
 140             //
 141             // If there is any String in the StringTable
 142             //
 143             for (int i = 0; i < al.size(); i++) {
 144                 String str = al.get(i);
 145                 String stringTableName;
 146
 147                 if (i == 0) {
 148                     //
 149                     // StringTable is a well-known name in the PCD DXE driver
 150                     //
 151                     stringTableName = stringTable;
 152
 153                 } else {
 154                     stringTableName = String.format("%s_%d", stringTable, i);
 155                     cDeclCode += tab;
 156                 }
 157                 cDeclCode += String.format("%-20s%s[%d]; /* %s */", "UINT16", stringTableName, str.length() + 1, alComments.get(i)) + newLine;
 158
 159                 if (i == 0) {
 160                     cInstCode = "/* StringTable */" + newLine;
 161                 }
 162                 cInstCode += tab + String.format("L\"%s\" /* %s */", al.get(i), alComments.get(i));
 163                 if (i != al.size() - 1) {
 164                     cInstCode += commaNewLine;
 165                 }
 166             }
 167
 168             decl = new CStructTypeDeclaration (
 169                     stringTable,
 170                     2,
 171                     cDeclCode,
 172                     true
 173             );
 174             declaList.add(decl);
 175
 176             instTable.put(stringTable, cInstCode);
 177         }
 178     }
 179
 180     public String getTypeDeclaration () {
 181
 182         String output;
 183
 184         final String stringTable = "StringTable";
 185         final String tab = "\t";
 186         final String newLine = ";\r\n";
 187
 188         output =  "/* StringTable */\r\n";
 189
 190         if (al.size() == 0) {
 191             output += tab + String.format("UINT16 %s[1] /* StringTable is Empty */", stringTable) + newLine;
 192         }
 193
 194         for (int i = 0; i < al.size(); i++) {
 195             String str = al.get(i);
 196
 197             if (i == 0) {
 198                 //
 199                 // StringTable is a well-known name in the PCD DXE driver
 200                 //
 201                 output += tab + String.format("UINT16       %s[%d] /* %s */", stringTable, str.length() + 1, alComments.get(i)) + newLine;
 202             } else {
 203                 output += tab + String.format("UINT16       %s_%d[%d] /* %s */", stringTable, i, str.length() + 1, alComments.get(i)) + newLine;
 204             }
 205         }
 206
 207         return output;
 208
 209     }
 210
 211     public ArrayList<String> getInstantiation () {
 212         ArrayList<String> output = new ArrayList<String>();
 213
 214         output.add("/* StringTable */");
 215
 216         if (al.size() == 0) {
 217             output.add("{ 0 }");
 218         } else {
 219             String str;
 220
 221             for (int i = 0; i < al.size(); i++) {
 222                 str = String.format("L\"%s\" /* %s */", al.get(i), alComments.get(i));
 223                 if (i != al.size() - 1) {
 224                     str += ",";
 225                 }
 226                 output.add(str);
 227             }
 228         }
 229
 230         return output;
 231     }
 232
 233     public int add (String inputStr, Token token) {
 234         int i;
 235         int pos;
 236
 237         String str = inputStr;
 238
 239         //
 240         // The input can be two types:
 241         // "L\"Bootmode\"" or "Bootmode".
 242         // We drop the L\" and \" for the first type.
 243         if (str.startsWith("L\"") && str.endsWith("\"")) {
 244             str = str.substring(2, str.length() - 1);
 245         }
 246         //
 247         // Check if StringTable has this String already.
 248         // If so, return the current pos.
 249         //
 250         for (i = 0, pos = 0; i < al.size(); i++) {
 251             String s = al.get(i);;
 252
 253             if (str.equals(s)) {
 254                 return pos;
 255             }
 256             pos = s.length() + 1;
 257
 258         }
 259
 260         i = len;
 261         //
 262         // Include the NULL character at the end of String
 263         //
 264         len += str.length() + 1;
 265         al.add(str);
 266         alComments.add(token.getPrimaryKeyString());
 267
 268         return i;
 269     }
 270 }
 271
 272 class SizeTable {
 273     private ArrayList<Integer>  al;
 274     private ArrayList<String>   alComments;
 275     private String              phase;
 276     private int                 len;
 277
 278     public SizeTable (String phase) {
 279         this.phase = phase;
 280         al = new ArrayList<Integer>();
 281         alComments = new ArrayList<String>();
 282         len = 0;
 283     }
 284
 285     public void genCodeNew (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) {
 286         final String name = "SizeTable";
 287
 288         CStructTypeDeclaration decl;
 289         String cCode;
 290
 291         cCode = String.format(PcdDatabase.SizeTableDeclaration, phase);
 292         decl = new CStructTypeDeclaration (
 293                                             name,
 294                                             2,
 295                                             cCode,
 296                                             true
 297                                            );
 298         declaList.add(decl);
 299
 300
 301         cCode = PcdDatabase.genInstantiationStr(getInstantiation());
 302         instTable.put(name, cCode);
 303     }
 304
 305     public String getTypeDeclaration () {
 306         return String.format(PcdDatabase.SizeTableDeclaration, phase);
 307     }
 308
 309     public ArrayList<String> getInstantiation () {
 310         ArrayList<String> Output = new ArrayList<String>();
 311
 312         Output.add("/* SizeTable */");
 313         Output.add("{");
 314         if (al.size() == 0) {
 315             Output.add("\t0");
 316         } else {
 317             for (int index = 0; index < al.size(); index++) {
 318                 Integer n = al.get(index);
 319                 String str = "\t" + n.toString();
 320
 321                 if (index != (al.size() - 1)) {
 322                     str += ",";
 323                 }
 324
 325                 str += " /* " + alComments.get(index) + " */";
 326                 Output.add(str);
 327
 328             }
 329         }
 330         Output.add("}");
 331
 332         return Output;
 333     }
 334
 335     public int add (Token token) {
 336         int index = len;
 337
 338         len++;
 339         al.add(token.datumSize);
 340         alComments.add(token.getPrimaryKeyString());
 341
 342         return index;
 343     }
 344
 345     public int getTableLen () {
 346         return al.size() == 0 ? 1 : al.size();
 347     }
 348
 349 }
 350
 351 class GuidTable {
 352     private ArrayList<UUID> al;
 353     private ArrayList<String> alComments;
 354     private String          phase;
 355     private int             len;
 356     private int             bodyLineNum;
 357
 358     public GuidTable (String phase) {
 359         this.phase = phase;
 360         al = new ArrayList<UUID>();
 361         alComments = new ArrayList<String>();
 362         len = 0;
 363         bodyLineNum = 0;
 364     }
 365
 366     public String getSizeMacro () {
 367         return String.format(PcdDatabase.GuidTableSizeMacro, phase, getSize());
 368     }
 369
 370     private int getSize () {
 371         return (al.size() == 0)? 1 : al.size();
 372     }
 373
 374     public String getExistanceMacro () {
 375         return String.format(PcdDatabase.GuidTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 376     }
 377
 378     public void genCodeNew (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) {
 379         final String name = "GuidTable";
 380
 381         CStructTypeDeclaration decl;
 382         String cCode = "";
 383
 384         cCode += String.format(PcdDatabase.GuidTableDeclaration, phase);
 385         decl = new CStructTypeDeclaration (
 386                                             name,
 387                                             8,
 388                                             cCode,
 389                                             true
 390                                            );
 391         declaList.add(decl);
 392
 393
 394         cCode = PcdDatabase.genInstantiationStr(getInstantiation());
 395         instTable.put(name, cCode);
 396     }
 397
 398     public String getTypeDeclaration () {
 399         return String.format(PcdDatabase.GuidTableDeclaration, phase);
 400     }
 401
 402     private String getUuidCString (UUID uuid) {
 403         String[]  guidStrArray;
 404
 405         guidStrArray =(uuid.toString()).split("-");
 406
 407         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}}",
 408                                          guidStrArray[0],
 409                                          guidStrArray[1],
 410                                          guidStrArray[2],
 411                                         (guidStrArray[3].substring(0, 2)),
 412                                         (guidStrArray[3].substring(2, 4)),
 413                                         (guidStrArray[4].substring(0, 2)),
 414                                         (guidStrArray[4].substring(2, 4)),
 415                                         (guidStrArray[4].substring(4, 6)),
 416                                         (guidStrArray[4].substring(6, 8)),
 417                                         (guidStrArray[4].substring(8, 10)),
 418                                         (guidStrArray[4].substring(10, 12))
 419                                         );
 420     }
 421
 422     public ArrayList<String> getInstantiation () {
 423         ArrayList<String> Output = new ArrayList<String>();
 424
 425         Output.add("/* GuidTable */");
 426         Output.add("{");
 427
 428         if (al.size() == 0) {
 429             Output.add("\t" + getUuidCString(new UUID(0, 0)));
 430         }
 431
 432         for (int i = 0; i < al.size(); i++) {
 433             String str = "\t" + getUuidCString(al.get(i));
 434
 435             str += "/* " + alComments.get(i) +  " */";
 436             if (i != (al.size() - 1)) {
 437                 str += ",";
 438             }
 439             Output.add(str);
 440             bodyLineNum++;
 441
 442         }
 443         Output.add("}");
 444
 445         return Output;
 446     }
 447
 448     public int add (UUID uuid, String name) {
 449         //
 450         // Check if GuidTable has this entry already.
 451         // If so, return the GuidTable index.
 452         //
 453         for (int i = 0; i < al.size(); i++) {
 454             if (al.get(i).equals(uuid)) {
 455                 return i;
 456             }
 457         }
 458
 459         len++;
 460         al.add(uuid);
 461         alComments.add(name);
 462
 463         //
 464         // Return the previous Table Index
 465         //
 466         return len - 1;
 467     }
 468
 469     public int getTableLen () {
 470         return al.size() == 0 ? 0 : al.size();
 471     }
 472
 473 }
 474
 475 class SkuIdTable {
 476     private ArrayList<Integer[]> al;
 477     private ArrayList<String>    alComment;
 478     private String               phase;
 479     private int                  len;
 480
 481     public SkuIdTable (String phase) {
 482         this.phase = phase;
 483         al = new ArrayList<Integer[]>();
 484         alComment = new ArrayList<String>();
 485         len = 0;
 486     }
 487
 488     public String getSizeMacro () {
 489         return String.format(PcdDatabase.SkuIdTableSizeMacro, phase, getSize());
 490     }
 491
 492     private int getSize () {
 493         return (len == 0)? 1 : len;
 494     }
 495
 496     public String getExistanceMacro () {
 497         return String.format(PcdDatabase.SkuTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 498     }
 499
 500     public void genCodeNew (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) {
 501         final String name = "SkuIdTable";
 502
 503         CStructTypeDeclaration decl;
 504         String cCode = "";
 505
 506         cCode += String.format(PcdDatabase.SkuIdTableDeclaration, phase);
 507         decl = new CStructTypeDeclaration (
 508                                             name,
 509                                             1,
 510                                             cCode,
 511                                             true
 512                                            );
 513         declaList.add(decl);
 514
 515
 516         cCode = PcdDatabase.genInstantiationStr(getInstantiation());
 517         instTable.put(name, cCode);
 518
 519         //
 520         // SystemSkuId is in PEI phase PCD Database
 521         //
 522         if (phase.equalsIgnoreCase("PEI")) {
 523             decl = new CStructTypeDeclaration (
 524                                                 "SystemSkuId",
 525                                                 1,
 526                                                 String.format("%-20sSystemSkuId;\r\n", "SKU_ID"),
 527                                                 true
 528                                               );
 529             declaList.add(decl);
 530
 531             instTable.put("SystemSkuId", "0");
 532         }
 533
 534     }
 535
 536     public String getTypeDeclaration () {
 537         return String.format(PcdDatabase.SkuIdTableDeclaration, phase);
 538     }
 539
 540     public ArrayList<String> getInstantiation () {
 541         ArrayList<String> Output = new ArrayList<String> ();
 542
 543         Output.add("/* SkuIdTable */");
 544         Output.add("{");
 545
 546         if (al.size() == 0) {
 547             Output.add("\t0");
 548         }
 549
 550         for (int index = 0; index < al.size(); index++) {
 551             String str;
 552
 553             str = "/* " + alComment.get(index) + "*/ ";
 554             str += "/* MaxSku */ ";
 555
 556
 557             Integer[] ia = al.get(index);
 558
 559             str += "\t" + ia[0].toString() + ", ";
 560             for (int index2 = 1; index2 < ia.length; index2++) {
 561                str += ia[index2].toString();
 562                if (!((index2 == ia.length - 1) && (index == al.size() - 1))) {
 563                    str += ", ";
 564                }
 565             }
 566
 567             Output.add(str);
 568
 569         }
 570
 571         Output.add("}");
 572
 573         return Output;
 574     }
 575
 576     public int add (Token token) {
 577
 578         int index;
 579         int pos;
 580
 581         //
 582         // Check if this SKU_ID Array is already in the table
 583         //
 584         pos = 0;
 585         for (Object o: al) {
 586             Integer [] s = (Integer[]) o;
 587             boolean different = false;
 588             if (s[0] == token.getSkuIdCount()) {
 589                 for (index = 1; index < s.length; index++) {
 590                     if (s[index] != token.skuData.get(index-1).id) {
 591                         different = true;
 592                         break;
 593                     }
 594                 }
 595             } else {
 596                 different = true;
 597             }
 598             if (different) {
 599                 pos += s[0] + 1;
 600             } else {
 601                 return pos;
 602             }
 603         }
 604
 605         Integer [] skuIds = new Integer[token.skuData.size() + 1];
 606         skuIds[0] = new Integer(token.skuData.size());
 607         for (index = 1; index < skuIds.length; index++) {
 608             skuIds[index] = new Integer(token.skuData.get(index - 1).id);
 609         }
 610
 611         index = len;
 612
 613         len += skuIds.length;
 614         al.add(skuIds);
 615         alComment.add(token.getPrimaryKeyString());
 616
 617         return index;
 618     }
 619
 620     public int getTableLen () {
 621         return al.size() == 0 ? 1 : al.size();
 622     }
 623
 624 }
 625
 626 class LocalTokenNumberTable {
 627     private ArrayList<String>    al;
 628     private ArrayList<String>    alComment;
 629     private String               phase;
 630     private int                  len;
 631
 632     public LocalTokenNumberTable (String phase) {
 633         this.phase = phase;
 634         al = new ArrayList<String>();
 635         alComment = new ArrayList<String>();
 636
 637         len = 0;
 638     }
 639
 640     public String getSizeMacro () {
 641         return String.format(PcdDatabase.LocalTokenNumberTableSizeMacro, phase, getSize())
 642                         + String.format(PcdDatabase.LocalTokenNumberSizeMacro, phase, al.size());
 643     }
 644
 645     public int getSize () {
 646         return (al.size() == 0)? 1 : al.size();
 647     }
 648
 649     public String getExistanceMacro () {
 650         return String.format(PcdDatabase.DatabaseExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 651     }
 652
 653     public void genCodeNew (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) {
 654         final String name = "LocalTokenNumberTable";
 655
 656         CStructTypeDeclaration decl;
 657         String cCode = "";
 658
 659         cCode += String.format(PcdDatabase.LocalTokenNumberTableDeclaration, phase);
 660         decl = new CStructTypeDeclaration (
 661                                             name,
 662                                             4,
 663                                             cCode,
 664                                             true
 665                                            );
 666         declaList.add(decl);
 667
 668         cCode = PcdDatabase.genInstantiationStr(getInstantiation());
 669         instTable.put(name, cCode);
 670     }
 671
 672     public String getTypeDeclaration () {
 673         return String.format(PcdDatabase.LocalTokenNumberTableDeclaration, phase);
 674     }
 675
 676     public ArrayList<String> getInstantiation () {
 677         ArrayList<String> output = new ArrayList<String>();
 678
 679         output.add("/* LocalTokenNumberTable */");
 680         output.add("{");
 681
 682         if (al.size() == 0) {
 683             output.add("\t0");
 684         }
 685
 686         for (int index = 0; index < al.size(); index++) {
 687             String str;
 688
 689             str = "\t" + (String)al.get(index);
 690
 691             str += " /* " + alComment.get(index) + " */ ";
 692
 693
 694             if (index != (al.size() - 1)) {
 695                 str += ",";
 696             }
 697
 698             output.add(str);
 699
 700         }
 701
 702         output.add("}");
 703
 704         return output;
 705     }
 706
 707     public int add (Token token) {
 708         int index = len;
 709         String str;
 710
 711         len++;
 712
 713         str =  String.format(PcdDatabase.offsetOfStrTemplate, phase, token.hasDefaultValue() ? "Init" : "Uninit", token.getPrimaryKeyString());
 714
 715         if (token.isUnicodeStringType()) {
 716             str += " | PCD_TYPE_STRING";
 717         }
 718
 719         if (token.isSkuEnable()) {
 720             str += " | PCD_TYPE_SKU_ENABLED";
 721         }
 722
 723         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {
 724             str += " | PCD_TYPE_HII";
 725         }
 726
 727         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {
 728             str += " | PCD_TYPE_VPD";
 729         }
 730
 731         al.add(str);
 732         alComment.add(token.getPrimaryKeyString());
 733
 734         return index;
 735     }
 736 }
 737
 738 class ExMapTable {
 739
 740     class ExTriplet {
 741         public Integer guidTableIdx;
 742         public Long exTokenNumber;
 743         public Long localTokenIdx;
 744
 745         public ExTriplet (int guidTableIdx, long exTokenNumber, long localTokenIdx) {
 746             this.guidTableIdx = new Integer(guidTableIdx);
 747             this.exTokenNumber = new Long(exTokenNumber);
 748             this.localTokenIdx = new Long(localTokenIdx);
 749         }
 750     }
 751
 752     private ArrayList<ExTriplet> al;
 753     private ArrayList<String>    alComment;
 754     private String               phase;
 755     private int                  len;
 756     private int                   bodyLineNum;
 757
 758     public ExMapTable (String phase) {
 759         this.phase = phase;
 760         al = new ArrayList<ExTriplet>();
 761         alComment = new ArrayList<String>();
 762         bodyLineNum = 0;
 763         len = 0;
 764     }
 765
 766     public String getSizeMacro () {
 767         return String.format(PcdDatabase.ExMapTableSizeMacro, phase, getTableLen())
 768              + String.format(PcdDatabase.ExTokenNumber, phase, al.size());
 769     }
 770
 771     public String getExistanceMacro () {
 772         return String.format(PcdDatabase.ExMapTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");
 773     }
 774
 775     public void genCodeNew (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) {
 776         final String exMapTableName = "ExMapTable";
 777
 778         sortTable();
 779
 780         CStructTypeDeclaration decl;
 781         String cCode = "";
 782
 783         cCode += String.format(PcdDatabase.ExMapTableDeclaration, phase);
 784         decl = new CStructTypeDeclaration (
 785                                             exMapTableName,
 786                                             4,
 787                                             cCode,
 788                                             true
 789                                            );
 790         declaList.add(decl);
 791
 792
 793         cCode = PcdDatabase.genInstantiationStr(getInstantiation());
 794         instTable.put(exMapTableName, cCode);
 795     }
 796
 797     public String getTypeDeclaration () {
 798         return String.format(PcdDatabase.ExMapTableDeclaration, phase);
 799     }
 800
 801     public ArrayList<String> getInstantiation () {
 802         ArrayList<String> Output = new ArrayList<String>();
 803
 804         Output.add("/* ExMapTable */");
 805         Output.add("{");
 806         if (al.size() == 0) {
 807             Output.add("\t{0, 0, 0}");
 808         }
 809
 810         int index;
 811         for (index = 0; index < al.size(); index++) {
 812             String str;
 813
 814             ExTriplet e = (ExTriplet)al.get(index);
 815
 816             str = "\t" + "{ " + String.format("0x%08X", e.exTokenNumber) + ", ";
 817             str += e.localTokenIdx.toString() + ", ";
 818             str += e.guidTableIdx.toString();
 819
 820             str += "}" + " /* " + alComment.get(index) + " */" ;
 821
 822             if (index != al.size() - 1) {
 823                 str += ",";
 824             }
 825
 826             Output.add(str);
 827             bodyLineNum++;
 828
 829         }
 830
 831         Output.add("}");
 832
 833         return Output;
 834     }
 835
 836     public int add (int localTokenIdx, long exTokenNum, int guidTableIdx, String name) {
 837         int index = len;
 838
 839         len++;
 840         al.add(new ExTriplet(guidTableIdx, exTokenNum, localTokenIdx));
 841         alComment.add(name);
 842
 843         return index;
 844     }
 845
 846     public int getTableLen () {
 847         return al.size() == 0 ? 1 : al.size();
 848     }
 849
 850     //
 851     // To simplify the algorithm for GetNextToken and GetNextTokenSpace in
 852     // PCD PEIM/Driver, we need to sort the ExMapTable according to the
 853     // following order:
 854     // 1) ExGuid
 855     // 2) ExTokenNumber
 856     //
 857     class ExTripletComp implements Comparator<ExTriplet> {
 858         public int compare (ExTriplet a, ExTriplet b) {
 859             if (a.guidTableIdx == b.guidTableIdx ) {
 860                 if (a.exTokenNumber > b.exTokenNumber) {
 861                     return 1;
 862                 } else if (a.exTokenNumber > b.exTokenNumber) {
 863                     return 1;
 864                 } else {
 865                     return 0;
 866                 }
 867             }
 868
 869             return a.guidTableIdx - b.guidTableIdx;
 870         }
 871     }
 872
 873     private void sortTable () {
 874         java.util.Comparator<ExTriplet> comparator = new ExTripletComp();
 875         java.util.Collections.sort(al, comparator);
 876     }
 877 }
 878
 879 class PcdDatabase {
 880
 881     private final static int    SkuHeadAlignmentSize             = 4;
 882     private final String        newLine                         = "\r\n";
 883     private final String        commaNewLine                    = ",\r\n";
 884     private final String        tab                             = "\t";
 885     public final static String ExMapTableDeclaration            = "DYNAMICEX_MAPPING   ExMapTable[%s_EXMAPPING_TABLE_SIZE];\r\n";
 886     public final static String GuidTableDeclaration             = "EFI_GUID            GuidTable[%s_GUID_TABLE_SIZE];\r\n";
 887     public final static String LocalTokenNumberTableDeclaration = "UINT32              LocalTokenNumberTable[%s_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r\n";
 888     public final static String StringTableDeclaration           = "UINT16              StringTable[%s_STRING_TABLE_SIZE];\r\n";
 889     public final static String SizeTableDeclaration             = "UINT16              SizeTable[%s_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r\n";
 890     public final static String SkuIdTableDeclaration            = "UINT8               SkuIdTable[%s_SKUID_TABLE_SIZE];\r\n";
 891
 892
 893     public final static String ExMapTableSizeMacro              = "#define %s_EXMAPPING_TABLE_SIZE  %d\r\n";
 894     public final static String ExTokenNumber                    = "#define %s_EX_TOKEN_NUMBER       %d\r\n";
 895     public final static String GuidTableSizeMacro               = "#define %s_GUID_TABLE_SIZE         %d\r\n";
 896     public final static String LocalTokenNumberTableSizeMacro   = "#define %s_LOCAL_TOKEN_NUMBER_TABLE_SIZE            %d\r\n";
 897     public final static String LocalTokenNumberSizeMacro                = "#define %s_LOCAL_TOKEN_NUMBER            %d\r\n";
 898     public final static String StringTableSizeMacro             = "#define %s_STRING_TABLE_SIZE       %d\r\n";
 899     public final static String SkuIdTableSizeMacro              = "#define %s_SKUID_TABLE_SIZE        %d\r\n";
 900
 901
 902     public final static String ExMapTableExistenceMacro         = "#define %s_EXMAP_TABLE_EMPTY    %s\r\n";
 903     public final static String GuidTableExistenceMacro          = "#define %s_GUID_TABLE_EMPTY     %s\r\n";
 904     public final static String DatabaseExistenceMacro           = "#define %s_DATABASE_EMPTY       %s\r\n";
 905     public final static String StringTableExistenceMacro        = "#define %s_STRING_TABLE_EMPTY   %s\r\n";
 906     public final static String SkuTableExistenceMacro           = "#define %s_SKUID_TABLE_EMPTY    %s\r\n";
 907
 908     public final static String offsetOfSkuHeadStrTemplate       = "offsetof(%s_PCD_DATABASE, %s.%s_SkuDataTable)";
 909     public final static String offsetOfVariableEnabledDefault   = "offsetof(%s_PCD_DATABASE, %s.%s_VariableDefault_%d)";
 910     public final static String offsetOfStrTemplate              = "offsetof(%s_PCD_DATABASE, %s.%s)";
 911
 912     private final static String  skuDataTableTemplate           = "SkuDataTable";
 913
 914
 915     private StringTable stringTable;
 916     private GuidTable   guidTable;
 917     private LocalTokenNumberTable localTokenNumberTable;
 918     private SkuIdTable  skuIdTable;
 919     private SizeTable   sizeTable;
 920     private ExMapTable  exMapTable;
 921
 922     private ArrayList<Token> alTokens;
 923     private String phase;
 924     private int assignedTokenNumber;
 925
 926     //
 927     // Use two class global variable to store
 928     // temperary
 929     //
 930     private String      privateGlobalName;
 931     private String      privateGlobalCCode;
 932     //
 933     // After Major changes done to the PCD
 934     // database generation class PcdDatabase
 935     // Please increment the version and please
 936     // also update the version number in PCD
 937     // service PEIM and DXE driver accordingly.
 938     //
 939     private final int version = 2;
 940
 941     private String hString;
 942     private String cString;
 943
 944
 945     class AlignmentSizeComp implements Comparator<Token> {
 946         public int compare (Token a, Token b) {
 947             return getAlignmentSize(b)
 948                     - getAlignmentSize(a);
 949         }
 950     }
 951
 952     public PcdDatabase (ArrayList<Token> alTokens, String exePhase, int startLen) {
 953        phase = exePhase;
 954
 955        stringTable = new StringTable(phase);
 956        guidTable = new GuidTable(phase);
 957        localTokenNumberTable = new LocalTokenNumberTable(phase);
 958        skuIdTable = new SkuIdTable(phase);
 959        sizeTable = new SizeTable(phase);
 960        exMapTable = new ExMapTable(phase);
 961
 962        assignedTokenNumber = startLen + 1;
 963        this.alTokens = alTokens;
 964     }
 965
 966     private void getNonExAndExTokens (ArrayList<Token> alTokens, List<Token> nexTokens, List<Token> exTokens) {
 967         for (int i = 0; i < alTokens.size(); i++) {
 968             Token t = (Token)alTokens.get(i);
 969             if (t.isDynamicEx()) {
 970                 exTokens.add(t);
 971             } else {
 972                 nexTokens.add(t);
 973             }
 974         }
 975
 976         return;
 977     }
 978
 979     private void getTwoGroupsOfTokens (ArrayList<Token> alTokens, List<Token> initTokens, List<Token> uninitTokens) {
 980         for (int i = 0; i < alTokens.size(); i++) {
 981             Token t = (Token)alTokens.get(i);
 982             if (t.hasDefaultValue()) {
 983                 initTokens.add(t);
 984             } else {
 985                 uninitTokens.add(t);
 986             }
 987         }
 988
 989         return;
 990     }
 991
 992     private int getDataTypeAlignmentSize (Token token) {
 993         switch (token.datumType) {
 994         case UINT8:
 995             return 1;
 996         case UINT16:
 997             return 2;
 998         case UINT32:
 999             return 4;
1000         case UINT64:
1001             return 8;
1002         case POINTER:
1003             return 1;
1004         case BOOLEAN:
1005             return 1;
1006         default:
1007             return 1;
1008         }
1009     }
1010
1011     private int getAlignmentSize (Token token) {
1012         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {
1013             return 2;
1014         }
1015
1016         if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {
1017             return 4;
1018         }
1019
1020         if (token.isUnicodeStringType()) {
1021             return 2;
1022         }
1023
1024         return getDataTypeAlignmentSize(token);
1025      }
1026
1027     public String getCString () {
1028         return cString;
1029     }
1030
1031     public String getHString () {
1032         return hString;
1033     }
1034
1035     private void genCodeWorker(Token t,
1036             ArrayList<CStructTypeDeclaration> declaList,
1037             HashMap<String, String> instTable, String phase)
1038             throws EntityException {
1039
1040         CStructTypeDeclaration decl;
1041
1042         //
1043         // Insert SKU_HEAD if isSkuEnable is true
1044         //
1045         if (t.isSkuEnable()) {
1046             int tableIdx;
1047             tableIdx = skuIdTable.add(t);
1048             decl = new CStructTypeDeclaration(t.getPrimaryKeyString(),
1049                     SkuHeadAlignmentSize, getSkuEnabledTypeDeclaration(t), true);
1050             declaList.add(decl);
1051             instTable.put(t.getPrimaryKeyString(),
1052                     getSkuEnabledTypeInstantiaion(t, tableIdx));
1053         }
1054
1055         //
1056         // Insert PCD_ENTRY declaration and instantiation
1057         //
1058         getCDeclarationString(t);
1059
1060         decl = new CStructTypeDeclaration(privateGlobalName,
1061                 getAlignmentSize(t), privateGlobalCCode, t.hasDefaultValue());
1062         declaList.add(decl);
1063
1064         if (t.hasDefaultValue()) {
1065             instTable.put(privateGlobalName,
1066                           getTypeInstantiation(t, declaList, instTable, phase)
1067                           );
1068         }
1069
1070     }
1071
1072     private void ProcessTokensNew (List<Token> tokens,
1073                                    ArrayList<CStructTypeDeclaration> cStructDeclList,
1074                                    HashMap<String, String> cStructInstTable,
1075                                    String phase
1076                                    )
1077     throws EntityException {
1078
1079         for (int idx = 0; idx < tokens.size(); idx++) {
1080             Token t = tokens.get(idx);
1081
1082             genCodeWorker (t, cStructDeclList, cStructInstTable, phase);
1083
1084             sizeTable.add(t);
1085             localTokenNumberTable.add(t);
1086             t.tokenNumber = assignedTokenNumber++;
1087
1088             //
1089             // Add a mapping if this dynamic PCD entry is a EX type
1090             //
1091             if (t.isDynamicEx()) {
1092                 exMapTable.add((int)t.tokenNumber,
1093                                 t.dynamicExTokenNumber,
1094                                 guidTable.add(t.tokenSpaceName, t.getPrimaryKeyString()),
1095                                 t.getPrimaryKeyString()
1096                                 );
1097             }
1098         }
1099
1100     }
1101
1102     public void genCodeNew () throws EntityException {
1103
1104         ArrayList<CStructTypeDeclaration> cStructDeclList = new ArrayList<CStructTypeDeclaration>();
1105         HashMap<String, String> cStructInstTable = new HashMap<String, String>();
1106
1107         List<Token> nexTokens = new ArrayList<Token> ();
1108         List<Token> exTokens = new ArrayList<Token> ();
1109
1110         getNonExAndExTokens (alTokens, nexTokens, exTokens);
1111
1112         //
1113         // We have to process Non-Ex type PCD entry first. The reason is
1114         // that our optimization assumes that the Token Number of Non-Ex
1115         // PCD entry start from 1 (for PEI phase) and grows continously upwards.
1116         //
1117         // EX type token number starts from the last Non-EX PCD entry and
1118         // grows continously upwards.
1119         //
1120         ProcessTokensNew (nexTokens, cStructDeclList, cStructInstTable, phase);
1121         ProcessTokensNew (exTokens, cStructDeclList, cStructInstTable, phase);
1122
1123         stringTable.genCodeNew(cStructDeclList, cStructInstTable);
1124         skuIdTable.genCodeNew(cStructDeclList, cStructInstTable, phase);
1125         exMapTable.genCodeNew(cStructDeclList, cStructInstTable, phase);
1126         localTokenNumberTable.genCodeNew(cStructDeclList, cStructInstTable, phase);
1127         sizeTable.genCodeNew(cStructDeclList, cStructInstTable, phase);
1128         guidTable.genCodeNew(cStructDeclList, cStructInstTable, phase);
1129
1130         hString = genCMacroCode ();
1131
1132         HashMap <String, String> result;
1133
1134         result = genCStructCode(cStructDeclList,
1135                 cStructInstTable,
1136                 phase
1137                 );
1138
1139         hString += result.get("initDeclStr");
1140         hString += result.get("uninitDeclStr");
1141
1142         hString += String.format("#define PCD_%s_SERVICE_DRIVER_VERSION         %d", phase, version);
1143
1144         cString = newLine + newLine + result.get("initInstStr");
1145
1146     }
1147
1148     private String genCMacroCode () {
1149         String macroStr   = "";
1150
1151         //
1152         // Generate size info Macro for all Tables
1153         //
1154         macroStr += guidTable.getSizeMacro();
1155         macroStr += stringTable.getSizeMacro();
1156         macroStr += skuIdTable.getSizeMacro();
1157         macroStr += localTokenNumberTable.getSizeMacro();
1158         macroStr += exMapTable.getSizeMacro();
1159
1160         //
1161         // Generate existance info Macro for all Tables
1162         //
1163         macroStr += guidTable.getExistanceMacro();
1164         macroStr += stringTable.getExistanceMacro();
1165         macroStr += skuIdTable.getExistanceMacro();
1166         macroStr += localTokenNumberTable.getExistanceMacro();
1167         macroStr += exMapTable.getExistanceMacro();
1168
1169         macroStr += newLine;
1170
1171         return macroStr;
1172     }
1173
1174     private HashMap <String, String> genCStructCode(
1175                                             ArrayList<CStructTypeDeclaration> declaList,
1176                                             HashMap<String, String> instTable,
1177                                             String phase
1178                                             ) {
1179
1180         int i;
1181         HashMap <String, String> result = new HashMap<String, String>();
1182         HashMap <Integer, ArrayList<String>>    alignmentInitDecl = new HashMap<Integer, ArrayList<String>>();
1183         HashMap <Integer, ArrayList<String>>    alignmentUninitDecl = new HashMap<Integer, ArrayList<String>>();
1184         HashMap <Integer, ArrayList<String>>    alignmentInitInst = new HashMap<Integer, ArrayList<String>>();
1185
1186         //
1187         // Initialize the storage for each alignment
1188         //
1189         for (i = 8; i > 0; i>>=1) {
1190             alignmentInitDecl.put(new Integer(i), new ArrayList<String>());
1191             alignmentInitInst.put(new Integer(i), new ArrayList<String>());
1192             alignmentUninitDecl.put(new Integer(i), new ArrayList<String>());
1193         }
1194
1195         String initDeclStr   = "typedef struct {" + newLine;
1196         String initInstStr   = String.format("%s_PCD_DATABASE_INIT g%sPcdDbInit = { ", phase.toUpperCase(), phase.toUpperCase()) + newLine;
1197         String uninitDeclStr = "typedef struct {" + newLine;
1198
1199         //
1200         // Sort all C declaration and instantiation base on Alignment Size
1201         //
1202         for (Object d : declaList) {
1203             CStructTypeDeclaration decl = (CStructTypeDeclaration) d;
1204
1205             if (decl.initTable) {
1206                 alignmentInitDecl.get(new Integer(decl.alignmentSize)).add(decl.cCode);
1207                 alignmentInitInst.get(new Integer(decl.alignmentSize)).add(instTable.get(decl.key));
1208             } else {
1209                 alignmentUninitDecl.get(new Integer(decl.alignmentSize)).add(decl.cCode);
1210             }
1211         }
1212
1213         //
1214         // Generate code for every alignment size
1215         //
1216         boolean uinitDatabaseEmpty = true;
1217         for (int align = 8; align > 0; align >>= 1) {
1218             ArrayList<String> declaListBasedOnAlignment = alignmentInitDecl.get(new Integer(align));
1219             ArrayList<String> instListBasedOnAlignment = alignmentInitInst.get(new Integer(align));
1220             for (i = 0; i < declaListBasedOnAlignment.size(); i++) {
1221                 initDeclStr += tab + declaListBasedOnAlignment.get(i);
1222                 initInstStr += tab + instListBasedOnAlignment.get(i);
1223
1224                 //
1225                 // We made a assumption that both PEI_PCD_DATABASE and DXE_PCD_DATABASE
1226                 // has a least one data memember with alignment size of 1. So we can
1227                 // remove the last "," in the C structure instantiation string. Luckily,
1228                 // this is true as both data structure has SKUID_TABLE anyway.
1229                 //
1230                 if ((align == 1) && (i == declaListBasedOnAlignment.size() - 1)) {
1231                     initInstStr += newLine;
1232                 } else {
1233                     initInstStr += commaNewLine;
1234                 }
1235             }
1236
1237             declaListBasedOnAlignment = alignmentUninitDecl.get(new Integer(align));
1238
1239             if (declaListBasedOnAlignment.size() != 0) {
1240                 uinitDatabaseEmpty = false;
1241             }
1242
1243             for (Object d : declaListBasedOnAlignment) {
1244                 String s = (String)d;
1245                 uninitDeclStr += tab + s;
1246             }
1247         }
1248
1249         if (uinitDatabaseEmpty) {
1250             uninitDeclStr += tab + String.format("%-20sdummy; /* PCD_DATABASE_UNINIT is emptry */\r\n", "UINT8");
1251         }
1252
1253         initDeclStr += String.format("} %s_PCD_DATABASE_INIT;", phase) + newLine + newLine;
1254         initInstStr += "};" + newLine;
1255         uninitDeclStr += String.format("} %s_PCD_DATABASE_UNINIT;", phase) + newLine + newLine;
1256
1257         result.put("initDeclStr", initDeclStr);
1258         result.put("initInstStr", initInstStr);
1259         result.put("uninitDeclStr", uninitDeclStr);
1260
1261         return result;
1262     }
1263
1264      public void genCode ()
1265         throws EntityException {
1266
1267         final String newLine                        = "\r\n";
1268         final String declNewLine                    = ";\r\n";
1269         final String tab                            = "\t";
1270         final String commaNewLine                   = ", \r\n";
1271
1272         int i;
1273         ArrayList<String> decla;
1274         ArrayList<String> inst;
1275
1276         String macroStr   = "";
1277         String initDeclStr = "";
1278         String initInstStr = "";
1279         String uninitDeclStr = "";
1280
1281         List<Token> initTokens = new ArrayList<Token> ();
1282         List<Token> uninitTokens = new ArrayList<Token> ();
1283
1284         HashMap <String, ArrayList<String>> initCode = new HashMap<String, ArrayList<String>> ();
1285         HashMap <String, ArrayList<String>> uninitCode = new HashMap<String, ArrayList<String>> ();
1286
1287         getTwoGroupsOfTokens (alTokens, initTokens, uninitTokens);
1288
1289         //
1290         // Generate Structure Declaration for PcdTokens without Default Value
1291         // PEI_PCD_DATABASE_INIT
1292         //
1293         java.util.Comparator<Token> comparator = new AlignmentSizeComp();
1294         java.util.Collections.sort(initTokens, comparator);
1295         initCode = processTokens(initTokens);
1296
1297         //
1298         // Generate Structure Declaration for PcdTokens without Default Value
1299         // PEI_PCD_DATABASE_UNINIT
1300         //
1301         java.util.Collections.sort(uninitTokens, comparator);
1302         uninitCode = processTokens(uninitTokens);
1303
1304         //
1305         // Generate size info Macro for all Tables
1306         //
1307         macroStr += guidTable.getSizeMacro();
1308         macroStr += stringTable.getSizeMacro();
1309         macroStr += skuIdTable.getSizeMacro();
1310         macroStr += localTokenNumberTable.getSizeMacro();
1311         macroStr += exMapTable.getSizeMacro();
1312
1313         //
1314         // Generate existance info Macro for all Tables
1315         //
1316         macroStr += guidTable.getExistanceMacro();
1317         macroStr += stringTable.getExistanceMacro();
1318         macroStr += skuIdTable.getExistanceMacro();
1319         macroStr += localTokenNumberTable.getExistanceMacro();
1320         macroStr += exMapTable.getExistanceMacro();
1321
1322         //
1323         // Generate Structure Declaration for PcdTokens with Default Value
1324         // for example PEI_PCD_DATABASE_INIT
1325         //
1326         initDeclStr += "typedef struct {" + newLine;
1327             {
1328                 initDeclStr += tab + exMapTable.getTypeDeclaration();
1329                 initDeclStr += tab + guidTable.getTypeDeclaration();
1330                 initDeclStr += tab + localTokenNumberTable.getTypeDeclaration();
1331                 initDeclStr += tab + stringTable.getTypeDeclaration();
1332                 initDeclStr += tab + sizeTable.getTypeDeclaration();
1333                 initDeclStr += tab + skuIdTable.getTypeDeclaration();
1334                 if (phase.equalsIgnoreCase("PEI")) {
1335                     initDeclStr += tab + "SKU_ID            SystemSkuId;" + newLine;
1336                 }
1337
1338                 decla = initCode.get(new String("Declaration"));
1339                 for (i = 0; i < decla.size(); i++)  {
1340                     initDeclStr += tab + decla.get(i) + declNewLine;
1341                 }
1342
1343                 //
1344                 // Generate Structure Declaration for PcdToken with SkuEnabled
1345                 //
1346                 decla = initCode.get("DeclarationForSku");
1347
1348                 for (i = 0; i < decla.size(); i++) {
1349                     initDeclStr += tab + decla.get(i) + declNewLine;
1350                 }
1351             }
1352         initDeclStr += String.format("} %s_PCD_DATABASE_INIT;\r\n\r\n", phase);
1353
1354         //
1355         // Generate MACRO for structure intialization of PCDTokens with Default Value
1356         // The sequence must match the sequence of declaration of the memembers in the structure
1357         String tmp = String.format("%s_PCD_DATABASE_INIT g%sPcdDbInit = { ", phase.toUpperCase(), phase.toUpperCase());
1358         initInstStr +=  tmp + newLine;
1359         initInstStr += tab + genInstantiationStr(exMapTable.getInstantiation()) + commaNewLine;
1360         initInstStr += tab + genInstantiationStr(guidTable.getInstantiation()) + commaNewLine;
1361         initInstStr += tab + genInstantiationStr(localTokenNumberTable.getInstantiation()) + commaNewLine;
1362         initInstStr += tab + genInstantiationStr(stringTable.getInstantiation()) + commaNewLine;
1363         initInstStr += tab + genInstantiationStr(sizeTable.getInstantiation()) + commaNewLine;
1364         initInstStr += tab + genInstantiationStr(skuIdTable.getInstantiation()) + commaNewLine;
1365         //
1366         // For SystemSkuId
1367         //
1368         if (phase.equalsIgnoreCase("PEI")) {
1369             initInstStr += tab + "0" + tab + "/* SystemSkuId */" + commaNewLine;
1370         }
1371
1372         inst = initCode.get("Instantiation");
1373         for (i = 0; i < inst.size(); i++) {
1374             initInstStr += tab + inst.get(i) + commaNewLine;
1375         }
1376
1377         inst = initCode.get("InstantiationForSku");
1378         for (i = 0; i < inst.size(); i++) {
1379             initInstStr += tab + inst.get(i);
1380             if (i != inst.size() - 1) {
1381                 initInstStr += commaNewLine;
1382             }
1383         }
1384
1385         initInstStr += "};";
1386
1387         uninitDeclStr += "typedef struct {" + newLine;
1388             {
1389                 decla = uninitCode.get("Declaration");
1390                 if (decla.size() == 0) {
1391                     uninitDeclStr += "UINT8 dummy /* The UINT struct is empty */" + declNewLine;
1392                 } else {
1393
1394                     for (i = 0; i < decla.size(); i++) {
1395                         uninitDeclStr += tab + decla.get(i) + declNewLine;
1396                     }
1397
1398                     decla = uninitCode.get("DeclarationForSku");
1399
1400                     for (i = 0; i < decla.size(); i++) {
1401                         uninitDeclStr += tab + decla.get(i) + declNewLine;
1402                     }
1403                 }
1404             }
1405         uninitDeclStr += String.format("} %s_PCD_DATABASE_UNINIT;\r\n\r\n", phase);
1406
1407         cString = initInstStr + newLine;
1408         hString = macroStr      + newLine
1409               + initDeclStr   + newLine
1410               + uninitDeclStr + newLine
1411               + newLine;
1412
1413         hString += String.format("#define PCD_%s_SERVICE_DRIVER_VERSION                 %d", phase, version);
1414
1415     }
1416
1417     public static String genInstantiationStr (ArrayList<String> alStr) {
1418         String str = "";
1419         for (int i = 0; i< alStr.size(); i++) {
1420             if (i != 0) {
1421                 str += "\t";
1422             }
1423             str += alStr.get(i);
1424             if (i != alStr.size() - 1) {
1425                 str += "\r\n";
1426             }
1427         }
1428
1429         return str;
1430     }
1431
1432     private HashMap<String, ArrayList<String>> processTokens (List<Token> alToken)
1433         throws EntityException {
1434
1435         HashMap <String, ArrayList<String>> map = new HashMap<String, ArrayList<String>>();
1436
1437         ArrayList<String> decl = new ArrayList<String>();
1438         ArrayList<String> declForSkuEnableType = new ArrayList<String>();
1439         ArrayList<String> inst = new ArrayList<String>();
1440         ArrayList<String> instForSkuEnableType = new ArrayList<String>();
1441
1442         for (int index = 0; index < alToken.size(); index++) {
1443             Token token = alToken.get(index);
1444
1445             if (token.isSkuEnable()) {
1446                 //
1447                 // BugBug: Schema only support Data type now
1448                 //
1449                 int tableIdx;
1450
1451                 tableIdx = skuIdTable.add(token);
1452
1453                 decl.add(getSkuEnabledTypeDeclaration(token));
1454                 if (token.hasDefaultValue()) {
1455                     inst.add(getSkuEnabledTypeInstantiaion(token, tableIdx));
1456                 }
1457
1458                 declForSkuEnableType.add(getDataTypeDeclarationForSkuEnabled(token));
1459                 if (token.hasDefaultValue()) {
1460                     instForSkuEnableType.add(getDataTypeInstantiationForSkuEnabled(token));
1461                 }
1462
1463             } else {
1464                 if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {
1465                     decl.add(getVariableEnableTypeDeclaration(token));
1466                     inst.add(getVariableEnableInstantiation(token));
1467                 } else if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {
1468                     decl.add(getVpdEnableTypeDeclaration(token));
1469                     inst.add(getVpdEnableTypeInstantiation(token));
1470                 } else if (token.isUnicodeStringType()) {
1471                     decl.add(getStringTypeDeclaration(token));
1472                     inst.add(getStringTypeInstantiation(stringTable.add(token.getStringTypeString(), token), token));
1473                 }
1474                 else {
1475                     decl.add(getDataTypeDeclaration(token));
1476                     if (token.hasDefaultValue()) {
1477                         inst.add(getDataTypeInstantiation(token));
1478                     }
1479                 }
1480             }
1481
1482             sizeTable.add(token);
1483             localTokenNumberTable.add(token);
1484             token.tokenNumber = assignedTokenNumber++;
1485
1486         }
1487
1488         map.put("Declaration",  decl);
1489         map.put("DeclarationForSku", declForSkuEnableType);
1490         map.put("Instantiation", inst);
1491         map.put("InstantiationForSku", instForSkuEnableType);
1492
1493         return map;
1494     }
1495
1496     private String getSkuEnabledTypeDeclaration (Token token) {
1497         return String.format("%-20s%s;\r\n", "SKU_HEAD", token.getPrimaryKeyString());
1498     }
1499
1500     private String getSkuEnabledTypeInstantiaion (Token token, int SkuTableIdx) {
1501
1502         String offsetof = String.format(PcdDatabase.offsetOfSkuHeadStrTemplate, phase, token.hasDefaultValue()? "Init" : "Uninit", token.getPrimaryKeyString());
1503         return String.format("{ %s, %d } /* SKU_ENABLED: %s */", offsetof, SkuTableIdx, token.getPrimaryKeyString());
1504     }
1505
1506     private String getDataTypeDeclarationForSkuEnabled (Token token) {
1507         String typeStr = "";
1508
1509         if (token.datumType == Token.DATUM_TYPE.UINT8) {
1510             typeStr = "UINT8 %s_%s[%d];\r\n";
1511         } else if (token.datumType == Token.DATUM_TYPE.UINT16) {
1512             typeStr = "UINT16 %s_%s[%d];\r\n";
1513         } else if (token.datumType == Token.DATUM_TYPE.UINT32) {
1514             typeStr = "UINT32 %s_%s[%d];\r\n";
1515         } else if (token.datumType == Token.DATUM_TYPE.UINT64) {
1516             typeStr = "UINT64 %s_%s[%d];\r\n";
1517         } else if (token.datumType == Token.DATUM_TYPE.BOOLEAN) {
1518             typeStr = "BOOLEAN %s_%s[%d];\r\n";
1519         } else if (token.datumType == Token.DATUM_TYPE.POINTER) {
1520             return String.format("UINT8 %s_%s[%d];\r\n", token.getPrimaryKeyString(), "SkuDataTable", token.datumSize * token.skuData.size());
1521         }
1522
1523         return String.format(typeStr, token.getPrimaryKeyString(), "SkuDataTable", token.skuData.size());
1524
1525     }
1526
1527     private String getDataTypeInstantiationForSkuEnabled (Token token) {
1528         String str = "";
1529
1530         if (token.datumType == Token.DATUM_TYPE.POINTER) {
1531             return String.format("UINT8 %s_%s[%d]", token.getPrimaryKeyString(), "SkuDataTable", token.datumSize * token.skuData.size());
1532         } else {
1533             str = "{ ";
1534             for (int idx = 0; idx < token.skuData.size(); idx++) {
1535                 str += token.skuData.get(idx).toString();
1536                 if (idx != token.skuData.size() - 1) {
1537                     str += ", ";
1538                 }
1539             }
1540             str += "}";
1541
1542             return str;
1543         }
1544
1545     }
1546
1547     private String getDataTypeInstantiationForVariableDefault_new (Token token, String cName, int skuId) {
1548         return String.format("%s /* %s */", token.skuData.get(skuId).value.hiiDefaultValue, cName);
1549     }
1550
1551     private String getDataTypeInstantiation (Token token) {
1552
1553         if (token.datumType == Token.DATUM_TYPE.POINTER) {
1554             return String.format("%s /* %s */", token.getDefaultSku().value, token.getPrimaryKeyString());
1555         } else {
1556             return String.format("%s /* %s */", token.getDefaultSku().value, token.getPrimaryKeyString());
1557         }
1558     }
1559
1560     private String getCType (Token t)
1561         throws EntityException {
1562
1563         if (t.isHiiEnable()) {
1564             return "VARIABLE_HEAD";
1565         }
1566
1567         if (t.isVpdEnable()) {
1568             return "VPD_HEAD";
1569         }
1570
1571         if (t.isUnicodeStringType()) {
1572             return "STRING_HEAD";
1573         }
1574
1575         switch (t.datumType) {
1576         case UINT64:
1577             return "UINT64";
1578         case UINT32:
1579             return "UINT32";
1580         case UINT16:
1581             return "UINT16";
1582         case UINT8:
1583             return "UINT8";
1584         case BOOLEAN:
1585             return "BOOLEAN";
1586         case POINTER:
1587             return "UINT8";
1588         default:
1589             throw new EntityException("Unknown type in getDataTypeCDeclaration");
1590         }
1591     }
1592
1593     private void getCDeclarationString(Token t)
1594         throws EntityException {
1595
1596         if (t.isSkuEnable()) {
1597             privateGlobalName = String.format("%s_%s", t.getPrimaryKeyString(), skuDataTableTemplate);
1598         } else {
1599             privateGlobalName = t.getPrimaryKeyString();
1600         }
1601
1602         if (t.isUnicodeStringType()) {
1603             privateGlobalCCode = String.format("%-20s%s[%d];\r\n", "STRING_HEAD", t.getPrimaryKeyString(), t.getSkuIdCount());
1604         } else {
1605             String type = getCType(t);
1606             if (t.datumType == Token.DATUM_TYPE.POINTER) {
1607                 int bufferSize;
1608                 if (t.isASCIIStringType()) {
1609                     //
1610                     // Build tool will add a NULL string at the end of the ASCII string
1611                     //
1612                     bufferSize = t.datumSize + 1;
1613                 } else {
1614                     bufferSize = t.datumSize;
1615                 }
1616                 privateGlobalCCode = String.format("%-20s%s[%d][%d];\r\n", type, privateGlobalName, t.getSkuIdCount(), bufferSize);
1617             } else {
1618                 privateGlobalCCode = String.format("%-20s%s[%d];\r\n", type, privateGlobalName, t.getSkuIdCount());
1619             }
1620         }
1621     }
1622
1623     private String getDataTypeDeclarationForVariableDefault_new (Token token, String cName, int skuId) {
1624
1625         String typeStr;
1626
1627         if (token.datumType == Token.DATUM_TYPE.UINT8) {
1628             typeStr = "UINT8";
1629         } else if (token.datumType == Token.DATUM_TYPE.UINT16) {
1630             typeStr = "UINT16";
1631         } else if (token.datumType == Token.DATUM_TYPE.UINT32) {
1632             typeStr = "UINT32";
1633         } else if (token.datumType == Token.DATUM_TYPE.UINT64) {
1634             typeStr = "UINT64";
1635         } else if (token.datumType == Token.DATUM_TYPE.BOOLEAN) {
1636             typeStr = "BOOLEAN";
1637         } else if (token.datumType == Token.DATUM_TYPE.POINTER) {
1638             return String.format("%-20s%s[%d];\r\n", cName, token.datumSize);
1639         } else {
1640             typeStr = "";
1641         }
1642
1643         return String.format("%-20s%s;\r\n", typeStr, cName);
1644     }
1645
1646     private String getDataTypeDeclaration (Token token) {
1647
1648         String typeStr = "";
1649
1650         if (token.datumType == Token.DATUM_TYPE.UINT8) {
1651             typeStr = "UINT8";
1652         } else if (token.datumType == Token.DATUM_TYPE.UINT16) {
1653             typeStr = "UINT16";
1654         } else if (token.datumType == Token.DATUM_TYPE.UINT32) {
1655             typeStr = "UINT32";
1656         } else if (token.datumType == Token.DATUM_TYPE.UINT64) {
1657             typeStr = "UINT64";
1658         } else if (token.datumType == Token.DATUM_TYPE.BOOLEAN) {
1659             typeStr = "BOOLEAN";
1660         } else if (token.datumType == Token.DATUM_TYPE.POINTER) {
1661             return String.format("UINT8 %s[%d]", token.getPrimaryKeyString(), token.datumSize);
1662         } else {
1663         }
1664
1665         return String.format("%s    %s", typeStr, token.getPrimaryKeyString());
1666     }
1667
1668     private String getVpdEnableTypeDeclaration (Token token) {
1669         return String.format("VPD_HEAD %s", token.getPrimaryKeyString());
1670     }
1671
1672     private String getTypeInstantiation (Token t, ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) throws EntityException {
1673
1674         int     i;
1675
1676         String s;
1677         s = String.format("/* %s */", t.getPrimaryKeyString()) + newLine;
1678         s += tab + "{" + newLine;
1679
1680         for (i = 0; i < t.skuData.size(); i++) {
1681             if (t.isUnicodeStringType() && !t.isHiiEnable()) {
1682                 s += tab + tab + String.format("{ %d }", stringTable.add(t.skuData.get(i).value.value, t));
1683             } else if (t.isHiiEnable()) {
1684                 /* VPD_HEAD definition
1685                    typedef struct {
1686                       UINT16  GuidTableIndex;   // Offset in Guid Table in units of GUID.
1687                       UINT16  StringIndex;      // Offset in String Table in units of UINT16.
1688                       UINT16  Offset;           // Offset in Variable
1689                     } VARIABLE_HEAD  ;
1690                  */
1691                 String variableDefaultName = String.format("%s_VariableDefault_%d", t.getPrimaryKeyString(), i);
1692
1693                 s += tab + tab + String.format("{ %d, %d, %s, %s }", guidTable.add(t.skuData.get(i).value.variableGuid, t.getPrimaryKeyString()),
1694                                                           stringTable.add(t.skuData.get(i).value.getStringOfVariableName(), t),
1695                                                           t.skuData.get(i).value.variableOffset,
1696                                                           String.format("offsetof(%s_PCD_DATABASE, Init.%s)", phase, variableDefaultName)
1697                                                           );
1698                 //
1699                 // We need to support the default value, so we add the declaration and
1700                 // the instantiation for the default value.
1701                 //
1702                 CStructTypeDeclaration decl = new CStructTypeDeclaration (variableDefaultName,
1703                                                         getDataTypeAlignmentSize(t),
1704                                                         getDataTypeDeclarationForVariableDefault_new(t, variableDefaultName, i),
1705                                                         true
1706                                                         );
1707                 declaList.add(decl);
1708                 instTable.put(variableDefaultName, getDataTypeInstantiationForVariableDefault_new (t, variableDefaultName, i));
1709             } else if (t.isVpdEnable()) {
1710                     /* typedef  struct {
1711                         UINT32  Offset;
1712                       } VPD_HEAD;
1713                     */
1714                 s += tab + tab + String.format("{ %s }", t.skuData.get(i).value.vpdOffset);
1715             } else {
1716                 if (t.isByteStreamType()) {
1717                     //
1718                     // Byte stream type input has their own "{" "}", so we won't help to insert.
1719                     //
1720                     s += tab + tab + String.format(" %s ", t.skuData.get(i).value.value);
1721                 } else {
1722                     s += tab + tab + String.format("{ %s }", t.skuData.get(i).value.value);
1723                 }
1724             }
1725
1726             if (i != t.skuData.size() - 1) {
1727                 s += commaNewLine;
1728             } else {
1729                 s += newLine;
1730             }
1731
1732         }
1733
1734         s += tab + "}";
1735
1736         return s;
1737     }
1738
1739     private String getVpdEnableTypeInstantiation (Token token) {
1740         return String.format("{ %s } /* %s */", token.getDefaultSku().vpdOffset,
1741                                                 token.getPrimaryKeyString());
1742     }
1743
1744     private String getStringTypeDeclaration (Token token) {
1745         return String.format("UINT16  %s", token.getPrimaryKeyString());
1746     }
1747
1748     private String getStringTypeInstantiation (int StringTableIdx, Token token) {
1749         return String.format ("%d /* %s */", StringTableIdx,
1750                                              token.getPrimaryKeyString());
1751     }
1752
1753
1754     private String getVariableEnableTypeDeclaration (Token token) {
1755       return String.format("VARIABLE_HEAD  %s", token.getPrimaryKeyString());
1756     }
1757
1758     private String getVariableEnableInstantiation (Token token)
1759         throws EntityException {
1760         //
1761         // Need scott fix
1762         //
1763         return String.format("{ %d, %d, %s } /* %s */", guidTable.add(token.getDefaultSku().variableGuid, token.getPrimaryKeyString()),
1764                                                         stringTable.add(token.getDefaultSku().getStringOfVariableName(), token),
1765                                                         token.getDefaultSku().variableOffset,
1766                                                         token.getPrimaryKeyString());
1767     }
1768
1769     public int getTotalTokenNumber () {
1770         return sizeTable.getTableLen();
1771     }
1772
1773     public static String getPcdDatabaseCommonDefinitions ()
1774         throws EntityException {
1775
1776         String retStr = "";
1777         try {
1778             File file = new File(GlobalData.getWorkspacePath() + File.separator +
1779                                  "Tools" + File.separator +
1780                                  "Conf" + File.separator +
1781                                  "Pcd" + File.separator +
1782                                  "PcdDatabaseCommonDefinitions.sample");
1783             FileReader reader = new FileReader(file);
1784             BufferedReader  in = new BufferedReader(reader);
1785             String str;
1786             while ((str = in.readLine()) != null) {
1787                 retStr = retStr +"\r\n" + str;
1788             }
1789         } catch (Exception ex) {
1790             throw new EntityException("Fatal error when generating PcdDatabase Common Definitions");
1791         }
1792
1793         return retStr;
1794     }
1795
1796     public static String getPcdDxeDatabaseDefinitions ()
1797         throws EntityException {
1798
1799         String retStr = "";
1800         try {
1801             File file = new File(GlobalData.getWorkspacePath() + File.separator +
1802                                  "Tools" + File.separator +
1803                                  "Conf" + File.separator +
1804                                  "Pcd" + File.separator +
1805                                  "PcdDatabaseDxeDefinitions.sample");
1806             FileReader reader = new FileReader(file);
1807             BufferedReader  in = new BufferedReader(reader);
1808             String str;
1809             while ((str = in.readLine()) != null) {
1810                 retStr = retStr +"\r\n" + str;
1811             }
1812         } catch (Exception ex) {
1813             throw new EntityException("Fatal error when generating PcdDatabase Dxe Definitions");
1814         }
1815
1816         return retStr;
1817     }
1818
1819     public static String getPcdPeiDatabaseDefinitions ()
1820         throws EntityException {
1821
1822         String retStr = "";
1823         try {
1824             File file = new File(GlobalData.getWorkspacePath() + File.separator +
1825                                  "Tools" + File.separator +
1826                                  "Conf" + File.separator +
1827                                  "Pcd" + File.separator +
1828                                  "PcdDatabasePeiDefinitions.sample");
1829             FileReader reader = new FileReader(file);
1830             BufferedReader  in = new BufferedReader(reader);
1831             String str;
1832             while ((str = in.readLine()) != null) {
1833                 retStr = retStr +"\r\n" + str;
1834             }
1835         } catch (Exception ex) {
1836             throw new EntityException("Fatal error when generating PcdDatabase Pei Definitions");
1837         }
1838
1839         return retStr;
1840     }
1841
1842 }
1843
1844 class ModuleInfo {
1845     private String                  type;
1846     private FpdModuleIdentification moduleId;
1847     private PcdBuildDefinitionDocument.PcdBuildDefinition pcdBuildDef;
1848
1849
1850
1851     public ModuleInfo (FpdModuleIdentification moduleId, String type, XmlObject pcdDef) {
1852         this.moduleId = moduleId;
1853         this.type   = type;
1854         this.pcdBuildDef = ((PcdBuildDefinitionDocument)pcdDef).getPcdBuildDefinition();
1855     }
1856     public String getModuleType (){
1857         return this.type;
1858     }
1859     public FpdModuleIdentification getModuleId (){
1860         return this.moduleId;
1861     }
1862     public PcdBuildDefinitionDocument.PcdBuildDefinition getPcdBuildDef(){
1863         return this.pcdBuildDef;
1864     }
1865 }
1866
1867 /** This action class is to collect PCD information from MSA, SPD, FPD xml file.
1868     This class will be used for wizard and build tools, So it can *not* inherit
1869     from buildAction or UIAction.
1870 **/
1871 public class CollectPCDAction {
1872     /// memoryDatabase hold all PCD information collected from SPD, MSA, FPD.
1873     private MemoryDatabaseManager dbManager;
1874
1875     /// Workspacepath hold the workspace information.
1876     private String                workspacePath;
1877
1878     /// FPD file is the root file.
1879     private String                fpdFilePath;
1880
1881     /// Message level for CollectPCDAction.
1882     private int                   originalMessageLevel;
1883
1884     /// Cache the fpd docment instance for private usage.
1885     private PlatformSurfaceAreaDocument fpdDocInstance;
1886
1887     /// xmlObject name
1888     private static String xmlObjectName = "PcdBuildDefinition";
1889
1890     /**
1891       Set WorkspacePath parameter for this action class.
1892
1893       @param workspacePath parameter for this action
1894     **/
1895     public void setWorkspacePath(String workspacePath) {
1896         this.workspacePath = workspacePath;
1897     }
1898
1899     /**
1900       Set action message level for CollectPcdAction tool.
1901
1902       The message should be restored when this action exit.
1903
1904       @param actionMessageLevel parameter for this action
1905     **/
1906     public void setActionMessageLevel(int actionMessageLevel) {
1907         originalMessageLevel       = ActionMessage.messageLevel;
1908         ActionMessage.messageLevel = actionMessageLevel;
1909     }
1910
1911     /**
1912       Set FPDFileName parameter for this action class.
1913
1914       @param fpdFilePath    fpd file path
1915     **/
1916     public void setFPDFilePath(String fpdFilePath) {
1917         this.fpdFilePath = fpdFilePath;
1918     }
1919
1920     /**
1921       Common function interface for outer.
1922
1923       @param workspacePath The path of workspace of current build or analysis.
1924       @param fpdFilePath   The fpd file path of current build or analysis.
1925       @param messageLevel  The message level for this Action.
1926
1927       @throws  Exception The exception of this function. Because it can *not* be predict
1928                          where the action class will be used. So only Exception can be throw.
1929
1930     **/
1931     public void perform(String workspacePath, String fpdFilePath,
1932                         int messageLevel) throws Exception {
1933         setWorkspacePath(workspacePath);
1934         setFPDFilePath(fpdFilePath);
1935         setActionMessageLevel(messageLevel);
1936         checkParameter();
1937         execute();
1938         ActionMessage.messageLevel = originalMessageLevel;
1939     }
1940
1941     /**
1942       Core execution function for this action class.
1943
1944       This function work flows will be:
1945       1) Collect and prepocess PCD information from FPD file, all PCD
1946       information will be stored into memory database.
1947       2) Generate 3 strings for
1948         a) All modules using Dynamic(Ex) PCD entry.(Token Number)
1949         b) PEI PCDDatabase (C Structure) for PCD Service PEIM.
1950         c) DXE PCD Database (C structure) for PCD Service DXE.
1951
1952
1953       @throws  EntityException Exception indicate failed to execute this action.
1954
1955     **/
1956     public void execute() throws EntityException {
1957         //
1958         // Get memoryDatabaseManager instance from GlobalData.
1959         // The memoryDatabaseManager should be initialized for whatever build
1960         // tools or wizard tools
1961         //
1962         if((dbManager = GlobalData.getPCDMemoryDBManager()) == null) {
1963             throw new EntityException("The instance of PCD memory database manager is null");
1964         }
1965
1966         //
1967         // Collect all PCD information defined in FPD file.
1968         // Evenry token defind in FPD will be created as an token into
1969         // memory database.
1970         //
1971         createTokenInDBFromFPD();
1972
1973         //
1974         // Call Private function genPcdDatabaseSourceCode (void); ComponentTypeBsDriver
1975         // 1) Generate for PEI, DXE PCD DATABASE's definition and initialization.
1976         //
1977         genPcdDatabaseSourceCode ();
1978
1979     }
1980
1981     /**
1982       This function generates source code for PCD Database.
1983
1984       @param void
1985       @throws EntityException  If the token does *not* exist in memory database.
1986
1987     **/
1988     private void genPcdDatabaseSourceCode()
1989         throws EntityException {
1990         String PcdCommonHeaderString = PcdDatabase.getPcdDatabaseCommonDefinitions ();
1991
1992         ArrayList<Token> alPei = new ArrayList<Token> ();
1993         ArrayList<Token> alDxe = new ArrayList<Token> ();
1994
1995         dbManager.getTwoPhaseDynamicRecordArray(alPei, alDxe);
1996         PcdDatabase pcdPeiDatabase = new PcdDatabase (alPei, "PEI", 0);
1997         pcdPeiDatabase.genCodeNew();
1998         MemoryDatabaseManager.PcdPeimHString        = PcdCommonHeaderString + pcdPeiDatabase.getHString()
1999                                             + PcdDatabase.getPcdPeiDatabaseDefinitions();
2000         MemoryDatabaseManager.PcdPeimCString        = pcdPeiDatabase.getCString();
2001
2002         PcdDatabase pcdDxeDatabase = new PcdDatabase (alDxe,
2003                                                       "DXE",
2004                                                       alPei.size()
2005                                                       );
2006         pcdDxeDatabase.genCodeNew();
2007         MemoryDatabaseManager.PcdDxeHString   = MemoryDatabaseManager.PcdPeimHString + pcdDxeDatabase.getHString()
2008                                       + PcdDatabase.getPcdDxeDatabaseDefinitions();
2009         MemoryDatabaseManager.PcdDxeCString   = pcdDxeDatabase.getCString();
2010     }
2011
2012     /**
2013       Get component array from FPD.
2014
2015       This function maybe provided by some Global class.
2016
2017       @return List<ModuleInfo> the component array.
2018
2019      */
2020     private List<ModuleInfo> getComponentsFromFPD()
2021         throws EntityException {
2022         List<ModuleInfo>            allModules  = new ArrayList<ModuleInfo>();
2023         ModuleInfo                  current     = null;
2024         int                         index       = 0;
2025         FrameworkModulesDocument.FrameworkModules fModules = null;
2026         ModuleSADocument.ModuleSA[]               modules  = null;
2027         HashMap<String, XmlObject>                map      = new HashMap<String, XmlObject>();
2028
2029         if (fpdDocInstance == null) {
2030             try {
2031                 fpdDocInstance = (PlatformSurfaceAreaDocument)XmlObject.Factory.parse(new File(fpdFilePath));
2032             } catch(IOException ioE) {
2033                 throw new EntityException("File IO error for xml file:" + fpdFilePath + "\n" + ioE.getMessage());
2034             } catch(XmlException xmlE) {
2035                 throw new EntityException("Can't parse the FPD xml fle:" + fpdFilePath + "\n" + xmlE.getMessage());
2036             }
2037
2038         }
2039
2040         Map<FpdModuleIdentification,XmlObject>pcdBuildDef = GlobalData.getFpdModuleSaXmlObject(CollectPCDAction.xmlObjectName);
2041         Set<FpdModuleIdentification> pcdBuildKeySet = pcdBuildDef.keySet();
2042         Iterator item = pcdBuildKeySet.iterator();
2043         while (item.hasNext()){
2044             FpdModuleIdentification id = (FpdModuleIdentification)item.next();
2045             allModules.add(new ModuleInfo(id, id.getModule().getModuleType(),pcdBuildDef.get(id)));
2046         }
2047
2048         return allModules;
2049     }
2050
2051     /**
2052       Create token instance object into memory database, the token information
2053       comes for FPD file. Normally, FPD file will contain all token platform
2054       informations.
2055
2056       @return FrameworkPlatformDescriptionDocument   The FPD document instance for furture usage.
2057
2058       @throws EntityException                        Failed to parse FPD xml file.
2059
2060     **/
2061     private void createTokenInDBFromFPD()
2062         throws EntityException {
2063         int                                 index             = 0;
2064         int                                 index2            = 0;
2065         int                                 pcdIndex          = 0;
2066         List<PcdBuildDefinition.PcdData>    pcdBuildDataArray = new ArrayList<PcdBuildDefinition.PcdData>();
2067         PcdBuildDefinition.PcdData          pcdBuildData      = null;
2068         Token                               token             = null;
2069         SkuInstance                         skuInstance       = null;
2070         int                                 skuIndex          = 0;
2071         List<ModuleInfo>                    modules           = null;
2072         String                              primaryKey        = null;
2073         String                              exceptionString   = null;
2074         UsageInstance                       usageInstance     = null;
2075         String                              primaryKey1       = null;
2076         String                              primaryKey2       = null;
2077         boolean                             isDuplicate       = false;
2078         Token.PCD_TYPE                      pcdType           = Token.PCD_TYPE.UNKNOWN;
2079         Token.DATUM_TYPE                    datumType         = Token.DATUM_TYPE.UNKNOWN;
2080         long                                tokenNumber       = 0;
2081         String                              moduleName        = null;
2082         String                              datum             = null;
2083         int                                 maxDatumSize      = 0;
2084         String[]                            tokenSpaceStrRet  = null;
2085
2086         //
2087         // ----------------------------------------------
2088         // 1), Get all <ModuleSA> from FPD file.
2089         // ----------------------------------------------
2090         //
2091         modules = getComponentsFromFPD();
2092
2093         if (modules == null) {
2094             throw new EntityException("[FPD file error] No modules in FPD file, Please check whether there are elements in <FrameworkModules> in FPD file!");
2095         }
2096
2097         //
2098         // -------------------------------------------------------------------
2099         // 2), Loop all modules to process <PcdBuildDeclarations> for each module.
2100         // -------------------------------------------------------------------
2101         //
2102         for (index = 0; index < modules.size(); index ++) {
2103             isDuplicate =  false;
2104             for (index2 = 0; index2 < index; index2 ++) {
2105                 //
2106                 // BUGBUG: For transition schema, we can *not* get module's version from
2107                 // <ModuleSAs>, It is work around code.
2108                 //
2109                 primaryKey1 = UsageInstance.getPrimaryKey(modules.get(index).getModuleId().getModule().getName(),
2110                                                           null,
2111                                                           null,
2112                                                           null,
2113                                                           modules.get(index).getModuleId().getArch(),
2114                                                           null);
2115                 primaryKey2 = UsageInstance.getPrimaryKey(modules.get(index2).getModuleId().getModule().getName(),
2116                                                           null,
2117                                                           null,
2118                                                           null,
2119                                                           modules.get(index2).getModuleId().getArch(),
2120                                                           null);
2121                 if (primaryKey1.equalsIgnoreCase(primaryKey2)) {
2122                     isDuplicate = true;
2123                     break;
2124                 }
2125             }
2126
2127             if (isDuplicate) {
2128                 continue;
2129             }
2130
2131             //
2132             // It is legal for a module does not contains ANY pcd build definitions.
2133             //
2134             if (modules.get(index).getPcdBuildDef() == null) {
2135                 continue;
2136             }
2137
2138             pcdBuildDataArray = modules.get(index).getPcdBuildDef().getPcdDataList();
2139
2140             moduleName = modules.get(index).getModuleId().getModule().getName();
2141
2142             //
2143             // ----------------------------------------------------------------------
2144             // 2.1), Loop all Pcd entry for a module and add it into memory database.
2145             // ----------------------------------------------------------------------
2146             //
2147             for (pcdIndex = 0; pcdIndex < pcdBuildDataArray.size(); pcdIndex ++) {
2148                 pcdBuildData = pcdBuildDataArray.get(pcdIndex);
2149
2150                 try {
2151                     tokenSpaceStrRet = GlobalData.getGuidInfoFromCname(pcdBuildData.getTokenSpaceGuidCName());
2152                 } catch ( Exception e ) {
2153                     throw new EntityException ("Faile get Guid for token " + pcdBuildData.getCName() + ":" + e.getMessage());
2154                 }
2155
2156                 if (tokenSpaceStrRet == null) {
2157                     throw new EntityException ("Fail to get Token space guid for token" + pcdBuildData.getCName());
2158                 }
2159
2160                 primaryKey   = Token.getPrimaryKeyString(pcdBuildData.getCName(),
2161                                                          translateSchemaStringToUUID(tokenSpaceStrRet[1]));
2162                 pcdType      = Token.getpcdTypeFromString(pcdBuildData.getItemType().toString());
2163                 datumType    = Token.getdatumTypeFromString(pcdBuildData.getDatumType().toString());
2164                 tokenNumber  = Long.decode(pcdBuildData.getToken().toString());
2165                 if (pcdBuildData.getValue() != null) {
2166                     datum = pcdBuildData.getValue().toString();
2167                 } else {
2168                     datum = null;
2169                 }
2170                 maxDatumSize = pcdBuildData.getMaxDatumSize();
2171
2172                 if ((pcdType    == Token.PCD_TYPE.FEATURE_FLAG) &&
2173                     (datumType  != Token.DATUM_TYPE.BOOLEAN)){
2174                     exceptionString = String.format("[FPD file error] For PCD %s in module %s, the PCD type is FEATRUE_FLAG but "+
2175                                                     "datum type of this PCD entry is not BOOLEAN!",
2176                                                     pcdBuildData.getCName(),
2177                                                     moduleName);
2178                     throw new EntityException(exceptionString);
2179                 }
2180
2181                 //
2182                 // -------------------------------------------------------------------------------------------
2183                 // 2.1.1), Do some necessary checking work for FixedAtBuild, FeatureFlag and PatchableInModule
2184                 // -------------------------------------------------------------------------------------------
2185                 //
2186                 if (!Token.isDynamic(pcdType)) {
2187                      //
2188                      // Value is required.
2189                      //
2190                      if (datum == null) {
2191                          exceptionString = String.format("[FPD file error] There is no value for PCD entry %s in module %s!",
2192                                                          pcdBuildData.getCName(),
2193                                                          moduleName);
2194                          throw new EntityException(exceptionString);
2195                      }
2196
2197                      //
2198                      // Check whether the datum size is matched datum type.
2199                      //
2200                      if ((exceptionString = verifyDatum(pcdBuildData.getCName(),
2201                                                         moduleName,
2202                                                         datum,
2203                                                         datumType,
2204                                                         maxDatumSize)) != null) {
2205                          throw new EntityException(exceptionString);
2206                      }
2207                 }
2208
2209                 //
2210                 // ---------------------------------------------------------------------------------
2211                 // 2.1.2), Create token or update token information for current anaylized PCD data.
2212                 // ---------------------------------------------------------------------------------
2213                 //
2214                 if (dbManager.isTokenInDatabase(primaryKey)) {
2215                     //
2216                     // If the token is already exist in database, do some necessary checking
2217                     // and add a usage instance into this token in database
2218                     //
2219                     token = dbManager.getTokenByKey(primaryKey);
2220
2221                     //
2222                     // checking for DatumType, DatumType should be unique for one PCD used in different
2223                     // modules.
2224                     //
2225                     if (token.datumType != datumType) {
2226                         exceptionString = String.format("[FPD file error] The datum type of PCD entry %s is %s, which is different with  %s defined in before!",
2227                                                         pcdBuildData.getCName(),
2228                                                         pcdBuildData.getDatumType().toString(),
2229                                                         Token.getStringOfdatumType(token.datumType));
2230                         throw new EntityException(exceptionString);
2231                     }
2232
2233                     //
2234                     // Check token number is valid
2235                     //
2236                     if (tokenNumber != token.tokenNumber) {
2237                         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!",
2238                                                         pcdBuildData.getCName(),
2239                                                         moduleName);
2240                         throw new EntityException(exceptionString);
2241                     }
2242
2243                     //
2244                     // For same PCD used in different modules, the PCD type should all be dynamic or non-dynamic.
2245                     //
2246                     if (token.isDynamicPCD != Token.isDynamic(pcdType)) {
2247                         exceptionString = String.format("[FPD file error] For PCD entry %s in module %s, you define dynamic or non-dynamic PCD type which"+
2248                                                         "is different with others module's",
2249                                                         token.cName,
2250                                                         moduleName);
2251                         throw new EntityException(exceptionString);
2252                     }
2253
2254                     if (token.isDynamicPCD) {
2255                         //
2256                         // Check datum is equal the datum in dynamic information.
2257                         // For dynamic PCD, you can do not write <Value> in sperated every <PcdBuildDefinition> in different <ModuleSA>,
2258                         // But if you write, the <Value> must be same as the value in <DynamicPcdBuildDefinitions>.
2259                         //
2260                         if (!token.isSkuEnable() &&
2261                             (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.DEFAULT_TYPE) &&
2262                             (datum != null)) {
2263                             if (!datum.equalsIgnoreCase(token.getDefaultSku().value)) {
2264                                 exceptionString = String.format("[FPD file error] For dynamic PCD %s in module %s, the datum in <ModuleSA> is "+
2265                                                                 "not equal to the datum in <DynamicPcdBuildDefinitions>, it is "+
2266                                                                 "illega! You could no set <Value> in <ModuleSA> for a dynamic PCD!",
2267                                                                 token.cName,
2268                                                                 moduleName);
2269                                 throw new EntityException(exceptionString);
2270                             }
2271                         }
2272
2273                         if ((maxDatumSize != 0) &&
2274                             (maxDatumSize != token.datumSize)){
2275                             exceptionString = String.format("[FPD file error] For dynamic PCD %s in module %s, the max datum size is %d which "+
2276                                                             "is different with <MaxDatumSize> %d defined in <DynamicPcdBuildDefinitions>!",
2277                                                             token.cName,
2278                                                             moduleName,
2279                                                             maxDatumSize,
2280                                                             token.datumSize);
2281                             throw new EntityException(exceptionString);
2282                         }
2283                     }
2284
2285                 } else {
2286                     //
2287                     // If the token is not in database, create a new token instance and add
2288                     // a usage instance into this token in database.
2289                     //
2290                     try {
2291                         tokenSpaceStrRet = GlobalData.getGuidInfoFromCname(pcdBuildData.getTokenSpaceGuidCName());
2292                     } catch (Exception e) {
2293                         throw new EntityException("Fail to get token space guid for token " + token.cName);
2294                     }
2295
2296                     if (tokenSpaceStrRet == null) {
2297                         throw new EntityException("Fail to get token space guid for token " + token.cName);
2298                     }
2299
2300                     token = new Token(pcdBuildData.getCName(),
2301                                       translateSchemaStringToUUID(tokenSpaceStrRet[1]));
2302
2303                     token.datumType     = datumType;
2304                     token.tokenNumber   = tokenNumber;
2305                     token.isDynamicPCD  = Token.isDynamic(pcdType);
2306                     token.datumSize     = maxDatumSize;
2307
2308                     if (token.isDynamicPCD) {
2309                         //
2310                         // For Dynamic and Dynamic Ex type, need find the dynamic information
2311                         // in <DynamicPcdBuildDefinition> section in FPD file.
2312                         //
2313                         updateDynamicInformation(moduleName,
2314                                                  token,
2315                                                  datum,
2316                                                  maxDatumSize);
2317                     }
2318
2319                     dbManager.addTokenToDatabase(primaryKey, token);
2320                 }
2321
2322                 //
2323                 // -----------------------------------------------------------------------------------
2324                 // 2.1.3), Add the PcdType in current module into this Pcd token's supported PCD type.
2325                 // -----------------------------------------------------------------------------------
2326                 //
2327                 token.updateSupportPcdType(pcdType);
2328
2329                 //
2330                 // ------------------------------------------------
2331                 // 2.1.4), Create an usage instance for this token.
2332                 // ------------------------------------------------
2333                 //
2334                 usageInstance = new UsageInstance(token,
2335                                                   moduleName,
2336                                                   null,
2337                                                   null,
2338                                                   null,
2339                                                   CommonDefinition.getModuleType(modules.get(index).getModuleType()),
2340                                                   pcdType,
2341                                                   modules.get(index).getModuleId().getArch(),
2342                                                   null,
2343                                                   datum,
2344                                                   maxDatumSize);
2345                 token.addUsageInstance(usageInstance);
2346             }
2347         }
2348     }
2349
2350     /**
2351        Verify the datum value according its datum size and datum type, this
2352        function maybe moved to FPD verification tools in future.
2353
2354        @param cName
2355        @param moduleName
2356        @param datum
2357        @param datumType
2358        @param maxDatumSize
2359
2360        @return String
2361      */
2362     /***/
2363     public String verifyDatum(String            cName,
2364                               String            moduleName,
2365                               String            datum,
2366                               Token.DATUM_TYPE  datumType,
2367                               int               maxDatumSize) {
2368         String      exceptionString = null;
2369         int         value;
2370         BigInteger  value64;
2371         String      subStr;
2372         int         index;
2373
2374         if (moduleName == null) {
2375             moduleName = "section <DynamicPcdBuildDefinitions>";
2376         } else {
2377             moduleName = "module " + moduleName;
2378         }
2379
2380         if (maxDatumSize == 0) {
2381             exceptionString = String.format("[FPD file error] You maybe miss <MaxDatumSize> for PCD %s in %s",
2382                                             cName,
2383                                             moduleName);
2384             return exceptionString;
2385         }
2386
2387         switch (datumType) {
2388         case UINT8:
2389             if (maxDatumSize != 1) {
2390                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
2391                                                 "is UINT8, but datum size is %d, they are not matched!",
2392                                                  cName,
2393                                                  moduleName,
2394                                                  maxDatumSize);
2395                 return exceptionString;
2396             }
2397
2398             if (datum != null) {
2399                 try {
2400                     value = Integer.decode(datum);
2401                 } catch (NumberFormatException nfeExp) {
2402                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not valid "+
2403                                                     "digital format of UINT8",
2404                                                     cName,
2405                                                     moduleName);
2406                     return exceptionString;
2407                 }
2408                 if (value > 0xFF) {
2409                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s exceed"+
2410                                                     " the max size of UINT8 - 0xFF",
2411                                                     cName,
2412                                                     moduleName,
2413                                                     datum);
2414                     return exceptionString;
2415                 }
2416             }
2417             break;
2418         case UINT16:
2419             if (maxDatumSize != 2) {
2420                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
2421                                                 "is UINT16, but datum size is %d, they are not matched!",
2422                                                  cName,
2423                                                  moduleName,
2424                                                  maxDatumSize);
2425                 return exceptionString;
2426             }
2427             if (datum != null) {
2428                 try {
2429                     value = Integer.decode(datum);
2430                 } catch (NumberFormatException nfeExp) {
2431                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is "+
2432                                                     "not valid digital of UINT16",
2433                                                     cName,
2434                                                     moduleName);
2435                     return exceptionString;
2436                 }
2437                 if (value > 0xFFFF) {
2438                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s "+
2439                                                     "which exceed the range of UINT16 - 0xFFFF",
2440                                                     cName,
2441                                                     moduleName,
2442                                                     datum);
2443                     return exceptionString;
2444                 }
2445             }
2446             break;
2447         case UINT32:
2448             if (maxDatumSize != 4) {
2449                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
2450                                                 "is UINT32, but datum size is %d, they are not matched!",
2451                                                  cName,
2452                                                  moduleName,
2453                                                  maxDatumSize);
2454                 return exceptionString;
2455             }
2456
2457             if (datum != null) {
2458                 try {
2459                     if (datum.length() > 2) {
2460                         if ((datum.charAt(0) == '0')        &&
2461                             ((datum.charAt(1) == 'x') || (datum.charAt(1) == 'X'))){
2462                             subStr = datum.substring(2, datum.length());
2463                             value64 = new BigInteger(subStr, 16);
2464                         } else {
2465                             value64 = new BigInteger(datum);
2466                         }
2467                     } else {
2468                         value64 = new BigInteger(datum);
2469                     }
2470                 } catch (NumberFormatException nfeExp) {
2471                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not "+
2472                                                     "valid digital of UINT32",
2473                                                     cName,
2474                                                     moduleName);
2475                     return exceptionString;
2476                 }
2477
2478                 if (value64.bitLength() > 32) {
2479                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s which "+
2480                                                     "exceed the range of UINT32 - 0xFFFFFFFF",
2481                                                     cName,
2482                                                     moduleName,
2483                                                     datum);
2484                     return exceptionString;
2485                 }
2486             }
2487             break;
2488         case UINT64:
2489             if (maxDatumSize != 8) {
2490                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
2491                                                 "is UINT64, but datum size is %d, they are not matched!",
2492                                                  cName,
2493                                                  moduleName,
2494                                                  maxDatumSize);
2495                 return exceptionString;
2496             }
2497
2498             if (datum != null) {
2499                 try {
2500                     if (datum.length() > 2) {
2501                         if ((datum.charAt(0) == '0')        &&
2502                             ((datum.charAt(1) == 'x') || (datum.charAt(1) == 'X'))){
2503                             subStr = datum.substring(2, datum.length());
2504                             value64 = new BigInteger(subStr, 16);
2505                         } else {
2506                             value64 = new BigInteger(datum);
2507                         }
2508                     } else {
2509                         value64 = new BigInteger(datum);
2510                     }
2511                 } catch (NumberFormatException nfeExp) {
2512                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not valid"+
2513                                                     " digital of UINT64",
2514                                                     cName,
2515                                                     moduleName);
2516                     return exceptionString;
2517                 }
2518
2519                 if (value64.bitLength() > 64) {
2520                     exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s "+
2521                                                     "exceed the range of UINT64 - 0xFFFFFFFFFFFFFFFF",
2522                                                     cName,
2523                                                     moduleName,
2524                                                     datum);
2525                     return exceptionString;
2526                 }
2527             }
2528             break;
2529         case BOOLEAN:
2530             if (maxDatumSize != 1) {
2531                 exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
2532                                                 "is BOOLEAN, but datum size is %d, they are not matched!",
2533                                                  cName,
2534                                                  moduleName,
2535                                                  maxDatumSize);
2536                 return exceptionString;
2537             }
2538
2539             if (datum != null) {
2540                 if (!(datum.equalsIgnoreCase("TRUE") ||
2541                      datum.equalsIgnoreCase("FALSE"))) {
2542                     exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+
2543                                                     "is BOOELAN, but value is not 'true'/'TRUE' or 'FALSE'/'false'",
2544                                                     cName,
2545                                                     moduleName);
2546                     return exceptionString;
2547                 }
2548
2549             }
2550             break;
2551         case POINTER:
2552             if (datum == null) {
2553                 break;
2554             }
2555
2556             char    ch     = datum.charAt(0);
2557             int     start, end;
2558             String  strValue;
2559             //
2560             // For void* type PCD, only three datum is support:
2561             // 1) Unicode: string with start char is "L"
2562             // 2) Ansci: String start char is ""
2563             // 3) byte array: String start char "{"
2564             //
2565             if (ch == 'L') {
2566                 start       = datum.indexOf('\"');
2567                 end         = datum.lastIndexOf('\"');
2568                 if ((start > end)           ||
2569                     (end   > datum.length())||
2570                     ((start == end) && (datum.length() > 0))) {
2571                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID* and datum is "+
2572                                                     "a UNICODE string because start with L\", but format maybe"+
2573                                                     "is not right, correct UNICODE string is L\"...\"!",
2574                                                     cName,
2575                                                     moduleName);
2576                     return exceptionString;
2577                 }
2578
2579                 strValue    = datum.substring(start + 1, end);
2580                 if ((strValue.length() * 2) > maxDatumSize) {
2581                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is "+
2582                                                     "a UNICODE string, but the datum size is %d exceed to <MaxDatumSize> : %d",
2583                                                     cName,
2584                                                     moduleName,
2585                                                     strValue.length() * 2,
2586                                                     maxDatumSize);
2587                     return exceptionString;
2588                 }
2589             } else if (ch == '\"'){
2590                 start       = datum.indexOf('\"');
2591                 end         = datum.lastIndexOf('\"');
2592                 if ((start > end)           ||
2593                     (end   > datum.length())||
2594                     ((start == end) && (datum.length() > 0))) {
2595                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID* and datum is "+
2596                                                     "a ANSCII string because start with \", but format maybe"+
2597                                                     "is not right, correct ANSIC string is \"...\"!",
2598                                                     cName,
2599                                                     moduleName);
2600                     return exceptionString;
2601                 }
2602                 strValue    = datum.substring(start + 1, end);
2603                 if ((strValue.length()) > maxDatumSize) {
2604                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is "+
2605                                                     "a ANSCI string, but the datum size is %d which exceed to <MaxDatumSize> : %d",
2606                                                     cName,
2607                                                     moduleName,
2608                                                     strValue.length(),
2609                                                     maxDatumSize);
2610                     return exceptionString;
2611                 }
2612             } else if (ch =='{') {
2613                 String[]  strValueArray;
2614
2615                 start           = datum.indexOf('{');
2616                 end             = datum.lastIndexOf('}');
2617                 strValue        = datum.substring(start + 1, end);
2618                 strValue        = strValue.trim();
2619                 if (strValue.length() == 0) {
2620                     break;
2621                 }
2622                 strValueArray   = strValue.split(",");
2623                 for (index = 0; index < strValueArray.length; index ++) {
2624                     try{
2625                         value = Integer.decode(strValueArray[index].trim());
2626                     } catch (NumberFormatException nfeEx) {
2627                         exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and "+
2628                                                          "it is byte array in fact. For every byte in array should be a valid"+
2629                                                          "byte digital, but element %s is not a valid byte digital!",
2630                                                          cName,
2631                                                          moduleName,
2632                                                          strValueArray[index]);
2633                         return exceptionString;
2634                     }
2635                     if (value > 0xFF) {
2636                         exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, "+
2637                                                         "it is byte array in fact. But the element of %s exceed the byte range",
2638                                                         cName,
2639                                                         moduleName,
2640                                                         strValueArray[index]);
2641                         return exceptionString;
2642                     }
2643                 }
2644
2645                 if (strValueArray.length > maxDatumSize) {
2646                     exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is byte"+
2647                                                     "array, but the number of bytes is %d which exceed to <MaxDatumSzie> : %d!",
2648                                                     cName,
2649                                                     moduleName,
2650                                                     strValueArray.length,
2651                                                     maxDatumSize);
2652                     return exceptionString;
2653                 }
2654             } else {
2655                 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 "+
2656                                                 "1) UNICODE string: like L\"xxxx\";\r\n"+
2657                                                 "2) ANSIC string: like \"xxx\";\r\n"+
2658                                                 "3) Byte array: like {0x2, 0x45, 0x23}\r\n"+
2659                                                 "But the datum in seems does not following above format!",
2660                                                 cName,
2661                                                 moduleName);
2662                 return exceptionString;
2663             }
2664             break;
2665         default:
2666             exceptionString = String.format("[FPD file error] For PCD entry %s in %s, datum type is unknown, it should be one of "+
2667                                             "UINT8, UINT16, UINT32, UINT64, VOID*, BOOLEAN",
2668                                             cName,
2669                                             moduleName);
2670             return exceptionString;
2671         }
2672         return null;
2673     }
2674
2675     /**
2676        Get dynamic information for a dynamic PCD from <DynamicPcdBuildDefinition> seciton in FPD file.
2677
2678        This function should be implemented in GlobalData in future.
2679
2680        @param token         The token instance which has hold module's PCD information
2681        @param moduleName    The name of module who will use this Dynamic PCD.
2682
2683        @return DynamicPcdBuildDefinitions.PcdBuildData
2684      */
2685     /***/
2686     private DynamicPcdBuildDefinitions.PcdBuildData getDynamicInfoFromFPD(Token     token,
2687                                                                           String    moduleName)
2688         throws EntityException {
2689         int    index             = 0;
2690         String exceptionString   = null;
2691         String dynamicPrimaryKey = null;
2692         DynamicPcdBuildDefinitions                    dynamicPcdBuildDefinitions = null;
2693         List<DynamicPcdBuildDefinitions.PcdBuildData> dynamicPcdBuildDataArray   = null;
2694         String[]                                      tokenSpaceStrRet           = null;
2695
2696         //
2697         // If FPD document is not be opened, open and initialize it.
2698         //
2699         if (fpdDocInstance == null) {
2700             try {
2701                 fpdDocInstance = (PlatformSurfaceAreaDocument)XmlObject.Factory.parse(new File(fpdFilePath));
2702             } catch(IOException ioE) {
2703                 throw new EntityException("File IO error for xml file:" + fpdFilePath + "\n" + ioE.getMessage());
2704             } catch(XmlException xmlE) {
2705                 throw new EntityException("Can't parse the FPD xml fle:" + fpdFilePath + "\n" + xmlE.getMessage());
2706             }
2707         }
2708
2709         dynamicPcdBuildDefinitions = fpdDocInstance.getPlatformSurfaceArea().getDynamicPcdBuildDefinitions();
2710         if (dynamicPcdBuildDefinitions == null) {
2711             exceptionString = String.format("[FPD file error] There are no <PcdDynamicBuildDescriptions> in FPD file but contains Dynamic type "+
2712                                             "PCD entry %s in module %s!",
2713                                             token.cName,
2714                                             moduleName);
2715             throw new EntityException(exceptionString);
2716         }
2717
2718         dynamicPcdBuildDataArray = dynamicPcdBuildDefinitions.getPcdBuildDataList();
2719         for (index = 0; index < dynamicPcdBuildDataArray.size(); index ++) {
2720             //String tokenSpaceGuidString = GlobalData.getGuidInfoFromCname(dynamicPcdBuildDataArray.get(index).getTokenSpaceGuidCName())[1];
2721             String tokenSpaceGuidString = null;
2722             try {
2723                 tokenSpaceStrRet = GlobalData.getGuidInfoFromCname(dynamicPcdBuildDataArray.get(index).getTokenSpaceGuidCName());
2724             } catch (Exception e) {
2725                 throw new EntityException ("Fail to get token space guid for token " + dynamicPcdBuildDataArray.get(index).getCName());
2726             }
2727
2728             if (tokenSpaceStrRet == null) {
2729                 throw new EntityException ("Fail to get token space guid for token " + dynamicPcdBuildDataArray.get(index).getCName());
2730             }
2731
2732             dynamicPrimaryKey = Token.getPrimaryKeyString(dynamicPcdBuildDataArray.get(index).getCName(),
2733                                                           translateSchemaStringToUUID(tokenSpaceStrRet[1]));
2734             if (dynamicPrimaryKey.equalsIgnoreCase(token.getPrimaryKeyString())) {
2735                 return dynamicPcdBuildDataArray.get(index);
2736             }
2737         }
2738
2739         return null;
2740     }
2741
2742     /**
2743        Update dynamic information for PCD entry.
2744
2745        Dynamic information is retrieved from <PcdDynamicBuildDeclarations> in
2746        FPD file.
2747
2748        @param moduleName        The name of the module who use this PCD
2749        @param token             The token instance
2750        @param datum             The <datum> in module's PCD information
2751        @param maxDatumSize      The <maxDatumSize> in module's PCD information
2752
2753        @return Token
2754      */
2755     private Token updateDynamicInformation(String   moduleName,
2756                                            Token    token,
2757                                            String   datum,
2758                                            int      maxDatumSize)
2759         throws EntityException {
2760         int                 index           = 0;
2761         int                 offset;
2762         String              exceptionString = null;
2763         DynamicTokenValue   dynamicValue;
2764         SkuInstance         skuInstance     = null;
2765         String              temp;
2766         boolean             hasSkuId0       = false;
2767         Token.PCD_TYPE      pcdType         = Token.PCD_TYPE.UNKNOWN;
2768         long                tokenNumber     = 0;
2769         String              hiiDefaultValue = null;
2770         String[]            variableGuidString = null;
2771
2772         List<DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo>   skuInfoList = null;
2773         DynamicPcdBuildDefinitions.PcdBuildData                 dynamicInfo = null;
2774
2775         dynamicInfo = getDynamicInfoFromFPD(token, moduleName);
2776         if (dynamicInfo == null) {
2777             exceptionString = String.format("[FPD file error] For Dynamic PCD %s used by module %s, "+
2778                                             "there is no dynamic information in <DynamicPcdBuildDefinitions> "+
2779                                             "in FPD file, but it is required!",
2780                                             token.cName,
2781                                             moduleName);
2782             throw new EntityException(exceptionString);
2783         }
2784
2785         token.datumSize = dynamicInfo.getMaxDatumSize();
2786
2787         exceptionString = verifyDatum(token.cName,
2788                                       moduleName,
2789                                       null,
2790                                       token.datumType,
2791                                       token.datumSize);
2792         if (exceptionString != null) {
2793             throw new EntityException(exceptionString);
2794         }
2795
2796         if ((maxDatumSize != 0) &&
2797             (maxDatumSize != token.datumSize)) {
2798             exceptionString = String.format("FPD file error] For dynamic PCD %s, the datum size in module %s is %d, but "+
2799                                             "the datum size in <DynamicPcdBuildDefinitions> is %d, they are not match!",
2800                                             token.cName,
2801                                             moduleName,
2802                                             maxDatumSize,
2803                                             dynamicInfo.getMaxDatumSize());
2804             throw new EntityException(exceptionString);
2805         }
2806         tokenNumber = Long.decode(dynamicInfo.getToken().toString());
2807         if (tokenNumber != token.tokenNumber) {
2808             exceptionString = String.format("[FPD file error] For dynamic PCD %s, the token number in module %s is 0x%x, but"+
2809                                             "in <DynamicPcdBuildDefinictions>, the token number is 0x%x, they are not match!",
2810                                             token.cName,
2811                                             moduleName,
2812                                             token.tokenNumber,
2813                                             tokenNumber);
2814             throw new EntityException(exceptionString);
2815         }
2816
2817         pcdType = Token.getpcdTypeFromString(dynamicInfo.getItemType().toString());
2818         if (pcdType == Token.PCD_TYPE.DYNAMIC_EX) {
2819             token.dynamicExTokenNumber = tokenNumber;
2820         }
2821
2822         skuInfoList = dynamicInfo.getSkuInfoList();
2823
2824         //
2825         // Loop all sku data
2826         //
2827         for (index = 0; index < skuInfoList.size(); index ++) {
2828             skuInstance = new SkuInstance();
2829             //
2830             // Although SkuId in schema is BigInteger, but in fact, sku id is 32 bit value.
2831             //
2832             temp = skuInfoList.get(index).getSkuId().toString();
2833             skuInstance.id = Integer.decode(temp);
2834             if (skuInstance.id == 0) {
2835                 hasSkuId0 = true;
2836             }
2837             //
2838             // Judge whether is DefaultGroup at first, because most case is DefautlGroup.
2839             //
2840             if (skuInfoList.get(index).getValue() != null) {
2841                 skuInstance.value.setValue(skuInfoList.get(index).getValue().toString());
2842                 if ((exceptionString = verifyDatum(token.cName,
2843                                                    null,
2844                                                    skuInfoList.get(index).getValue().toString(),
2845                                                    token.datumType,
2846                                                    token.datumSize)) != null) {
2847                     throw new EntityException(exceptionString);
2848                 }
2849
2850                 token.skuData.add(skuInstance);
2851
2852                 //
2853                 // Judege wether is same of datum between module's information
2854                 // and dynamic information.
2855                 //
2856                 if (datum != null) {
2857                     if ((skuInstance.id == 0)                                   &&
2858                         !datum.toString().equalsIgnoreCase(skuInfoList.get(index).getValue().toString())) {
2859                         exceptionString = "[FPD file error] For dynamic PCD " + token.cName + ", the value in module " + moduleName + " is " + datum.toString() + " but the "+
2860                                           "value of sku 0 data in <DynamicPcdBuildDefinition> is " + skuInstance.value.value + ". They are must be same!"+
2861                                           " or you could not define value for a dynamic PCD in every <ModuleSA>!";
2862                         throw new EntityException(exceptionString);
2863                     }
2864                 }
2865                 continue;
2866             }
2867
2868             //
2869             // Judge whether is HII group case.
2870             //
2871             if (skuInfoList.get(index).getVariableName() != null) {
2872                 exceptionString = null;
2873                 if (skuInfoList.get(index).getVariableGuid() == null) {
2874                     exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+
2875                                                     "file, who use HII, but there is no <VariableGuid> defined for Sku %d data!",
2876                                                     token.cName,
2877                                                     index);
2878                     if (exceptionString != null) {
2879                         throw new EntityException(exceptionString);
2880                     }
2881                 }
2882
2883                 if (skuInfoList.get(index).getVariableOffset() == null) {
2884                     exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+
2885                                                     "file, who use HII, but there is no <VariableOffset> defined for Sku %d data!",
2886                                                     token.cName,
2887                                                     index);
2888                     if (exceptionString != null) {
2889                         throw new EntityException(exceptionString);
2890                     }
2891                 }
2892
2893                 if (skuInfoList.get(index).getHiiDefaultValue() == null) {
2894                     exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+
2895                                                     "file, who use HII, but there is no <HiiDefaultValue> defined for Sku %d data!",
2896                                                     token.cName,
2897                                                     index);
2898                     if (exceptionString != null) {
2899                         throw new EntityException(exceptionString);
2900                     }
2901                 }
2902
2903                 if (skuInfoList.get(index).getHiiDefaultValue() != null) {
2904                     hiiDefaultValue = skuInfoList.get(index).getHiiDefaultValue().toString();
2905                 } else {
2906                     hiiDefaultValue = null;
2907                 }
2908
2909                 if ((exceptionString = verifyDatum(token.cName,
2910                                                    null,
2911                                                    hiiDefaultValue,
2912                                                    token.datumType,
2913                                                    token.datumSize)) != null) {
2914                     throw new EntityException(exceptionString);
2915                 }
2916
2917                 offset = Integer.decode(skuInfoList.get(index).getVariableOffset());
2918                 if (offset > 0xFFFF) {
2919                     throw new EntityException(String.format("[FPD file error] For dynamic PCD %s ,  the variable offset defined in sku %d data "+
2920                                                             "exceed 64K, it is not allowed!",
2921                                                             token.cName,
2922                                                             index));
2923                 }
2924
2925                 //
2926                 // Get variable guid string according to the name of guid which will be mapped into a GUID in SPD file.
2927                 //
2928                 variableGuidString = GlobalData.getGuidInfoFromCname(skuInfoList.get(index).getVariableGuid().toString());
2929                 if (variableGuidString == null) {
2930                     throw new EntityException(String.format("[GUID Error] For dynamic PCD %s,  the variable guid %s can be found in all SPD file!",
2931                                                             token.cName,
2932                                                             skuInfoList.get(index).getVariableGuid().toString()));
2933                 }
2934                 String variableStr = skuInfoList.get(index).getVariableName();
2935                 Pattern pattern = Pattern.compile("0x([a-fA-F0-9]){4}");
2936                 Matcher matcher = pattern.matcher(variableStr);
2937                 List<String> varNameList = new ArrayList<String>();
2938                 while (matcher.find()){
2939                         String str = variableStr.substring(matcher.start(),matcher.end());
2940                         varNameList.add(str);
2941                 }
2942
2943                 skuInstance.value.setHiiData(varNameList,
2944                                              translateSchemaStringToUUID(variableGuidString[1]),
2945                                              skuInfoList.get(index).getVariableOffset(),
2946                                              skuInfoList.get(index).getHiiDefaultValue().toString());
2947                 token.skuData.add(skuInstance);
2948                 continue;
2949             }
2950
2951             if (skuInfoList.get(index).getVpdOffset() != null) {
2952                 skuInstance.value.setVpdData(skuInfoList.get(index).getVpdOffset());
2953                 token.skuData.add(skuInstance);
2954                 continue;
2955             }
2956
2957             exceptionString = String.format("[FPD file error] For dynamic PCD %s, the dynamic info must "+
2958                                             "be one of 'DefaultGroup', 'HIIGroup', 'VpdGroup'.",
2959                                             token.cName);
2960             throw new EntityException(exceptionString);
2961         }
2962
2963         if (!hasSkuId0) {
2964             exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions>, there are "+
2965                                             "no sku id = 0 data, which is required for every dynamic PCD",
2966                                             token.cName);
2967             throw new EntityException(exceptionString);
2968         }
2969
2970         return token;
2971     }
2972
2973     /**
2974        Translate the schema string to UUID instance.
2975
2976        In schema, the string of UUID is defined as following two types string:
2977         1) GuidArrayType: pattern = 0x[a-fA-F0-9]{1,8},( )*0x[a-fA-F0-9]{1,4},(
2978         )*0x[a-fA-F0-9]{1,4}(,( )*\{)?(,?( )*0x[a-fA-F0-9]{1,2}){8}( )*(\})?
2979
2980         2) GuidNamingConvention: pattern =
2981         [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}
2982
2983        This function will convert string and create uuid instance.
2984
2985        @param uuidString    UUID string in XML file
2986
2987        @return UUID         UUID instance
2988     **/
2989     private UUID translateSchemaStringToUUID(String uuidString)
2990         throws EntityException {
2991         String      temp;
2992         String[]    splitStringArray;
2993         int         index;
2994         int         chIndex;
2995         int         chLen;
2996
2997         if (uuidString == null) {
2998             return null;
2999         }
3000
3001         if (uuidString.length() == 0) {
3002             return null;
3003         }
3004
3005         if (uuidString.equals("0") ||
3006             uuidString.equalsIgnoreCase("0x0")) {
3007             return new UUID(0, 0);
3008         }
3009
3010         uuidString = uuidString.replaceAll("\\{", "");
3011         uuidString = uuidString.replaceAll("\\}", "");
3012
3013         //
3014         // If the UUID schema string is GuidArrayType type then need translate
3015         // to GuidNamingConvention type at first.
3016         //
3017         if ((uuidString.charAt(0) == '0') && ((uuidString.charAt(1) == 'x') || (uuidString.charAt(1) == 'X'))) {
3018             splitStringArray = uuidString.split("," );
3019             if (splitStringArray.length != 11) {
3020                 throw new EntityException ("[FPD file error] Wrong format for UUID string: " + uuidString);
3021             }
3022
3023             //
3024             // Remove blank space from these string and remove header string "0x"
3025             //
3026             for (index = 0; index < 11; index ++) {
3027                 splitStringArray[index] = splitStringArray[index].trim();
3028                 splitStringArray[index] = splitStringArray[index].substring(2, splitStringArray[index].length());
3029             }
3030
3031             //
3032             // Add heading '0' to normalize the string length
3033             //
3034             for (index = 3; index < 11; index ++) {
3035                 chLen = splitStringArray[index].length();
3036                 for (chIndex = 0; chIndex < 2 - chLen; chIndex ++) {
3037                     splitStringArray[index] = "0" + splitStringArray[index];
3038                 }
3039             }
3040
3041             //
3042             // construct the final GuidNamingConvention string
3043             //
3044             temp = String.format("%s-%s-%s-%s%s-%s%s%s%s%s%s",
3045                                  splitStringArray[0],
3046                                  splitStringArray[1],
3047                                  splitStringArray[2],
3048                                  splitStringArray[3],
3049                                  splitStringArray[4],
3050                                  splitStringArray[5],
3051                                  splitStringArray[6],
3052                                  splitStringArray[7],
3053                                  splitStringArray[8],
3054                                  splitStringArray[9],
3055                                  splitStringArray[10]);
3056             uuidString = temp;
3057         }
3058
3059         return UUID.fromString(uuidString);
3060     }
3061
3062     /**
3063       check parameter for this action.
3064
3065       @throws EntityException  Bad parameter.
3066     **/
3067     private void checkParameter() throws EntityException {
3068         File file = null;
3069
3070         if((fpdFilePath    == null) ||(workspacePath  == null)) {
3071             throw new EntityException("WorkspacePath and FPDFileName should be blank for CollectPCDAtion!");
3072         }
3073
3074         if(fpdFilePath.length() == 0 || workspacePath.length() == 0) {
3075             throw new EntityException("WorkspacePath and FPDFileName should be blank for CollectPCDAtion!");
3076         }
3077
3078         file = new File(workspacePath);
3079         if(!file.exists()) {
3080             throw new EntityException("WorkpacePath " + workspacePath + " does not exist!");
3081         }
3082
3083         file = new File(fpdFilePath);
3084
3085         if(!file.exists()) {
3086             throw new EntityException("FPD File " + fpdFilePath + " does not exist!");
3087         }
3088     }
3089
3090     /**
3091       Test case function
3092
3093       @param argv  parameter from command line
3094     **/
3095     public static void main(String argv[]) throws EntityException {
3096         CollectPCDAction ca = new CollectPCDAction();
3097         ca.setWorkspacePath("m:/tianocore/edk2");
3098         ca.setFPDFilePath("m:/tianocore/edk2/EdkNt32Pkg/Nt32.fpd");
3099         ca.setActionMessageLevel(ActionMessage.MAX_MESSAGE_LEVEL);
3100 //        GlobalData.initInfo("Tools" + File.separator + "Conf" + File.separator + "FrameworkDatabase.db",
3101 //                            "m:/tianocore/edk2");
3102 //        ca.execute();
3103     }
3104 }