Tools/Source/FrameworkWizard/src/org/tianocore/frameworkwizard/platform/ui/FpdFileContents.java

   1 /** @file
   2   Java class FpdFileContents is used to parse fpd xml file.
   3
   4 Copyright (c) 2006, Intel Corporation
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12 **/
  13 package org.tianocore.frameworkwizard.platform.ui;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.math.BigInteger;
  18 import java.util.ArrayList;
  19 import java.util.HashMap;
  20 import java.util.Iterator;
  21 import java.util.LinkedHashMap;
  22 import java.util.List;
  23 import java.util.ListIterator;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.Vector;
  27
  28 import javax.xml.namespace.QName;
  29
  30 import org.apache.xmlbeans.XmlCursor;
  31 import org.apache.xmlbeans.XmlObject;
  32 import org.apache.xmlbeans.XmlOptions;
  33 import org.tianocore.AntTaskDocument;
  34 import org.tianocore.BuildOptionsDocument;
  35 import org.tianocore.DynamicPcdBuildDefinitionsDocument;
  36 import org.tianocore.EfiSectionType;
  37 import org.tianocore.FlashDefinitionFileDocument;
  38 import org.tianocore.FlashDocument;
  39 import org.tianocore.FrameworkModulesDocument;
  40 import org.tianocore.IntermediateOutputType;
  41 import org.tianocore.LibrariesDocument;
  42 import org.tianocore.ModuleSADocument;
  43 import org.tianocore.ModuleSaBuildOptionsDocument;
  44 import org.tianocore.ModuleSurfaceAreaDocument;
  45 import org.tianocore.OptionDocument;
  46 import org.tianocore.OptionsDocument;
  47 import org.tianocore.PcdBuildDefinitionDocument;
  48 import org.tianocore.PcdCodedDocument;
  49 import org.tianocore.PcdDataTypes;
  50 import org.tianocore.PcdDeclarationsDocument;
  51 import org.tianocore.PcdItemTypes;
  52 import org.tianocore.PlatformDefinitionsDocument;
  53 import org.tianocore.PlatformSurfaceAreaDocument;
  54 import org.tianocore.FvImageTypes;
  55 import org.tianocore.FvImagesDocument;
  56 import org.tianocore.LicenseDocument;
  57 import org.tianocore.PlatformHeaderDocument;
  58 import org.tianocore.SkuInfoDocument;
  59 import org.tianocore.UserDefinedAntTasksDocument;
  60 import org.tianocore.UserExtensionsDocument;
  61 import org.tianocore.frameworkwizard.platform.ui.global.WorkspaceProfile;
  62 import org.tianocore.frameworkwizard.platform.ui.global.SurfaceAreaQuery;
  63 import org.tianocore.frameworkwizard.module.Identifications.ModuleIdentification;
  64 import org.tianocore.frameworkwizard.packaging.PackageIdentification;
  65
  66 /**
  67  This class processes fpd file contents such as add remove xml elements.
  68  @since PackageEditor 1.0
  69 **/
  70 public class FpdFileContents {
  71
  72     static final String xmlNs = "http://www.TianoCore.org/2006/Edk2.0";
  73     static final String regExpNewLineAndSpaces = "((\n)|(\r\n)|(\r)|(\u0085)|(\u2028)|(\u2029))(\\s)*";
  74
  75     private PlatformSurfaceAreaDocument fpdd = null;
  76
  77     private PlatformSurfaceAreaDocument.PlatformSurfaceArea fpdRoot = null;
  78
  79     private PlatformHeaderDocument.PlatformHeader fpdHdr = null;
  80
  81     private PlatformDefinitionsDocument.PlatformDefinitions fpdPlatformDefs = null;
  82
  83     private FlashDocument.Flash fpdFlash = null;
  84
  85     private BuildOptionsDocument.BuildOptions fpdBuildOpts = null;
  86
  87     private FrameworkModulesDocument.FrameworkModules fpdFrameworkModules = null;
  88
  89     private DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions fpdDynPcdBuildDefs = null;
  90
  91     private HashMap<String, ArrayList<String>> dynPcdMap = null;
  92
  93     private HashMap<String, String> defaultPcdValue = new HashMap<String, String>();
  94
  95     private String itemType (String pcdInfo) {
  96
  97         return pcdInfo.substring(pcdInfo.lastIndexOf(" ") + 1);
  98     }
  99
 100     /**
 101      * look through all pcd data in all ModuleSA, create pcd -> ModuleSA mappings.
 102      */
 103     public void initDynPcdMap() {
 104       if (dynPcdMap == null) {
 105           dynPcdMap = new HashMap<String, ArrayList<String>>();
 106           List<ModuleSADocument.ModuleSA> l = getfpdFrameworkModules().getModuleSAList();
 107           if (l == null) {
 108               removeElement(getfpdFrameworkModules());
 109               fpdFrameworkModules = null;
 110               return;
 111           }
 112           ListIterator<ModuleSADocument.ModuleSA> li = l.listIterator();
 113           while (li.hasNext()) {
 114               ModuleSADocument.ModuleSA moduleSa = li.next();
 115               if (moduleSa.getPcdBuildDefinition() == null || moduleSa.getPcdBuildDefinition().getPcdDataList() == null) {
 116                   continue;
 117               }
 118               String ModuleInfo = moduleSa.getModuleGuid() + " " + moduleSa.getModuleVersion() +
 119                " " + moduleSa.getPackageGuid() + " " + moduleSa.getPackageVersion() + " " + listToString(moduleSa.getSupArchList());
 120               List<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData> lp = moduleSa.getPcdBuildDefinition().getPcdDataList();
 121               ListIterator<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData> lpi = lp.listIterator();
 122               while (lpi.hasNext()) {
 123                   PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = lpi.next();
 124                   String pcdKey = pcdData.getCName() + " " + pcdData.getTokenSpaceGuidCName();
 125                   if (dynPcdMap.get(pcdKey) == null) {
 126                       ArrayList<String> al = new ArrayList<String>();
 127                       al.add(ModuleInfo + " " + pcdData.getItemType().toString());
 128                       dynPcdMap.put(pcdKey, al);
 129                   }
 130                   else{
 131                       dynPcdMap.get(pcdKey).add(ModuleInfo + " " + pcdData.getItemType().toString());
 132                   }
 133               }
 134           }
 135       }
 136     }
 137
 138     public ArrayList<String> getDynPcdMapValue(String key) {
 139         return dynPcdMap.get(key);
 140     }
 141     /**
 142      Constructor to create a new spd file
 143      **/
 144     public FpdFileContents() {
 145
 146         fpdd = PlatformSurfaceAreaDocument.Factory.newInstance();
 147         fpdRoot = fpdd.addNewPlatformSurfaceArea();
 148
 149     }
 150
 151     /**
 152      Constructor for existing document object
 153      @param psa
 154      **/
 155     public FpdFileContents(PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd) {
 156         fpdRoot = fpd;
 157         fpdHdr = fpdRoot.getPlatformHeader();
 158         fpdPlatformDefs = fpdRoot.getPlatformDefinitions();
 159         fpdBuildOpts = fpdRoot.getBuildOptions();
 160         fpdFrameworkModules = fpdRoot.getFrameworkModules();
 161         fpdDynPcdBuildDefs = fpdRoot.getDynamicPcdBuildDefinitions();
 162         fpdFlash = fpdRoot.getFlash();
 163     }
 164
 165     /**
 166      Constructor based on an existing spd file
 167
 168      @param f Existing spd file
 169      **/
 170     public FpdFileContents(File f) {
 171         try {
 172             fpdd = PlatformSurfaceAreaDocument.Factory.parse(f);
 173             fpdRoot = fpdd.getPlatformSurfaceArea();
 174         } catch (Exception e) {
 175             System.out.println(e.toString());
 176         }
 177     }
 178
 179     public DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions getfpdDynPcdBuildDefs() {
 180         if (fpdDynPcdBuildDefs == null){
 181             fpdDynPcdBuildDefs = fpdRoot.addNewDynamicPcdBuildDefinitions();
 182         }
 183         return fpdDynPcdBuildDefs;
 184     }
 185
 186     public FrameworkModulesDocument.FrameworkModules getfpdFrameworkModules() {
 187         if (fpdFrameworkModules == null){
 188             fpdFrameworkModules = fpdRoot.addNewFrameworkModules();
 189         }
 190         return fpdFrameworkModules;
 191     }
 192
 193     public void getFrameworkModuleSAByFvBinding (String fvName, Vector<String[]> vGuid) {
 194         if (getFrameworkModulesCount() == 0){
 195             return;
 196         }
 197
 198         ListIterator li = getfpdFrameworkModules().getModuleSAList().listIterator();
 199         while(li.hasNext()) {
 200             ModuleSADocument.ModuleSA moduleSa = (ModuleSADocument.ModuleSA)li.next();
 201             if (moduleSa.getModuleSaBuildOptions() == null) {
 202                 continue;
 203             }
 204             String fvBinding = moduleSa.getModuleSaBuildOptions().getFvBinding();
 205             if (fvBinding == null) {
 206                 continue;
 207             }
 208
 209             String[] fvNames = fvBinding.split(" ");
 210             for (int i = 0; i < fvNames.length; ++i) {
 211                 //
 212                 // BugBug : underscore "_" should not be replaced!!!
 213                 // But Fv name FVMAIN from fdf file not consist with FV_MAIN in fpd file.
 214                 //
 215                 if (fvNames[i].equals(fvName) || fvNames[i].replaceAll("_", "").equals(fvName)) {
 216                     String[] sa = new String[] {moduleSa.getModuleGuid(), moduleSa.getModuleVersion(),
 217                                                 moduleSa.getPackageGuid(), moduleSa.getPackageVersion(),
 218                                                 listToString(moduleSa.getSupArchList())};
 219                     vGuid.add(sa);
 220                     break;
 221                 }
 222             }
 223         }
 224     }
 225
 226     public int getFrameworkModulesCount() {
 227         if (getfpdFrameworkModules().getModuleSAList() == null || getfpdFrameworkModules().getModuleSAList().size() == 0){
 228             removeElement(getfpdFrameworkModules());
 229             fpdFrameworkModules = null;
 230             return 0;
 231         }
 232         return getfpdFrameworkModules().getModuleSAList().size();
 233     }
 234
 235     public void getFrameworkModulesInfo(String[][] saa) {
 236         if (getFrameworkModulesCount() == 0){
 237             return;
 238         }
 239
 240         ListIterator li = getfpdFrameworkModules().getModuleSAList().listIterator();
 241         int i = 0;
 242         while(li.hasNext()) {
 243             ModuleSADocument.ModuleSA moduleSa = (ModuleSADocument.ModuleSA)li.next();
 244             saa[i][0] = moduleSa.getModuleGuid();
 245             saa[i][1] = moduleSa.getModuleVersion();
 246
 247             saa[i][2] = moduleSa.getPackageGuid();
 248             saa[i][3] = moduleSa.getPackageVersion();
 249             saa[i][4] = listToString(moduleSa.getSupArchList());
 250             ++i;
 251         }
 252     }
 253
 254     public void getFrameworkModuleInfo(int i, String[] sa) {
 255         ModuleSADocument.ModuleSA msa = getModuleSA(i);
 256         if (msa == null) {
 257             return;
 258         }
 259         sa[0] = msa.getModuleGuid();
 260         sa[1] = msa.getModuleVersion();
 261         sa[2] = msa.getPackageGuid();
 262         sa[3] = msa.getPackageVersion();
 263         sa[4] = listToString(msa.getSupArchList());
 264     }
 265
 266     public ModuleSADocument.ModuleSA getModuleSA(String key) {
 267
 268         if (getfpdFrameworkModules().getModuleSAList() == null || getfpdFrameworkModules().getModuleSAList().size() == 0) {
 269             removeElement(getfpdFrameworkModules());
 270             fpdFrameworkModules = null;
 271             return null;
 272         }
 273         String[] s = key.split(" ");
 274         String archsInKey = "";
 275         if (s.length > 4) {
 276             for (int i = 4; i < s.length; ++i) {
 277                 archsInKey += s[i];
 278                 archsInKey += " ";
 279             }
 280             archsInKey = archsInKey.trim();
 281         }
 282
 283         ListIterator li = getfpdFrameworkModules().getModuleSAList().listIterator();
 284         while(li.hasNext()) {
 285             ModuleSADocument.ModuleSA moduleSa = (ModuleSADocument.ModuleSA)li.next();
 286             if (moduleSa.getModuleGuid().equalsIgnoreCase(s[0]) && moduleSa.getPackageGuid().equalsIgnoreCase(s[2])) {
 287                 if (moduleSa.getModuleVersion() != null) {
 288                     if (!moduleSa.getModuleVersion().equals(s[1])) {
 289                         continue;
 290                     }
 291                 }
 292                 if (moduleSa.getPackageVersion() != null) {
 293                     if (!moduleSa.getPackageVersion().equals(s[3])) {
 294                         continue;
 295                     }
 296                 }
 297                 //ToDo add arch check .
 298                 if (moduleSa.getSupArchList() != null) {
 299                     if (listToString(moduleSa.getSupArchList()).equals(archsInKey)) {
 300                         return moduleSa;
 301                     }
 302                 }
 303                 else {
 304                     if (archsInKey.length() == 0) {
 305                         return moduleSa;
 306                     }
 307                 }
 308             }
 309         }
 310         return null;
 311     }
 312
 313     private ModuleSADocument.ModuleSA getModuleSA(int i) {
 314         ModuleSADocument.ModuleSA moduleSa = null;
 315         if (fpdRoot.getFrameworkModules() == null) {
 316             return null;
 317         }
 318         XmlCursor cursor = fpdRoot.getFrameworkModules().newCursor();
 319         if (cursor.toFirstChild()) {
 320             for (int j = 0; j < i; ++j) {
 321                 cursor.toNextSibling();
 322             }
 323             moduleSa = (ModuleSADocument.ModuleSA)cursor.getObject();
 324         }
 325         cursor.dispose();
 326         return moduleSa;
 327     }
 328
 329     public void removeModuleSA(int i) {
 330         XmlObject o = fpdRoot.getFrameworkModules();
 331         if (o == null) {
 332             return;
 333         }
 334
 335         XmlCursor cursor = o.newCursor();
 336         if (cursor.toFirstChild()) {
 337             for (int j = 0; j < i; ++j) {
 338                 cursor.toNextSibling();
 339             }
 340             //
 341             // remove pcd from dynPcdMap, if DynamicPcdBuildData exists, remove them too.
 342             //
 343             ModuleSADocument.ModuleSA moduleSa = (ModuleSADocument.ModuleSA)cursor.getObject();
 344             String moduleInfo = moduleSa.getModuleGuid() + " " + moduleSa.getModuleVersion() + " " +
 345             moduleSa.getPackageGuid()+ " " + moduleSa.getPackageVersion() + " " + listToString(moduleSa.getSupArchList());
 346             PcdBuildDefinitionDocument.PcdBuildDefinition pcdBuildDef = moduleSa.getPcdBuildDefinition();
 347             if (pcdBuildDef != null && pcdBuildDef.getPcdDataList() != null) {
 348                 ListIterator<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData> li = pcdBuildDef.getPcdDataList().listIterator();
 349                 while(li.hasNext()) {
 350                     PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = li.next();
 351                     maintainDynPcdMap(pcdData.getCName() + " " + pcdData.getTokenSpaceGuidCName(), moduleInfo);
 352                 }
 353             }
 354
 355             cursor.push();
 356             while (cursor.hasPrevToken()) {
 357                 cursor.toPrevToken();
 358                 if (!cursor.isText()) {
 359                     break;
 360                 }
 361                 String s = cursor.getTextValue();
 362                 if (s.matches(regExpNewLineAndSpaces)) {
 363                     continue;
 364                 }
 365             }
 366
 367             if (cursor.isComment()) {
 368                 cursor.removeXml();
 369             }
 370
 371             cursor.pop();
 372             cursor.removeXml();
 373             if (getFrameworkModulesCount() == 0) {
 374                 cursor.toParent();
 375                 cursor.removeXml();
 376             }
 377         }
 378         cursor.dispose();
 379     }
 380
 381     public boolean adjustPcd (int seqModuleSa) throws Exception {
 382         boolean dataModified = false;
 383         ModuleSADocument.ModuleSA moduleSa = getModuleSA(seqModuleSa);
 384         int pcdCount = getPcdDataCount(seqModuleSa);
 385         String[][] saaModuleSaPcd = new String[pcdCount][7];
 386         getPcdData(seqModuleSa, saaModuleSaPcd);
 387         String mg = moduleSa.getModuleGuid();
 388         String mv = moduleSa.getModuleVersion();
 389         String pg = moduleSa.getPackageGuid();
 390         String pv = moduleSa.getPackageVersion();
 391         String arch = listToString(moduleSa.getSupArchList());
 392         //
 393         // delete pcd in ModuleSA but not in MSA files any longer.
 394         //
 395         String moduleKey = mg + " " + mv + " " + pg + " " + pv + " " + arch;
 396         int libCount = getLibraryInstancesCount(moduleKey);
 397         String[][] saaLib = new String[libCount][5];
 398         getLibraryInstances(moduleKey, saaLib);
 399         ModuleIdentification mi = WorkspaceProfile.getModuleId(moduleKey);
 400         Vector<ModuleIdentification> vMi = new Vector<ModuleIdentification>();
 401         //
 402         // create vector for module & library instance MIs.
 403         //
 404         vMi.add(mi);
 405         for (int j = 0; j < saaLib.length; ++j) {
 406             String libKey = saaLib[j][1] + " " + saaLib[j][2] + " " + saaLib[j][3] + " " + saaLib[j][4];
 407             ModuleIdentification libMi = WorkspaceProfile.getModuleId(libKey);
 408             vMi.add(libMi);
 409         }
 410
 411     nextPcd:for (int i = 0; i < saaModuleSaPcd.length; ++i) {
 412
 413                 for (int j = 0; j < vMi.size(); ++j) {
 414                     ModuleIdentification nextMi = vMi.get(j);
 415                     if (WorkspaceProfile.pcdInMsa(saaModuleSaPcd[i][0], saaModuleSaPcd[i][1], nextMi)) {
 416                         continue nextPcd;
 417                     }
 418                 }
 419                 removePcdData(seqModuleSa, saaModuleSaPcd[i][0], saaModuleSaPcd[i][1]);
 420                 dataModified = true;
 421             }
 422         //
 423         // add new Pcd from MSA file to ModuleSA.
 424         //
 425            for (int i = 0; i < vMi.size(); ++i) {
 426                 ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = (ModuleSurfaceAreaDocument.ModuleSurfaceArea) WorkspaceProfile
 427                                                                                                                           .getModuleXmlObject(vMi
 428                                                                                                                                                  .get(i));
 429                 if (msa.getPcdCoded() == null || msa.getPcdCoded().getPcdEntryList() == null) {
 430                     continue;
 431                 }
 432                 ListIterator li = msa.getPcdCoded().getPcdEntryList().listIterator();
 433      msaPcdIter:while (li.hasNext()) {
 434                     PcdCodedDocument.PcdCoded.PcdEntry msaPcd = (PcdCodedDocument.PcdCoded.PcdEntry) li.next();
 435                     ArrayList<String> al = getDynPcdMapValue(msaPcd.getCName() + " " + msaPcd.getTokenSpaceGuidCName());
 436                     if (al != null) {
 437                         for (int j = 0; j < al.size(); ++j) {
 438                             if (al.get(j).contains(moduleKey)) {
 439                                 continue msaPcdIter;
 440                             }
 441                         }
 442                     }
 443
 444                     PackageIdentification[] depPkgs = SurfaceAreaQuery.getDependencePkg(null, vMi.get(i));
 445                     PcdDeclarationsDocument.PcdDeclarations.PcdEntry spdPcd = LookupPcdDeclaration(msaPcd, depPkgs);
 446                     if (spdPcd == null) {
 447                         //
 448                         // ToDo Error
 449                         //
 450                         throw new PcdDeclNotFound("No Declaration for PCD Entry " + msaPcd.getCName() + " in Module "
 451                                                   + mi.getName());
 452                     }
 453                     //
 454                     // AddItem to ModuleSA PcdBuildDefinitions
 455                     //
 456                     String defaultVal = msaPcd.getDefaultValue() == null ? spdPcd.getDefaultValue()
 457                                                                         : msaPcd.getDefaultValue();
 458
 459                     genPcdData(msaPcd.getCName(), spdPcd.getToken(), msaPcd.getTokenSpaceGuidCName(),
 460                                msaPcd.getPcdItemType().toString(), spdPcd.getDatumType() + "", defaultVal, moduleSa);
 461                     dataModified = true;
 462                  }
 463
 464             }
 465
 466         return dataModified;
 467     }
 468
 469     private void maintainDynPcdMap(String pcdKey, String moduleInfo) {
 470
 471         ArrayList<String> al = dynPcdMap.get(pcdKey);
 472         if (al == null) {
 473             return;
 474         }
 475         String[] s = moduleInfo.split(" ");
 476         for(int i = 0; i < al.size(); ++i){
 477             String consumer = al.get(i);
 478             if (consumer.contains(s[0]) && consumer.contains(s[2])){
 479                 String[] consumerPart = consumer.split(" ");
 480                 if (!consumerPart[4].equals(s[4])) {
 481                     continue;
 482                 }
 483                 al.remove(consumer);
 484                 break;
 485             }
 486         }
 487
 488         if (al.size() == 0) {
 489             defaultPcdValue.remove(pcdKey);
 490             dynPcdMap.remove(pcdKey);
 491             String[] s1 = pcdKey.split(" ");
 492             removeDynamicPcdBuildData(s1[0], s1[1]);
 493         }
 494
 495     }
 496     //
 497     // key for ModuleSA : "ModuleGuid ModuleVer PackageGuid PackageVer Arch"
 498     //
 499     public int getPcdDataCount (int i){
 500         ModuleSADocument.ModuleSA msa = getModuleSA(i);
 501
 502         if (msa == null || msa.getPcdBuildDefinition() == null || msa.getPcdBuildDefinition().getPcdDataList() == null){
 503             return 0;
 504         }
 505         return msa.getPcdBuildDefinition().getPcdDataList().size();
 506
 507     }
 508
 509     public void getPcdData (int i, String[][] saa) {
 510         ModuleSADocument.ModuleSA msa = getModuleSA(i);
 511
 512         if (msa == null || msa.getPcdBuildDefinition() == null || msa.getPcdBuildDefinition().getPcdDataList() == null){
 513             return;
 514         }
 515         ListIterator<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData>li = msa.getPcdBuildDefinition().getPcdDataList().listIterator();
 516         for (int k = 0; k < saa.length; ++k) {
 517             PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = li.next();
 518             saa[k][0] = pcdData.getCName();
 519             saa[k][1] = pcdData.getTokenSpaceGuidCName();
 520             saa[k][2] = pcdData.getItemType()+"";
 521             saa[k][3] = pcdData.getToken().toString();
 522             saa[k][4] = pcdData.getMaxDatumSize()+"";
 523             saa[k][5] = pcdData.getDatumType()+"";
 524             saa[k][6] = pcdData.getValue();
 525
 526         }
 527     }
 528
 529     public void removePcdData (int seqModuleSa, String cName, String tsGuid) {
 530         ModuleSADocument.ModuleSA moduleSa = getModuleSA(seqModuleSa);
 531         if (moduleSa == null || moduleSa.getPcdBuildDefinition() == null){
 532             return;
 533         }
 534
 535         String mg = moduleSa.getModuleGuid();
 536         String mv = moduleSa.getModuleVersion();
 537         String pg = moduleSa.getPackageGuid();
 538         String pv = moduleSa.getPackageVersion();
 539         String arch = listToString(moduleSa.getSupArchList());
 540         String moduleKey = mg + " " + mv + " " + pg + " " + pv + " " + arch;
 541
 542         XmlCursor cursor = moduleSa.getPcdBuildDefinition().newCursor();
 543         if (cursor.toFirstChild()){
 544
 545             do {
 546                 PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = (PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData)cursor.getObject();
 547                 if (pcdData.getCName().equals(cName) && pcdData.getTokenSpaceGuidCName().equals(tsGuid)) {
 548                     maintainDynPcdMap(cName + " " + tsGuid, moduleKey);
 549                     if (getPcdDataCount(seqModuleSa) == 1) {
 550                         cursor.toParent();
 551                     }
 552                     cursor.removeXml();
 553                     break;
 554                 }
 555             }
 556             while(cursor.toNextSibling());
 557
 558         }
 559         cursor.dispose();
 560     }
 561
 562     public void updatePcdData (String key, String cName, String tsGuid, String itemType, String maxSize, String value){
 563         ModuleSADocument.ModuleSA moduleSa = getModuleSA(key);
 564         if (moduleSa == null || moduleSa.getPcdBuildDefinition() == null){
 565             return;
 566         }
 567
 568         XmlCursor cursor = moduleSa.getPcdBuildDefinition().newCursor();
 569         if (cursor.toFirstChild()){
 570             do {
 571                 PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = (PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData)cursor.getObject();
 572                 if (pcdData.getCName().equals(cName) && pcdData.getTokenSpaceGuidCName().equals(tsGuid)) {
 573                     //
 574                     // change item type while not updating dynPcdData????
 575                     //
 576                     pcdData.setItemType(PcdItemTypes.Enum.forString(itemType));
 577                     if(pcdData.getDatumType().equals("VOID*")) {
 578                         pcdData.setMaxDatumSize(new Integer(maxSize));
 579                     }
 580                     pcdData.setValue(value);
 581                     defaultPcdValue.put(cName + " " + tsGuid, value);
 582                     break;
 583                 }
 584             }
 585             while(cursor.toNextSibling());
 586         }
 587         cursor.dispose();
 588     }
 589
 590     /**Get original Pcd info from MSA & SPD files.
 591      * @param mi ModuleIdentification from which MSA & SPD come
 592      * @param cName PCD cName
 593      * @param sa Results: HelpText, Original item type.
 594      * @return
 595      */
 596     public boolean getPcdBuildDataInfo(ModuleIdentification mi, String cName, String tsGuid, String[] sa) throws Exception{
 597         try {
 598
 599             ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = (ModuleSurfaceAreaDocument.ModuleSurfaceArea)WorkspaceProfile.getModuleXmlObject(mi);
 600             if (msa.getPcdCoded() == null) {
 601                 return false;
 602             }
 603
 604             Map<String, XmlObject> m = new HashMap<String, XmlObject>();
 605             m.put("ModuleSurfaceArea", msa);
 606             SurfaceAreaQuery.setDoc(m);
 607             PackageIdentification[] depPkgs = SurfaceAreaQuery.getDependencePkg(null, mi);
 608             //
 609             // First look through MSA pcd entries.
 610             //
 611             List<PcdCodedDocument.PcdCoded.PcdEntry> l = msa.getPcdCoded().getPcdEntryList();
 612             ListIterator li = l.listIterator();
 613             while(li.hasNext()) {
 614                 PcdCodedDocument.PcdCoded.PcdEntry msaPcd = (PcdCodedDocument.PcdCoded.PcdEntry)li.next();
 615                 if (!msaPcd.getCName().equals(cName)) {
 616                     continue;
 617                 }
 618                 if (!msaPcd.getTokenSpaceGuidCName().equals(tsGuid)) {
 619                     continue;
 620                 }
 621                 PcdDeclarationsDocument.PcdDeclarations.PcdEntry spdPcd = LookupPcdDeclaration(msaPcd, depPkgs);
 622                 if (spdPcd == null) {
 623                     //
 624                     // ToDo Error
 625                     //
 626                     throw new PcdDeclNotFound(mi.getName() + " " + msaPcd.getCName());
 627                 }
 628                 //
 629                 // Get Pcd help text and original item type.
 630                 //
 631                 sa[0] = spdPcd.getHelpText() + msaPcd.getHelpText();
 632                 sa[1] = msaPcd.getPcdItemType()+"";
 633                 sa[2] = msa.getModuleDefinitions().getBinaryModule()+"";
 634                 return true;
 635             }
 636
 637
 638         }
 639         catch (Exception e){
 640             e.printStackTrace();
 641             throw e;
 642         }
 643
 644         return false;
 645     }
 646
 647     private boolean multiSourcePcd (String cName, String tsGuidCName, String moduleKey) {
 648         int libCount = getLibraryInstancesCount(moduleKey);
 649         String[][] saaLib = new String[libCount][5];
 650         getLibraryInstances(moduleKey, saaLib);
 651         ModuleIdentification mi = WorkspaceProfile.getModuleId(moduleKey);
 652         Vector<ModuleIdentification> vMi = new Vector<ModuleIdentification>();
 653         //
 654         // create vector for module & library instance MIs.
 655         //
 656         vMi.add(mi);
 657         for (int j = 0; j < saaLib.length; ++j) {
 658             String libKey = saaLib[j][1] + " " + saaLib[j][2] + " " + saaLib[j][3] + " " + saaLib[j][4];
 659             ModuleIdentification libMi = WorkspaceProfile.getModuleId(libKey);
 660             vMi.add(libMi);
 661         }
 662
 663         int pcdSourceCount = 0;
 664         for (int i = 0; i < vMi.size(); ++i) {
 665             if (WorkspaceProfile.pcdInMsa(cName, tsGuidCName, vMi.get(i))) {
 666                 pcdSourceCount++;
 667             }
 668         }
 669
 670         if (pcdSourceCount < 2) {
 671             return false;
 672         }
 673         else {
 674             return true;
 675         }
 676
 677     }
 678
 679     /**Remove PCDBuildDefinition entries from ModuleSA
 680      * @param moduleKey identifier of ModuleSA.
 681      * @param consumer where these entries come from.
 682      */
 683     public void removePcdData(String moduleKey, ModuleIdentification consumer) {
 684
 685             ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = (ModuleSurfaceAreaDocument.ModuleSurfaceArea)WorkspaceProfile.getModuleXmlObject(consumer);
 686             if (msa.getPcdCoded() == null) {
 687                 return;
 688             }
 689
 690             List<PcdCodedDocument.PcdCoded.PcdEntry> l = msa.getPcdCoded().getPcdEntryList();
 691             ListIterator li = l.listIterator();
 692
 693             while(li.hasNext()) {
 694                 PcdCodedDocument.PcdCoded.PcdEntry msaPcd = (PcdCodedDocument.PcdCoded.PcdEntry)li.next();
 695                 ModuleSADocument.ModuleSA moduleSA = getModuleSA(moduleKey);
 696                 if (moduleSA.getPcdBuildDefinition() != null) {
 697                     XmlCursor cursor = moduleSA.getPcdBuildDefinition().newCursor();
 698                     cursor.push();
 699                     if (cursor.toFirstChild()) {
 700                         do {
 701                             PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = (PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData) cursor
 702                                                                                                                                                           .getObject();
 703                             String cName = msaPcd.getCName();
 704                             String tsGuidCName = msaPcd.getTokenSpaceGuidCName();
 705                             if (cName.equals(pcdData.getCName())
 706                                 && tsGuidCName.equals(pcdData.getTokenSpaceGuidCName()) && !multiSourcePcd(cName, tsGuidCName, moduleKey)) {
 707
 708                                 maintainDynPcdMap(pcdData.getCName() + " " + pcdData.getTokenSpaceGuidCName(),
 709                                                   moduleKey);
 710                                 cursor.removeXml();
 711                                 break;
 712                             }
 713                         } while (cursor.toNextSibling());
 714                     }
 715
 716                     cursor.pop();
 717                     if (moduleSA.getPcdBuildDefinition().getPcdDataList().size() == 0) {
 718                         cursor.removeXml();
 719                     }
 720                     cursor.dispose();
 721                 }
 722             }
 723
 724     }
 725     //
 726     // key for ModuleSA : "ModuleGuid ModuleVer PackageGuid PackageVer Arch"
 727     //
 728     public int getLibraryInstancesCount(String key) {
 729         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 730         if (msa == null || msa.getLibraries() == null || msa.getLibraries().getInstanceList() == null){
 731             return 0;
 732         }
 733         return msa.getLibraries().getInstanceList().size();
 734     }
 735
 736     public void getLibraryInstances(String key, String[][] saa){
 737         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 738         if (msa == null || msa.getLibraries() == null || msa.getLibraries().getInstanceList() == null){
 739             return ;
 740         }
 741
 742         ListIterator<LibrariesDocument.Libraries.Instance> li = msa.getLibraries().getInstanceList().listIterator();
 743         for (int i = 0; i < saa.length; ++i) {
 744             LibrariesDocument.Libraries.Instance instance = li.next();
 745             saa[i][1] = instance.getModuleGuid();
 746             saa[i][2] = instance.getModuleVersion();
 747             saa[i][3] = instance.getPackageGuid();
 748             saa[i][4] = instance.getPackageVersion();
 749         }
 750     }
 751
 752     public void removeLibraryInstance(String key, int i) {
 753         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 754         if (msa == null || msa.getLibraries() == null){
 755             return ;
 756         }
 757
 758         XmlCursor cursor = msa.getLibraries().newCursor();
 759         if (cursor.toFirstChild()) {
 760             for (int j = 0; j < i; ++j) {
 761                 cursor.toNextSibling();
 762             }
 763             cursor.push();
 764             while (cursor.hasPrevToken()) {
 765                 cursor.toPrevToken();
 766                 if (!cursor.isText()) {
 767                     break;
 768                 }
 769                 String s = cursor.getTextValue();
 770                 if (s.matches(regExpNewLineAndSpaces)) {
 771                     continue;
 772                 }
 773             }
 774
 775             if (cursor.isComment()) {
 776                 cursor.removeXml();
 777             }
 778             cursor.pop();
 779             cursor.removeXml();
 780             if (getLibraryInstancesCount(key) == 0) {
 781                 cursor.toParent();
 782                 cursor.removeXml();
 783             }
 784         }
 785
 786         cursor.dispose();
 787     }
 788
 789     public void genLibraryInstance(ModuleIdentification libMi, String key) {
 790         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 791         if (msa == null){
 792             msa = getfpdFrameworkModules().addNewModuleSA();
 793         }
 794         LibrariesDocument.Libraries libs = msa.getLibraries();
 795         if(libs == null){
 796             libs = msa.addNewLibraries();
 797         }
 798
 799         String mn = libMi.getName();
 800         String mg = libMi.getGuid();
 801         String mv = libMi.getVersion();
 802         String pn = libMi.getPackageId().getName();
 803         String pg = libMi.getPackageId().getGuid();
 804         String pv = libMi.getPackageId().getVersion();
 805         LibrariesDocument.Libraries.Instance instance = libs.addNewInstance();
 806         XmlCursor cursor = instance.newCursor();
 807         try{
 808             String comment = "Pkg: " + pn + " Mod: " + mn
 809                 + " Path: " + libMi.getPath().substring(System.getenv("WORKSPACE").length() + 1);
 810             cursor.insertComment(comment);
 811         }
 812         catch (Exception e){
 813             e.printStackTrace();
 814         }
 815         finally {
 816             cursor.dispose();
 817         }
 818
 819         instance.setModuleGuid(mg);
 820         instance.setModuleVersion(mv);
 821         instance.setPackageGuid(pg);
 822         instance.setPackageVersion(pv);
 823
 824     }
 825
 826     public String getFvBinding(String moduleKey){
 827         ModuleSADocument.ModuleSA moduleSa = getModuleSA(moduleKey);
 828         return getFvBinding (moduleSa);
 829     }
 830
 831     public String getFvBinding (ModuleSADocument.ModuleSA moduleSa) {
 832         if (moduleSa == null || moduleSa.getModuleSaBuildOptions() == null) {
 833             return null;
 834         }
 835         return moduleSa.getModuleSaBuildOptions().getFvBinding();
 836     }
 837
 838     public void setFvBinding(ModuleSADocument.ModuleSA moduleSa, String fvBinding) {
 839         if (moduleSa == null ) {
 840             return;
 841         }
 842         if (fvBinding == null || fvBinding.length() == 0) {
 843             if(moduleSa.getModuleSaBuildOptions() != null){
 844                 moduleSa.getModuleSaBuildOptions().unsetFvBinding();
 845             }
 846         }
 847         else {
 848             if(moduleSa.getModuleSaBuildOptions() == null){
 849                 moduleSa.addNewModuleSaBuildOptions().setFvBinding(fvBinding);
 850                 return;
 851             }
 852             moduleSa.getModuleSaBuildOptions().setFvBinding(fvBinding);
 853         }
 854     }
 855
 856     public void setFvBinding(String moduleKey, String fvBinding){
 857         ModuleSADocument.ModuleSA moduleSa = getModuleSA(moduleKey);
 858         setFvBinding (moduleSa, fvBinding);
 859     }
 860
 861     private int fvBindingForModuleSA (ModuleSADocument.ModuleSA moduleSa, String fvName) {
 862         if (moduleSa == null || moduleSa.getModuleSaBuildOptions() == null || moduleSa.getModuleSaBuildOptions().getFvBinding() == null) {
 863             return -1;
 864         }
 865
 866         String fvNameList = moduleSa.getModuleSaBuildOptions().getFvBinding();
 867         String[] fvNamesArray = fvNameList.split(" ");
 868         int occursAt = -1;
 869         for (int i = 0; i < fvNamesArray.length; ++i) {
 870             if (fvNamesArray[i].equals(fvName)) {
 871                 occursAt = i;
 872                 break;
 873             }
 874         }
 875         return occursAt;
 876     }
 877
 878     public void removeFvBinding (ModuleSADocument.ModuleSA moduleSa, String fvName) {
 879         if (moduleSa == null || moduleSa.getModuleSaBuildOptions() == null || moduleSa.getModuleSaBuildOptions().getFvBinding() == null) {
 880             return;
 881         }
 882
 883         String fvNameList = moduleSa.getModuleSaBuildOptions().getFvBinding();
 884         String[] fvNamesArray = fvNameList.split(" ");
 885         int occursAt = -1;
 886         for (int i = 0; i < fvNamesArray.length; ++i) {
 887             if (fvNamesArray[i].equals(fvName)) {
 888                 occursAt = i;
 889                 break;
 890             }
 891         }
 892         // jump over where the input fvName occurs in the original Fv list.
 893         if (occursAt != -1) {
 894             String newFvNameList = " ";
 895             for (int i = 0; i < fvNamesArray.length; ++i) {
 896                 if (i == occursAt) {
 897                     continue;
 898                 }
 899                 newFvNameList += fvNamesArray[i];
 900             }
 901             setFvBinding (moduleSa, newFvNameList.trim());
 902         }
 903
 904     }
 905
 906     /**
 907      * @param fvName The FV name that to be removed from FvBinding List.
 908      */
 909     public void removeFvBindingAll (String fvName) {
 910         if (getfpdFrameworkModules().getModuleSAList() == null || getfpdFrameworkModules().getModuleSAList().size() == 0){
 911             removeElement(getfpdFrameworkModules());
 912             fpdFrameworkModules = null;
 913             return;
 914         }
 915
 916         Iterator<ModuleSADocument.ModuleSA> li = getfpdFrameworkModules().getModuleSAList().iterator();
 917         while (li.hasNext()) {
 918             ModuleSADocument.ModuleSA moduleSa = li.next();
 919             removeFvBinding (moduleSa, fvName);
 920         }
 921     }
 922
 923     public void appendFvBindingAll (String fvName) {
 924         if (getfpdFrameworkModules().getModuleSAList() == null || getfpdFrameworkModules().getModuleSAList().size() == 0){
 925             removeElement(getfpdFrameworkModules());
 926             fpdFrameworkModules = null;
 927             return;
 928         }
 929
 930         Iterator<ModuleSADocument.ModuleSA> li = getfpdFrameworkModules().getModuleSAList().iterator();
 931         while (li.hasNext()) {
 932             ModuleSADocument.ModuleSA moduleSa = li.next();
 933             appendFvBinding (moduleSa, fvName);
 934         }
 935     }
 936
 937     public void appendFvBindingFor (String oldFvName, String newFvName) {
 938         if (getfpdFrameworkModules().getModuleSAList() == null || getfpdFrameworkModules().getModuleSAList().size() == 0){
 939             removeElement(getfpdFrameworkModules());
 940             fpdFrameworkModules = null;
 941             return;
 942         }
 943
 944         Iterator<ModuleSADocument.ModuleSA> li = getfpdFrameworkModules().getModuleSAList().iterator();
 945         while (li.hasNext()) {
 946             ModuleSADocument.ModuleSA moduleSa = li.next();
 947             String fvBinding = getFvBinding (moduleSa);
 948             if (fvBinding != null && fvBindingForModuleSA (moduleSa, oldFvName) >= 0) {
 949                 appendFvBinding (moduleSa, newFvName);
 950             }
 951         }
 952     }
 953
 954     public void appendFvBinding (String moduleKey, String fvName) {
 955         ModuleSADocument.ModuleSA moduleSa = getModuleSA(moduleKey);
 956         appendFvBinding (moduleSa, fvName);
 957     }
 958
 959     public void appendFvBinding (ModuleSADocument.ModuleSA moduleSa, String fvName) {
 960         if (moduleSa == null) {
 961             return;
 962         }
 963
 964         if (moduleSa.getModuleSaBuildOptions() == null || moduleSa.getModuleSaBuildOptions().getFvBinding() == null) {
 965             setFvBinding(moduleSa, fvName);
 966             return;
 967         }
 968
 969         String fvNameList = moduleSa.getModuleSaBuildOptions().getFvBinding();
 970         String newFvNameList = fvNameList + " " + fvName;
 971         setFvBinding (moduleSa, newFvNameList.trim());
 972     }
 973
 974     public void updateFvBindingInModuleSA (String moduleKey, String fvName) {
 975
 976         appendFvBinding (moduleKey, fvName);
 977     }
 978
 979     public String getFfsFileNameGuid(String moduleKey){
 980         ModuleSADocument.ModuleSA moduleSa = getModuleSA(moduleKey);
 981         if (moduleSa == null || moduleSa.getModuleSaBuildOptions() == null) {
 982             return null;
 983         }
 984         return moduleSa.getModuleSaBuildOptions().getFfsFileNameGuid();
 985     }
 986
 987     public void setFfsFileNameGuid(String moduleKey, String fileGuid){
 988         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 989         if (msa == null ) {
 990             return;
 991         }
 992         if(msa.getModuleSaBuildOptions() == null){
 993             msa.addNewModuleSaBuildOptions();
 994
 995         }
 996         ModuleSaBuildOptionsDocument.ModuleSaBuildOptions msaBuildOpts= msa.getModuleSaBuildOptions();
 997         if (fileGuid != null) {
 998             msaBuildOpts.setFfsFileNameGuid(fileGuid);
 999         }
1000         else{
1001             XmlCursor cursor = msaBuildOpts.newCursor();
1002             if (cursor.toChild(xmlNs, "FfsFileNameGuid")) {
1003                 cursor.removeXml();
1004             }
1005             cursor.dispose();
1006         }
1007
1008     }
1009
1010     public String getFfsFormatKey(String moduleKey){
1011         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
1012         if (msa == null || msa.getModuleSaBuildOptions() == null) {
1013             return null;
1014         }
1015         return msa.getModuleSaBuildOptions().getFfsFormatKey();
1016     }
1017
1018     public void setFfsFormatKey(String moduleKey, String ffsKey){
1019         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
1020         if (msa == null ) {
1021             return;
1022         }
1023         if(msa.getModuleSaBuildOptions() == null){
1024             msa.addNewModuleSaBuildOptions().setFfsFormatKey(ffsKey);
1025             return;
1026         }
1027         msa.getModuleSaBuildOptions().setFfsFormatKey(ffsKey);
1028     }
1029
1030     public void setModuleSAForceDebug(int i, boolean dbgEnable) {
1031         ModuleSADocument.ModuleSA moduleSa = getModuleSA(i);
1032         moduleSa.setForceDebug(dbgEnable);
1033     }
1034
1035     public boolean getModuleSAForceDebug (int i) {
1036         ModuleSADocument.ModuleSA moduleSa = getModuleSA(i);
1037         if (moduleSa.getForceDebug() == true) {
1038             return true;
1039         }
1040         return false;
1041     }
1042
1043     public void getModuleSAOptions(String moduleKey, String[][] saa) {
1044         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
1045         if (msa == null || msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null
1046                         || msa.getModuleSaBuildOptions().getOptions().getOptionList() == null) {
1047             return ;
1048         }
1049
1050         List<OptionDocument.Option> lOpt = msa.getModuleSaBuildOptions().getOptions().getOptionList();
1051         ListIterator li = lOpt.listIterator();
1052         int i = 0;
1053         while(li.hasNext()) {
1054             OptionDocument.Option opt = (OptionDocument.Option)li.next();
1055             if (opt.getBuildTargets() != null) {
1056                 saa[i][0] = listToString(opt.getBuildTargets());
1057             }
1058             saa[i][1] = opt.getToolChainFamily();
1059             saa[i][2] = opt.getTagName();
1060             saa[i][3] = opt.getToolCode();
1061
1062             if (opt.getSupArchList() != null){
1063                 saa[i][4] = listToString(opt.getSupArchList());
1064             }
1065             else {
1066                 saa[i][4] = "";
1067             }
1068
1069             saa[i][5] = opt.getStringValue();
1070
1071             ++i;
1072         }
1073     }
1074
1075     public int getModuleSAOptionsCount(String moduleKey){
1076         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
1077         if (msa == null || msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null
1078                         || msa.getModuleSaBuildOptions().getOptions().getOptionList() == null) {
1079             return 0;
1080         }
1081         return msa.getModuleSaBuildOptions().getOptions().getOptionList().size();
1082     }
1083
1084     public void genModuleSAOptionsOpt(String moduleKey, Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
1085         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
1086         if (msa.getModuleSaBuildOptions() == null) {
1087             msa.addNewModuleSaBuildOptions();
1088         }
1089         if (msa.getModuleSaBuildOptions().getOptions() == null){
1090             msa.getModuleSaBuildOptions().addNewOptions();
1091         }
1092         OptionDocument.Option opt = msa.getModuleSaBuildOptions().getOptions().addNewOption();
1093         setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
1094     }
1095
1096     public void removeModuleSAOptionsOpt(String moduleKey, int i) {
1097         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
1098         if (msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null) {
1099             return ;
1100         }
1101         OptionsDocument.Options opts = msa.getModuleSaBuildOptions().getOptions();
1102         XmlCursor cursor = opts.newCursor();
1103         if (cursor.toFirstChild()) {
1104             for (int j = 0; j < i; ++j){
1105                 cursor.toNextSibling();
1106             }
1107             cursor.removeXml();
1108         }
1109         cursor.dispose();
1110     }
1111
1112     public void updateModuleSAOptionsOpt(String moduleKey, int i, Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
1113         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
1114         if (msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null) {
1115             return ;
1116         }
1117         OptionsDocument.Options opts = msa.getModuleSaBuildOptions().getOptions();
1118         XmlCursor cursor = opts.newCursor();
1119         if (cursor.toFirstChild()) {
1120             for (int j = 0; j < i; ++j){
1121                 cursor.toNextSibling();
1122             }
1123             OptionDocument.Option opt = (OptionDocument.Option)cursor.getObject();
1124             setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
1125         }
1126         cursor.dispose();
1127     }
1128
1129     /**add pcd information of module mi to a ModuleSA.
1130      * @param mi
1131      * @param moduleSa if null, generate a new ModuleSA.
1132      */
1133     public void addFrameworkModulesPcdBuildDefs(ModuleIdentification mi, String arch, ModuleSADocument.ModuleSA moduleSa) throws Exception {
1134         //ToDo add Arch filter
1135
1136         try {
1137             if (moduleSa == null) {
1138                 moduleSa = genModuleSA(mi, arch);
1139             }
1140
1141             ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = (ModuleSurfaceAreaDocument.ModuleSurfaceArea)WorkspaceProfile.getModuleXmlObject(mi);
1142             if (msa.getPcdCoded() == null) {
1143                 return;
1144             }
1145
1146             Map<String, XmlObject> m = new HashMap<String, XmlObject>();
1147             m.put("ModuleSurfaceArea", msa);
1148             SurfaceAreaQuery.setDoc(m);
1149             PackageIdentification[] depPkgs = SurfaceAreaQuery.getDependencePkg(null, mi);
1150             //
1151             // Implementing InitializePlatformPcdBuildDefinitions
1152             //
1153             List<PcdCodedDocument.PcdCoded.PcdEntry> l = msa.getPcdCoded().getPcdEntryList();
1154             ListIterator li = l.listIterator();
1155             while(li.hasNext()) {
1156                 PcdCodedDocument.PcdCoded.PcdEntry msaPcd = (PcdCodedDocument.PcdCoded.PcdEntry)li.next();
1157                 PcdDeclarationsDocument.PcdDeclarations.PcdEntry spdPcd = LookupPcdDeclaration(msaPcd, depPkgs);
1158                 if (spdPcd == null) {
1159                     //
1160                     // ToDo Error
1161                     //
1162                     throw new PcdDeclNotFound("No Declaration for PCD Entry " + msaPcd.getCName() + " in Module " + mi.getName());
1163                 }
1164                 //
1165                 // AddItem to ModuleSA PcdBuildDefinitions
1166                 //
1167                 String defaultVal = msaPcd.getDefaultValue() == null ? spdPcd.getDefaultValue() : msaPcd.getDefaultValue();
1168
1169                 genPcdData(msaPcd.getCName(), spdPcd.getToken(), msaPcd.getTokenSpaceGuidCName(), msaPcd.getPcdItemType().toString(), spdPcd.getDatumType()+"", defaultVal, moduleSa);
1170             }
1171
1172         }
1173         catch (Exception e){
1174
1175             throw e;
1176         }
1177
1178     }
1179
1180     private PcdDeclarationsDocument.PcdDeclarations.PcdEntry LookupPcdDeclaration (PcdCodedDocument.PcdCoded.PcdEntry msaPcd, PackageIdentification[] depPkgs) {
1181
1182         PcdDeclarationsDocument.PcdDeclarations.PcdEntry spdPcd = null;
1183         for (int i = 0; i < depPkgs.length; ++i) {
1184
1185             XmlObject[] xo = SurfaceAreaQuery.getSpdPcdDeclarations(depPkgs[i]);
1186             if (xo == null) {
1187                 continue;
1188             }
1189             for (int j = 0; j < xo.length; ++j) {
1190                 spdPcd = (PcdDeclarationsDocument.PcdDeclarations.PcdEntry)xo[j];
1191                 if (msaPcd.getTokenSpaceGuidCName() == null) {
1192                     if (spdPcd.getCName().equals(msaPcd.getCName())) {
1193                         return spdPcd;
1194                     }
1195                 }
1196                 else{
1197                     if (spdPcd.getCName().equals(msaPcd.getCName()) && spdPcd.getTokenSpaceGuidCName().equals(msaPcd.getTokenSpaceGuidCName())) {
1198                         return spdPcd;
1199                     }
1200                 }
1201
1202             }
1203
1204         }
1205         return null;
1206     }
1207
1208     private ModuleSADocument.ModuleSA genModuleSA (ModuleIdentification mi, String arch) {
1209         PackageIdentification pi = WorkspaceProfile.getPackageForModule(mi);
1210         ModuleSADocument.ModuleSA msa = getfpdFrameworkModules().addNewModuleSA();
1211         XmlCursor cursor = msa.newCursor();
1212         try{
1213             String comment = "Mod: " + mi.getName() + " Type: " + SurfaceAreaQuery.getModuleType(mi) + " Path: "
1214                             + mi.getPath().substring(System.getenv("WORKSPACE").length() + 1);
1215             cursor.insertComment(comment);
1216         }
1217         catch(Exception e){
1218             e.printStackTrace();
1219         }
1220         finally {
1221             cursor.dispose();
1222         }
1223         msa.setModuleGuid(mi.getGuid());
1224         msa.setModuleVersion(mi.getVersion());
1225         msa.setPackageGuid(pi.getGuid());
1226         msa.setPackageVersion(pi.getVersion());
1227         if (arch != null) {
1228             Vector<String> v = new Vector<String>();
1229             v.add(arch);
1230             msa.setSupArchList(v);
1231         }
1232
1233         return msa;
1234     }
1235
1236     private void genPcdData (String cName, Object token, String tsGuid, String itemType, String dataType, String defaultVal, ModuleSADocument.ModuleSA moduleSa)
1237     throws PcdItemTypeConflictException, PcdValueMalFormed{
1238         if (moduleSa.getPcdBuildDefinition() == null){
1239             moduleSa.addNewPcdBuildDefinition();
1240         }
1241         //
1242         // constructe pcd to modulesa mapping first.
1243         // Attention : for any error condition, remove from map this pcd.
1244         //
1245         ArrayList<String> pcdConsumer = LookupPlatformPcdData(cName + " " + tsGuid);
1246         if (pcdConsumer == null) {
1247             pcdConsumer = new ArrayList<String>();
1248         }
1249         //
1250         // Check whether this PCD has already added to ModuleSA, if so, just return.
1251         //
1252         String moduleInfo = moduleSa.getModuleGuid().toLowerCase() + " " + moduleSa.getModuleVersion()
1253         + " " + moduleSa.getPackageGuid().toLowerCase() + " " + moduleSa.getPackageVersion() + " " + listToString(moduleSa.getSupArchList());
1254         for (int i = 0; i < pcdConsumer.size(); ++i) {
1255             String pcdInfo = pcdConsumer.get(i);
1256             if (moduleInfo.equals(pcdInfo.substring(0, pcdInfo.lastIndexOf(" ")))){
1257                 return;
1258             }
1259         }
1260         //
1261         // Using existing Pcd type, if this pcd already exists in other ModuleSA
1262         //
1263         if (pcdConsumer.size() > 0) {
1264
1265             itemType = itemType (pcdConsumer.get(0));
1266         }
1267         String listValue = moduleInfo + " " + itemType;
1268         pcdConsumer.add(listValue);
1269         dynPcdMap.put(cName + " " + tsGuid, pcdConsumer);
1270
1271         PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData fpdPcd = moduleSa.getPcdBuildDefinition().addNewPcdData();
1272         fpdPcd.setCName(cName);
1273         fpdPcd.setToken(token);
1274         fpdPcd.setTokenSpaceGuidCName(tsGuid);
1275         fpdPcd.setDatumType(PcdDataTypes.Enum.forString(dataType));
1276         fpdPcd.setItemType(PcdItemTypes.Enum.forString(itemType));
1277
1278         if (defaultVal != null){
1279             fpdPcd.setValue(defaultVal);
1280         }
1281         else {
1282             if (dataType.equals("UINT8") || dataType.equals("UINT16") || dataType.equals("UINT32") || dataType.equals("UINT64")) {
1283                 fpdPcd.setValue("0");
1284             }
1285             if (dataType.equals("BOOLEAN")){
1286                 fpdPcd.setValue("FALSE");
1287             }
1288             if (dataType.equals("VOID*")) {
1289                 fpdPcd.setValue("");
1290             }
1291         }
1292         //
1293         // Using existing pcd value, if this pcd already exists in other moduleSa.
1294         //
1295         if (defaultPcdValue.get(cName + " " + tsGuid) == null) {
1296             defaultPcdValue.put(cName + " " + tsGuid, fpdPcd.getValue());
1297         }
1298         else {
1299             fpdPcd.setValue(defaultPcdValue.get(cName + " " + tsGuid));
1300         }
1301
1302         if (dataType.equals("UINT8")){
1303             fpdPcd.setMaxDatumSize(1);
1304         }
1305         if (dataType.equals("UINT16")) {
1306             fpdPcd.setMaxDatumSize(2);
1307         }
1308         if (dataType.equals("UINT32")) {
1309             fpdPcd.setMaxDatumSize(4);
1310         }
1311         if (dataType.equals("UINT64")){
1312             fpdPcd.setMaxDatumSize(8);
1313         }
1314         if (dataType.equals("BOOLEAN")){
1315             fpdPcd.setMaxDatumSize(1);
1316         }
1317         if (dataType.equals("VOID*")) {
1318             int maxSize = setMaxSizeForPointer(fpdPcd.getValue());
1319             fpdPcd.setMaxDatumSize(maxSize);
1320         }
1321
1322
1323         if (itemType.equals("DYNAMIC") || itemType.equals("DYNAMIC_EX")) {
1324             ArrayList<String> al = LookupDynamicPcdBuildDefinition(cName + " " + tsGuid);
1325             //
1326             // if only one module mapped to this pcd, then the one is myself. so no other module mapped.
1327             // so need to add one dyn pcd.
1328             //
1329             if (al.size() == 1) {
1330                 addDynamicPcdBuildData(cName, token, tsGuid, itemType, dataType, defaultVal);
1331             }
1332         }
1333
1334     }
1335
1336     public int setMaxSizeForPointer(String datum) throws PcdValueMalFormed{
1337         if (datum == null) {
1338             return 0;
1339         }
1340         char    ch     = datum.charAt(0);
1341         int     start, end;
1342         String  strValue;
1343         //
1344         // For void* type PCD, only three datum is support:
1345         // 1) Unicode: string with start char is "L"
1346         // 2) Ansci: String  is ""
1347         // 3) byte array: String start char "{"
1348         //
1349         if (ch == 'L') {
1350             start       = datum.indexOf('\"');
1351             end         = datum.lastIndexOf('\"');
1352             if ((start > end)           ||
1353                 (end   > datum.length())||
1354                 ((start == end) && (datum.length() > 0))) {
1355                 //ToDo Error handling here
1356                 throw new PcdValueMalFormed (datum);
1357             }
1358
1359             strValue    = datum.substring(start + 1, end);
1360             return strValue.length() * 2;
1361         } else if (ch == '\"'){
1362             start       = datum.indexOf('\"');
1363             end         = datum.lastIndexOf('\"');
1364             if ((start > end)           ||
1365                 (end   > datum.length())||
1366                 ((start == end) && (datum.length() > 0))) {
1367                 throw new PcdValueMalFormed (datum);
1368             }
1369             strValue    = datum.substring(start + 1, end);
1370             return strValue.length();
1371         } else if (ch =='{') {
1372             String[]  strValueArray;
1373
1374             start           = datum.indexOf('{');
1375             end             = datum.lastIndexOf('}');
1376             strValue        = datum.substring(start + 1, end);
1377             strValue        = strValue.trim();
1378             if (strValue.length() == 0) {
1379                 return 0;
1380             }
1381             strValueArray   = strValue.split(",");
1382             for (int index = 0; index < strValueArray.length; index ++) {
1383                     Integer value = Integer.decode(strValueArray[index].trim());
1384
1385                 if (value > 0xFF) {
1386 //                   "[FPD file error] The datum type of PCD %s in %s is VOID*, "+
1387 //                   "it must be a byte array. But the element of %s exceed the byte range",
1388                     throw new PcdValueMalFormed (datum);
1389                 }
1390             }
1391             return strValueArray.length;
1392
1393
1394         } else {
1395 //            "[FPD file error] The datum type of PCD %s in %s is VOID*. For VOID* type, you have three format choise:\n "+
1396 //            "1) UNICODE string: like L\"xxxx\";\r\n"+
1397 //            "2) ANSIC string: like \"xxx\";\r\n"+
1398 //            "3) Byte array: like {0x2, 0x45, 0x23}\r\n"+
1399 //            "but the datum in seems does not following above format!",
1400             throw new PcdValueMalFormed (datum);
1401
1402         }
1403     }
1404
1405     private ArrayList<String> LookupDynamicPcdBuildDefinition(String dynPcdKey) {
1406         ArrayList<String> al = dynPcdMap.get(dynPcdKey);
1407
1408         return al;
1409     }
1410
1411     private ArrayList<String> LookupPlatformPcdData(String pcdKey) {
1412
1413         return dynPcdMap.get(pcdKey);
1414     }
1415
1416     public int getDynamicPcdBuildDataCount() {
1417         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1418             removeElement(getfpdDynPcdBuildDefs());
1419             fpdDynPcdBuildDefs = null;
1420             return 0;
1421         }
1422         return getfpdDynPcdBuildDefs().getPcdBuildDataList().size();
1423     }
1424
1425     public void getDynamicPcdBuildData(String[][] saa) {
1426         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1427             removeElement(getfpdDynPcdBuildDefs());
1428             fpdDynPcdBuildDefs = null;
1429             return ;
1430         }
1431         List<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData> l = getfpdDynPcdBuildDefs().getPcdBuildDataList();
1432         ListIterator<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData> li = l.listIterator();
1433         int i = 0;
1434         while(li.hasNext()) {
1435             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData dynPcd = li.next();
1436             saa[i][0] = dynPcd.getCName();
1437             saa[i][1] = dynPcd.getToken().toString();
1438             saa[i][2] = dynPcd.getTokenSpaceGuidCName();
1439             saa[i][3] = dynPcd.getMaxDatumSize()+"";
1440             saa[i][4] = dynPcd.getDatumType().toString();
1441
1442             ++i;
1443         }
1444     }
1445
1446     public void addDynamicPcdBuildData(String cName, Object token, String tsGuid, String itemType, String dataType, String defaultVal)
1447     throws PcdValueMalFormed{
1448         DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData dynPcdData = getfpdDynPcdBuildDefs().addNewPcdBuildData();
1449         dynPcdData.setItemType(PcdItemTypes.Enum.forString(itemType));
1450         dynPcdData.setCName(cName);
1451         dynPcdData.setToken(token);
1452         dynPcdData.setTokenSpaceGuidCName(tsGuid);
1453         dynPcdData.setDatumType(PcdDataTypes.Enum.forString(dataType));
1454
1455         BigInteger bigInt = new BigInteger("0");
1456         DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = dynPcdData.addNewSkuInfo();
1457         skuInfo.setSkuId(bigInt);
1458         if (defaultVal != null){
1459             skuInfo.setValue(defaultVal);
1460         }
1461         else {
1462             if (dataType.equals("UINT8")){
1463                 skuInfo.setValue("0");
1464             }
1465             if (dataType.equals("UINT16")) {
1466                 skuInfo.setValue("0");
1467             }
1468             if (dataType.equals("UINT32")) {
1469                 skuInfo.setValue("0");
1470             }
1471             if (dataType.equals("UINT64")){
1472                 skuInfo.setValue("0");
1473             }
1474             if (dataType.equals("BOOLEAN")){
1475                 skuInfo.setValue("false");
1476             }
1477             if (dataType.equals("VOID*")) {
1478                 skuInfo.setValue("");
1479             }
1480         }
1481         if (dataType.equals("UINT8")){
1482             dynPcdData.setMaxDatumSize(1);
1483         }
1484         if (dataType.equals("UINT16")) {
1485             dynPcdData.setMaxDatumSize(2);
1486         }
1487         if (dataType.equals("UINT32")) {
1488             dynPcdData.setMaxDatumSize(4);
1489         }
1490         if (dataType.equals("UINT64")){
1491             dynPcdData.setMaxDatumSize(8);
1492         }
1493         if (dataType.equals("BOOLEAN")){
1494             dynPcdData.setMaxDatumSize(1);
1495         }
1496         if (dataType.equals("VOID*")) {
1497             int maxSize = setMaxSizeForPointer(defaultVal);
1498             dynPcdData.setMaxDatumSize(maxSize);
1499         }
1500     }
1501
1502     public void removeDynamicPcdBuildData(String cName, String tsGuid) {
1503         XmlObject o = fpdRoot.getDynamicPcdBuildDefinitions();
1504         if (o == null) {
1505             return;
1506         }
1507
1508         XmlCursor cursor = o.newCursor();
1509         if (cursor.toFirstChild()) {
1510             do {
1511                 DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdBuildData =
1512                     (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1513                 if (pcdBuildData.getCName().equals(cName) && pcdBuildData.getTokenSpaceGuidCName().equals(tsGuid)) {
1514
1515                     if (getDynamicPcdBuildDataCount() == 1) {
1516                         cursor.toParent();
1517                     }
1518                     cursor.removeXml();
1519                     cursor.dispose();
1520                     return;
1521                 }
1522             }
1523             while (cursor.toNextSibling());
1524         }
1525         cursor.dispose();
1526     }
1527     //
1528     // Get the Sku Info count of ith dyn pcd element.
1529     //
1530     public int getDynamicPcdSkuInfoCount(int i){
1531         if (fpdRoot.getDynamicPcdBuildDefinitions() == null || fpdRoot.getDynamicPcdBuildDefinitions().getPcdBuildDataList() == null
1532                         || fpdRoot.getDynamicPcdBuildDefinitions().getPcdBuildDataList().size() == 0) {
1533             return 0;
1534         }
1535
1536         int skuInfoCount = 0;
1537         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1538         if (cursor.toFirstChild()) {
1539             for (int j = 0; j < i; ++j) {
1540                 cursor.toNextSibling();
1541             }
1542             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1543             if (pcdData.getSkuInfoList() == null) {
1544                 skuInfoCount = 0;
1545             }
1546             else {
1547                 skuInfoCount = pcdData.getSkuInfoList().size();
1548             }
1549         }
1550         cursor.dispose();
1551         return skuInfoCount;
1552     }
1553
1554     public void getDynamicPcdSkuInfos(int i, String[][] saa){
1555         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1556             removeElement(getfpdDynPcdBuildDefs());
1557             fpdDynPcdBuildDefs = null;
1558             return;
1559         }
1560
1561         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1562         if (cursor.toFirstChild()) {
1563             for (int j = 0; j < i; ++j) {
1564                 cursor.toNextSibling();
1565             }
1566             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1567             if (pcdData.getSkuInfoList() == null) {
1568                 cursor.dispose();
1569                 return;
1570             }
1571             else {
1572                 ListIterator<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo> li = pcdData.getSkuInfoList().listIterator();
1573                 int k = 0;
1574                 while (li.hasNext()) {
1575                     DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = li.next();
1576                     saa[k][0] = skuInfo.getSkuId()+"";
1577                     saa[k][1] = skuInfo.getVariableName();
1578                     saa[k][2] = skuInfo.getVariableGuid();
1579                     saa[k][3] = skuInfo.getVariableOffset();
1580                     saa[k][4] = skuInfo.getHiiDefaultValue();
1581                     saa[k][5] = skuInfo.getVpdOffset();
1582                     saa[k][6] = skuInfo.getValue();
1583                     ++k;
1584                 }
1585
1586             }
1587         }
1588         cursor.dispose();
1589
1590     }
1591
1592     public String getDynamicPcdBuildDataValue(int i){
1593         String value = null;
1594         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1595             removeElement(getfpdDynPcdBuildDefs());
1596             fpdDynPcdBuildDefs = null;
1597             return value;
1598         }
1599
1600         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1601         if (cursor.toFirstChild()) {
1602             for (int j = 0; j < i; ++j) {
1603                 cursor.toNextSibling();
1604             }
1605             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1606             if (pcdData.getSkuInfoList() == null) {
1607                 value = null;
1608             }
1609             else {
1610                 value = pcdData.getSkuInfoArray(0).getValue();
1611             }
1612         }
1613         cursor.dispose();
1614         return value;
1615     }
1616
1617     public String getDynamicPcdBuildDataVpdOffset(int i){
1618         String vpdOffset = null;
1619         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1620             removeElement(getfpdDynPcdBuildDefs());
1621             fpdDynPcdBuildDefs = null;
1622             return vpdOffset;
1623         }
1624
1625         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1626         if (cursor.toFirstChild()) {
1627             for (int j = 0; j < i; ++j) {
1628                 cursor.toNextSibling();
1629             }
1630             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1631             if (pcdData.getSkuInfoList() == null) {
1632                 vpdOffset = null;
1633             }
1634             else {
1635                 vpdOffset = pcdData.getSkuInfoArray(0).getVpdOffset();
1636             }
1637         }
1638         cursor.dispose();
1639         return vpdOffset;
1640     }
1641
1642     public void removeDynamicPcdBuildDataSkuInfo(int i) {
1643         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1644             removeElement(getfpdDynPcdBuildDefs());
1645             fpdDynPcdBuildDefs = null;
1646             return;
1647         }
1648
1649         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1650         if (cursor.toFirstChild()) {
1651             for (int j = 0; j < i; ++j) {
1652                 cursor.toNextSibling();
1653             }
1654             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1655             if (pcdData.getSkuInfoList() == null) {
1656                 cursor.dispose();
1657                 return;
1658             }
1659             else {
1660                 QName qSkuInfo = new QName(xmlNs, "SkuInfo");
1661                 cursor.toChild(qSkuInfo);
1662                 cursor.removeXml();
1663             }
1664         }
1665         cursor.dispose();
1666     }
1667     //
1668     // generate sku info for ith dyn pcd build data.
1669     //
1670     public void genDynamicPcdBuildDataSkuInfo(String id, String varName, String varGuid, String varOffset,
1671                                               String hiiDefault, String vpdOffset, String value, int i) {
1672 //        if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1673 //            return;
1674 //        }
1675
1676         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1677         if (cursor.toFirstChild()) {
1678             for (int j = 0; j < i; ++j) {
1679                 cursor.toNextSibling();
1680             }
1681             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1682             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = pcdData.addNewSkuInfo();
1683             skuInfo.setSkuId(new BigInteger(id));
1684             if (varName != null){
1685                 skuInfo.setVariableName(varName);
1686                 skuInfo.setVariableGuid(varGuid);
1687                 skuInfo.setVariableOffset(varOffset);
1688                 skuInfo.setHiiDefaultValue(hiiDefault);
1689             }
1690             else if (vpdOffset != null){
1691                 skuInfo.setVpdOffset(vpdOffset);
1692             }
1693             else{
1694                 skuInfo.setValue(value);
1695             }
1696         }
1697     }
1698
1699     public void updateDynamicPcdBuildDataSkuInfo(String id, String varName, String varGuid, String varOffset,
1700                                                  String hiiDefault, String vpdOffset, String value, int i){
1701 //        if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1702 //            return;
1703 //        }
1704
1705         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1706         if (cursor.toFirstChild()) {
1707             for (int j = 0; j < i; ++j) {
1708                 cursor.toNextSibling();
1709             }
1710             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1711             ListIterator<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo> li = pcdData.getSkuInfoList().listIterator();
1712             while (li.hasNext()) {
1713                 DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = li.next();
1714                 if (skuInfo.getSkuId().toString().equals(id)){
1715                     if (varName != null){
1716                         skuInfo.setVariableName(varName);
1717                         skuInfo.setVariableGuid(varGuid);
1718                         skuInfo.setVariableOffset(varOffset);
1719                         skuInfo.setHiiDefaultValue(hiiDefault);
1720                     }
1721                     else if (vpdOffset != null){
1722                         skuInfo.setVpdOffset(vpdOffset);
1723                     }
1724                     else{
1725                         skuInfo.setValue(value);
1726                     }
1727                     break;
1728                 }
1729             }
1730         }
1731     }
1732
1733     public BuildOptionsDocument.BuildOptions getfpdBuildOpts() {
1734         if (fpdBuildOpts == null) {
1735             fpdBuildOpts = fpdRoot.addNewBuildOptions();
1736         }
1737         return fpdBuildOpts;
1738     }
1739
1740     public void genBuildOptionsUserExtensions(String fvName, String outputFileName, Vector<String[]> includeModules) {
1741         QName elementFvName = new QName (xmlNs, "FvName");
1742         QName elementIncludeModules = new QName(xmlNs, "IncludeModules");
1743         QName elementInfFileName = new QName(xmlNs, "InfFileName");
1744         QName elementModule = new QName(xmlNs, "Module");
1745
1746         UserExtensionsDocument.UserExtensions userExts = getfpdBuildOpts().addNewUserExtensions();
1747         userExts.setUserID("IMAGES");
1748         userExts.setIdentifier(new BigInteger("1"));
1749         XmlCursor cursor = userExts.newCursor();
1750         cursor.toEndToken();
1751
1752         cursor.beginElement(elementFvName);
1753         cursor.insertChars(fvName);
1754         cursor.toNextToken();
1755
1756         cursor.beginElement(elementInfFileName);
1757         cursor.insertChars(fvName + ".inf");
1758         cursor.toNextToken();
1759
1760         cursor.beginElement(elementIncludeModules);
1761         for (int i = 0; i < includeModules.size(); ++i) {
1762             cursor.beginElement(elementModule);
1763             cursor.insertAttributeWithValue("ModuleGuid", includeModules.get(i)[0]);
1764             cursor.insertAttributeWithValue("ModuleVersion", includeModules.get(i)[1]);
1765             cursor.insertAttributeWithValue("PackageGuid", includeModules.get(i)[2]);
1766             cursor.insertAttributeWithValue("PackageVersion", includeModules.get(i)[3]);
1767             cursor.insertAttributeWithValue("Arch", includeModules.get(i)[4]);
1768             cursor.toEndToken();
1769             cursor.toNextToken();
1770         }
1771         cursor.dispose();
1772     }
1773
1774     public int getUserExtsIncModCount (String fvName) {
1775         if (getfpdBuildOpts().getUserExtensionsList() == null) {
1776             return -1;
1777         }
1778         ListIterator<UserExtensionsDocument.UserExtensions> li = getfpdBuildOpts().getUserExtensionsList().listIterator();
1779         QName elementIncludeModules = new QName(xmlNs, "IncludeModules");
1780         while (li.hasNext()) {
1781             UserExtensionsDocument.UserExtensions ues = li.next();
1782             if (!ues.getUserID().equals("IMAGES")) {
1783                 continue;
1784             }
1785             XmlCursor cursor = ues.newCursor();
1786             cursor.toFirstChild();
1787             String elementName = cursor.getTextValue();
1788             if (elementName.equals(fvName)) {
1789                 cursor.toNextSibling(elementIncludeModules);
1790                 if (cursor.toFirstChild()) {
1791                     int i = 1;
1792                     for (i = 1; cursor.toNextSibling(); ++i);
1793                     cursor.dispose();
1794                     return i;
1795                 }
1796                 cursor.dispose();
1797                 return 0;
1798             }
1799             cursor.dispose();
1800         }
1801         return -1;
1802     }
1803
1804     public void getUserExtsIncMods(String fvName, String[][] saa) {
1805         if (getfpdBuildOpts().getUserExtensionsList() == null) {
1806             return;
1807         }
1808
1809         XmlCursor cursor = getfpdBuildOpts().newCursor();
1810         QName elementUserExts = new QName (xmlNs, "UserExtensions");
1811         QName attribUserId = new QName ("UserID");
1812         QName elementFvName = new QName (xmlNs, "FvName");
1813         QName elementIncludeModules = new QName(xmlNs, "IncludeModules");
1814         QName attribModuleGuid = new QName("ModuleGuid");
1815         QName attribModuleVersion = new QName("ModuleVersion");
1816         QName attribPackageGuid = new QName("PackageGuid");
1817         QName attribPackageVersion = new QName("PackageVersion");
1818         QName attribArch = new QName("Arch");
1819
1820         if (cursor.toChild(elementUserExts)) {
1821             do {
1822                 cursor.push();
1823                 if (cursor.getAttributeText(attribUserId).equals("IMAGES")) {
1824                     cursor.toChild(elementFvName);
1825                     String elementName = cursor.getTextValue();
1826                     if (elementName.equals(fvName)) {
1827                         cursor.toNextSibling(elementIncludeModules);
1828                         if (cursor.toFirstChild()) {
1829                             int i = 0;
1830                             do {
1831                                 saa[i][0] = cursor.getAttributeText(attribModuleGuid);
1832                                 saa[i][1] = cursor.getAttributeText(attribModuleVersion);
1833                                 saa[i][2] = cursor.getAttributeText(attribPackageGuid);
1834                                 saa[i][3] = cursor.getAttributeText(attribPackageVersion);
1835                                 saa[i][4] = cursor.getAttributeText(attribArch);
1836                                 ++i;
1837                             }while (cursor.toNextSibling());
1838                         }
1839                         break;
1840                     }
1841                 }
1842                 cursor.pop();
1843             }while (cursor.toNextSibling(elementUserExts));
1844         }
1845         cursor.dispose();
1846
1847     }
1848
1849     public void updateBuildOptionsUserExtensions (String oldFvName, String newFvName) {
1850         if (getfpdBuildOpts().getUserExtensionsList() == null) {
1851             return;
1852         }
1853         ListIterator<UserExtensionsDocument.UserExtensions> li = getfpdBuildOpts().getUserExtensionsList().listIterator();
1854         while (li.hasNext()) {
1855             UserExtensionsDocument.UserExtensions ues = li.next();
1856             if (!ues.getUserID().equals("IMAGES")) {
1857                 continue;
1858             }
1859             XmlCursor cursor = ues.newCursor();
1860             cursor.toFirstChild();
1861             String elementName = cursor.getTextValue();
1862             if (elementName.equals(oldFvName)) {
1863                 cursor.setTextValue(newFvName);
1864             }
1865             cursor.dispose();
1866         }
1867
1868     }
1869
1870     public void removeBuildOptionsUserExtensions (String fvName) {
1871         if (getfpdBuildOpts().getUserExtensionsList() == null) {
1872             return;
1873         }
1874
1875         ListIterator<UserExtensionsDocument.UserExtensions> li = getfpdBuildOpts().getUserExtensionsList().listIterator();
1876         while (li.hasNext()) {
1877             UserExtensionsDocument.UserExtensions ues = li.next();
1878             if (!ues.getUserID().equals("IMAGES")) {
1879                 continue;
1880             }
1881             XmlCursor cursor = ues.newCursor();
1882             cursor.toFirstChild();
1883             String elementName = cursor.getTextValue();
1884             if (elementName.equals(fvName)) {
1885                 cursor.toParent();
1886                 cursor.removeXml();
1887                 cursor.dispose();
1888                 return;
1889             }
1890             cursor.dispose();
1891         }
1892
1893     }
1894
1895
1896     public void genBuildOptionsUserDefAntTask (String id, String fileName, String execOrder) {
1897         UserDefinedAntTasksDocument.UserDefinedAntTasks udats = getfpdBuildOpts().getUserDefinedAntTasks();
1898         if (udats == null) {
1899             udats = getfpdBuildOpts().addNewUserDefinedAntTasks();
1900         }
1901
1902         AntTaskDocument.AntTask at = udats.addNewAntTask();
1903         setBuildOptionsUserDefAntTask(id, fileName, execOrder, at);
1904     }
1905
1906     private void setBuildOptionsUserDefAntTask(String id, String fileName, String execOrder, AntTaskDocument.AntTask at) {
1907         at.setId(new Integer(id));
1908         XmlCursor cursor = at.newCursor();
1909         if (fileName != null){
1910             at.setFilename(fileName);
1911         }
1912         else if (cursor.toChild(xmlNs, "Filename")) {
1913             cursor.removeXml();
1914         }
1915         if (execOrder != null) {
1916             at.setAntCmdOptions(execOrder);
1917         }
1918         else if (cursor.toChild(xmlNs, "AntCmdOptions")) {
1919             cursor.removeXml();
1920         }
1921         cursor.dispose();
1922     }
1923
1924     public void removeBuildOptionsUserDefAntTask(int i) {
1925         XmlObject o = getfpdBuildOpts().getUserDefinedAntTasks();
1926         if (o == null) {
1927             return;
1928         }
1929         XmlCursor cursor = o.newCursor();
1930         if (cursor.toFirstChild()) {
1931             for (int j = 0; j < i; ++j) {
1932                 cursor.toNextSibling();
1933             }
1934             cursor.removeXml();
1935             if (getBuildOptionsUserDefAntTaskCount() == 0) {
1936                 cursor.toParent();
1937                 cursor.removeXml();
1938             }
1939         }
1940         cursor.dispose();
1941     }
1942
1943     public void updateBuildOptionsUserDefAntTask(int i, String id, String fileName, String execOrder){
1944         XmlObject o = getfpdBuildOpts().getUserDefinedAntTasks();
1945         if (o == null) {
1946             return;
1947         }
1948         XmlCursor cursor = o.newCursor();
1949         if (cursor.toFirstChild()) {
1950             for (int j = 0; j < i; ++j) {
1951                 cursor.toNextSibling();
1952             }
1953             AntTaskDocument.AntTask at = (AntTaskDocument.AntTask)cursor.getObject();
1954             setBuildOptionsUserDefAntTask(id, fileName, execOrder, at);
1955         }
1956         cursor.dispose();
1957     }
1958
1959     public int getBuildOptionsUserDefAntTaskCount() {
1960         UserDefinedAntTasksDocument.UserDefinedAntTasks udats = getfpdBuildOpts().getUserDefinedAntTasks();
1961         if (udats == null || udats.getAntTaskList() == null) {
1962             return 0;
1963         }
1964
1965         return udats.getAntTaskList().size();
1966     }
1967
1968     public void getBuildOptionsUserDefAntTasks(String[][] saa) {
1969         UserDefinedAntTasksDocument.UserDefinedAntTasks udats = getfpdBuildOpts().getUserDefinedAntTasks();
1970         if (udats == null || udats.getAntTaskList() == null) {
1971             return ;
1972         }
1973
1974         List<AntTaskDocument.AntTask> l = udats.getAntTaskList();
1975         ListIterator li = l.listIterator();
1976         int i = 0;
1977         while (li.hasNext()) {
1978             AntTaskDocument.AntTask at = (AntTaskDocument.AntTask)li.next();
1979             saa[i][0] = at.getId() + "";
1980             saa[i][1] = saa[i][2] = "";
1981             if (at.getFilename() != null){
1982                 saa[i][1] = at.getFilename();
1983             }
1984             if (at.getAntCmdOptions() != null) {
1985                 saa[i][2] = at.getAntCmdOptions();
1986             }
1987             ++i;
1988         }
1989     }
1990     public void genBuildOptionsOpt(Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
1991         OptionsDocument.Options opts = getfpdBuildOpts().getOptions();
1992         if (opts == null) {
1993             opts = getfpdBuildOpts().addNewOptions();
1994         }
1995         OptionDocument.Option opt = opts.addNewOption();
1996         setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
1997     }
1998
1999     private void setBuildOptionsOpt(Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents, OptionDocument.Option opt){
2000         opt.setStringValue(contents);
2001
2002         opt.setBuildTargets(buildTargets);
2003         opt.setToolChainFamily(toolChain);
2004         opt.setTagName(tagName);
2005         opt.setToolCode(toolCmd);
2006
2007         if (archList != null) {
2008             opt.setSupArchList(archList);
2009         }
2010         else {
2011             if (opt.isSetSupArchList()) {
2012                 opt.unsetSupArchList();
2013             }
2014         }
2015     }
2016
2017     public void removeBuildOptionsOpt(int i){
2018
2019         XmlObject o = getfpdBuildOpts().getOptions();
2020         if (o == null) {
2021             return;
2022         }
2023
2024         XmlCursor cursor = o.newCursor();
2025         if (cursor.toFirstChild()) {
2026             for (int j = 0; j < i; ++j) {
2027                 cursor.toNextSibling();
2028             }
2029             cursor.removeXml();
2030             if (getBuildOptionsOptCount() == 0) {
2031                 cursor.toParent();
2032                 cursor.removeXml();
2033             }
2034         }
2035         cursor.dispose();
2036     }
2037
2038     public void updateBuildOptionsOpt(int i, Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
2039         XmlObject o = getfpdBuildOpts().getOptions();
2040         if (o == null) {
2041             return;
2042         }
2043
2044         XmlCursor cursor = o.newCursor();
2045         if (cursor.toFirstChild()) {
2046             for (int j = 0; j < i; ++j) {
2047                 cursor.toNextSibling();
2048             }
2049             OptionDocument.Option opt = (OptionDocument.Option)cursor.getObject();
2050             setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
2051         }
2052         cursor.dispose();
2053     }
2054
2055     public int getBuildOptionsOptCount(){
2056         if (getfpdBuildOpts().getOptions() == null || getfpdBuildOpts().getOptions().getOptionList() == null) {
2057             return 0;
2058         }
2059         return getfpdBuildOpts().getOptions().getOptionList().size();
2060     }
2061
2062     public void getBuildOptionsOpts(String[][] saa) {
2063         if (getfpdBuildOpts().getOptions() == null || getfpdBuildOpts().getOptions().getOptionList() == null) {
2064             return ;
2065         }
2066
2067         List<OptionDocument.Option> lOpt = getfpdBuildOpts().getOptions().getOptionList();
2068         ListIterator li = lOpt.listIterator();
2069         int i = 0;
2070         while(li.hasNext()) {
2071             OptionDocument.Option opt = (OptionDocument.Option)li.next();
2072             if (opt.getBuildTargets() != null) {
2073                 saa[i][0] = listToString(opt.getBuildTargets());
2074             }
2075             saa[i][1] = opt.getToolChainFamily();
2076             if (opt.getSupArchList() != null){
2077                 saa[i][2] = listToString(opt.getSupArchList());
2078
2079             }
2080             saa[i][3] = opt.getToolCode();
2081             saa[i][4] = opt.getTagName();
2082             saa[i][5] = opt.getStringValue();
2083
2084             ++i;
2085         }
2086     }
2087
2088     public void genBuildOptionsFfs(String ffsKey, String type) {
2089         BuildOptionsDocument.BuildOptions.Ffs ffs = getfpdBuildOpts().addNewFfs();
2090         ffs.setFfsKey(ffsKey);
2091         if (type != null) {
2092             ffs.addNewSections().setEncapsulationType(type);
2093         }
2094     }
2095
2096     public void updateBuildOptionsFfsSectionsType(int i, String type) {
2097         BuildOptionsDocument.BuildOptions.Ffs ffs = getfpdBuildOpts().addNewFfs();
2098         if (type != null) {
2099             ffs.addNewSections().setEncapsulationType(type);
2100         }
2101     }
2102
2103     public void genBuildOptionsFfsAttribute(int i, String name, String value) {
2104         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2105         BuildOptionsDocument.BuildOptions.Ffs.Attribute attrib = ffs.addNewAttribute();
2106         attrib.setName(name);
2107         attrib.setValue(value);
2108     }
2109
2110     /**update jth attribute of ith ffs.
2111      * @param i
2112      * @param j
2113      */
2114     public void updateBuildOptionsFfsAttribute(int i, int j, String name, String value){
2115         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2116         XmlCursor cursor = ffs.newCursor();
2117         QName qAttrib = new QName(xmlNs, "Attribute");
2118         if (cursor.toChild(qAttrib)) {
2119             for (int k = 0; k < j; ++k) {
2120                 cursor.toNextSibling(qAttrib);
2121             }
2122             BuildOptionsDocument.BuildOptions.Ffs.Attribute attrib = (BuildOptionsDocument.BuildOptions.Ffs.Attribute)cursor.getObject();
2123             attrib.setName(name);
2124             attrib.setValue(value);
2125         }
2126         cursor.dispose();
2127     }
2128
2129     public void removeBuildOptionsFfsAttribute(int i, int j){
2130         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2131         XmlCursor cursor = ffs.newCursor();
2132         QName qAttrib = new QName(xmlNs, "Attribute");
2133         if (cursor.toChild(qAttrib)) {
2134             for (int k = 0; k < j; ++k) {
2135                 cursor.toNextSibling(qAttrib);
2136             }
2137             cursor.removeXml();
2138         }
2139         cursor.dispose();
2140     }
2141
2142     public void genBuildOptionsFfsSectionsSection(int i, String sectionType) {
2143         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2144         if (ffs == null) {
2145             return;
2146         }
2147         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2148
2149         if (sections == null){
2150             sections = ffs.addNewSections();
2151         }
2152         sections.addNewSection().setSectionType(EfiSectionType.Enum.forString(sectionType));
2153     }
2154
2155     public void removeBuildOptionsFfsSectionsSection(int i, int j) {
2156         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2157         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2158         if (sections == null) {
2159             return;
2160         }
2161         XmlCursor cursor = sections.newCursor();
2162         QName qSection = new QName(xmlNs, "Section");
2163         if (cursor.toChild(qSection)) {
2164             for (int k = 0; k < j; ++k) {
2165                 cursor.toNextSibling(qSection);
2166             }
2167             cursor.removeXml();
2168         }
2169         cursor.dispose();
2170     }
2171
2172     public void updateBuildOptionsFfsSectionsSection(int i, int j, String type){
2173         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2174         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2175         if (sections == null) {
2176             return;
2177         }
2178         XmlCursor cursor = sections.newCursor();
2179         QName qSection = new QName(xmlNs, "Section");
2180         if (cursor.toChild(qSection)) {
2181             for (int k = 0; k < j; ++k) {
2182                 cursor.toNextSibling(qSection);
2183             }
2184             BuildOptionsDocument.BuildOptions.Ffs.Sections.Section section = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Section)cursor.getObject();
2185             section.setSectionType(EfiSectionType.Enum.forString(type));
2186         }
2187         cursor.dispose();
2188     }
2189
2190     public void genBuildOptionsFfsSectionsSections(int i, String encapType) {
2191         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2192         if (ffs == null) {
2193             return;
2194         }
2195         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2196
2197         if (sections == null){
2198             sections = ffs.addNewSections();
2199         }
2200         sections.addNewSections().setEncapsulationType(encapType);
2201     }
2202
2203     public void removeBuildOptionsFfsSectionsSections(int i, int j) {
2204         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2205         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2206         if (sections == null) {
2207             return;
2208         }
2209         XmlCursor cursor = sections.newCursor();
2210         QName qSections = new QName(xmlNs, "Sections");
2211         if (cursor.toChild(qSections)) {
2212             for (int k = 0; k < j; ++k) {
2213                 cursor.toNextSibling(qSections);
2214             }
2215             cursor.removeXml();
2216         }
2217         cursor.dispose();
2218     }
2219
2220     public void updateBuildOptionsFfsSectionsSections(int i, int j, String type) {
2221         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2222         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2223         if (sections == null) {
2224             return;
2225         }
2226         XmlCursor cursor = sections.newCursor();
2227         QName qSections = new QName(xmlNs, "Sections");
2228         if (cursor.toChild(qSections)) {
2229             for (int k = 0; k < j; ++k) {
2230                 cursor.toNextSibling(qSections);
2231             }
2232             BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2 sections2 = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2)cursor.getObject();
2233             sections2.setEncapsulationType(type);
2234         }
2235         cursor.dispose();
2236     }
2237
2238     public void genBuildOptionsFfsSectionsSectionsSection(int i, int j, String type) {
2239         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2240         if (ffs == null) {
2241             return;
2242         }
2243         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2244         XmlCursor cursor = sections.newCursor();
2245         QName qSections = new QName(xmlNs, "Sections");
2246         if (cursor.toChild(qSections)){
2247             for (int k = 0; k < j; ++k) {
2248                 cursor.toNextSibling(qSections);
2249             }
2250             BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2 sections2 = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2)cursor.getObject();
2251             sections2.addNewSection().setSectionType(EfiSectionType.Enum.forString(type));
2252         }
2253         cursor.dispose();
2254     }
2255
2256     public void removeBuildOptionsFfsSectionsSectionsSection(int i, int j, int k) {
2257         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2258         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2259         if (sections == null) {
2260             return;
2261         }
2262         XmlCursor cursor = sections.newCursor();
2263         QName qSections = new QName(xmlNs, "Sections");
2264         if (cursor.toChild(qSections)) {
2265             for (int l = 0; l < j; ++l) {
2266                 cursor.toNextSibling(qSections);
2267             }
2268             if (cursor.toFirstChild()) {
2269                 int m = 0;
2270                 for (; m < k; ++m) {
2271                     cursor.toNextSibling();
2272                 }
2273                 cursor.removeXml();
2274                 if (m == 0) {
2275                     cursor.toParent();
2276                     cursor.removeXml();
2277                 }
2278             }
2279         }
2280         cursor.dispose();
2281     }
2282
2283     public void updateBuildOptionsFfsSectionsSectionsSection(int i, int j, int k, String type) {
2284         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2285         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2286         if (sections == null) {
2287             return;
2288         }
2289         XmlCursor cursor = sections.newCursor();
2290         QName qSections = new QName(xmlNs, "Sections");
2291         if (cursor.toChild(qSections)) {
2292             for (int l = 0; l < j; ++l) {
2293                 cursor.toNextSibling(qSections);
2294             }
2295             if (cursor.toFirstChild()) {
2296                 for (int m = 0; m < k; ++m) {
2297                     cursor.toNextSibling();
2298                 }
2299                 BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section section = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section)cursor.getObject();
2300                 section.setSectionType(EfiSectionType.Enum.forString(type));
2301             }
2302         }
2303         cursor.dispose();
2304     }
2305
2306     public void getBuildOptionsFfsSectionsSectionsSection(int i, int j, ArrayList<String> al) {
2307         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2308         if (ffs == null) {
2309             return;
2310         }
2311         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
2312         XmlCursor cursor = sections.newCursor();
2313         QName qSections = new QName(xmlNs, "Sections");
2314         if (cursor.toChild(qSections)){
2315             for (int k = 0; k < j; ++k) {
2316                 cursor.toNextSibling(qSections);
2317             }
2318             BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2 sections2 = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2)cursor.getObject();
2319             if (sections2.getSectionList() == null){
2320                 cursor.dispose();
2321                 return;
2322             }
2323             ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section> li = sections2.getSectionList().listIterator();
2324             while(li.hasNext()) {
2325                 BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section section = li.next();
2326                 if (section.isSetSectionType()) {
2327                     al.add(section.getSectionType().toString());
2328                 }
2329
2330             }
2331         }
2332         cursor.dispose();
2333
2334     }
2335
2336     public int getBuildOptionsFfsCount(){
2337         if (getfpdBuildOpts().getFfsList() == null) {
2338             return 0;
2339         }
2340         return getfpdBuildOpts().getFfsList().size();
2341     }
2342
2343     public void getBuildOptionsFfsKey(String[][] saa) {
2344         if (getfpdBuildOpts().getFfsList() == null) {
2345             return;
2346         }
2347         ListIterator<BuildOptionsDocument.BuildOptions.Ffs> li = getfpdBuildOpts().getFfsList().listIterator();
2348         int i = 0;
2349         while(li.hasNext()){
2350             BuildOptionsDocument.BuildOptions.Ffs ffs = li.next();
2351             saa[i][0] = ffs.getFfsKey();
2352             ++i;
2353         }
2354     }
2355
2356     public void updateBuildOptionsFfsKey(int i, String key) {
2357         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2358         ffs.setFfsKey(key);
2359     }
2360
2361     /**Get ith FFS key and contents.
2362      * @param saa
2363      */
2364     public void getBuildOptionsFfs(int i, String[] sa, LinkedHashMap<String, String> ffsAttribMap, ArrayList<String> firstLevelSections, ArrayList<String> firstLevelSection) {
2365         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2366
2367         if (ffs != null) {
2368
2369             sa[0] = ffs.getFfsKey();
2370             if (ffs.getSections() != null) {
2371                 if(ffs.getSections().getEncapsulationType() != null){
2372                     sa[1] = ffs.getSections().getEncapsulationType();
2373                 }
2374                 if (ffs.getSections().getSectionList() != null){
2375                     ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Sections.Section> li = ffs.getSections().getSectionList().listIterator();
2376                     while (li.hasNext()) {
2377                         firstLevelSection.add(li.next().getSectionType().toString());
2378                     }
2379                 }
2380                 if (ffs.getSections().getSectionsList() != null) {
2381                     ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2> li = ffs.getSections().getSectionsList().listIterator();
2382                     while(li.hasNext()) {
2383                         firstLevelSections.add(li.next().getEncapsulationType());
2384                     }
2385                 }
2386             }
2387             if (ffs.getAttributeList() != null) {
2388                 ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Attribute> li = ffs.getAttributeList().listIterator();
2389                 while(li.hasNext()) {
2390                     BuildOptionsDocument.BuildOptions.Ffs.Attribute attrib = li.next();
2391                     ffsAttribMap.put(attrib.getName(), attrib.getValue());
2392                 }
2393
2394             }
2395         }
2396
2397
2398     }
2399
2400     private BuildOptionsDocument.BuildOptions.Ffs getFfs(int i) {
2401         XmlObject o = getfpdBuildOpts();
2402         BuildOptionsDocument.BuildOptions.Ffs ffs = null;
2403
2404         XmlCursor cursor = o.newCursor();
2405         QName qFfs = new QName(xmlNs, "Ffs");
2406         if (cursor.toChild(qFfs)) {
2407             for (int j = 0; j < i; ++j) {
2408                 cursor.toNextSibling(qFfs);
2409             }
2410             ffs = (BuildOptionsDocument.BuildOptions.Ffs)cursor.getObject();
2411         }
2412         cursor.dispose();
2413         return ffs;
2414     }
2415
2416     public void removeBuildOptionsFfs(int i) {
2417         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
2418         if (ffs == null){
2419             return;
2420         }
2421
2422         XmlCursor cursor = ffs.newCursor();
2423         cursor.removeXml();
2424         cursor.dispose();
2425     }
2426
2427
2428
2429     public PlatformDefinitionsDocument.PlatformDefinitions getfpdPlatformDefs(){
2430         if (fpdPlatformDefs == null){
2431             fpdPlatformDefs = fpdRoot.addNewPlatformDefinitions();
2432         }
2433         return fpdPlatformDefs;
2434     }
2435
2436     public void getPlatformDefsSupportedArchs(Vector<Object> archs){
2437         if (getfpdPlatformDefs().getSupportedArchitectures() == null) {
2438             return;
2439         }
2440         ListIterator li = getfpdPlatformDefs().getSupportedArchitectures().listIterator();
2441         while(li.hasNext()) {
2442             archs.add(li.next());
2443         }
2444     }
2445
2446     public void setPlatformDefsSupportedArchs(Vector<Object> archs) {
2447         if (archs != null) {
2448             getfpdPlatformDefs().setSupportedArchitectures(archs);
2449         }
2450 //        else {
2451 //            XmlCursor cursor = getfpdPlatformDefs().newCursor();
2452 //            if (cursor.toChild(xmlNs, "SupportedArchitectures")) {
2453 //                cursor.removeXml();
2454 //            }
2455 //            cursor.dispose();
2456 //        }
2457     }
2458
2459     public void getPlatformDefsBuildTargets(Vector<Object> targets) {
2460         if (getfpdPlatformDefs().getBuildTargets() == null) {
2461             return;
2462         }
2463         ListIterator li = getfpdPlatformDefs().getBuildTargets().listIterator();
2464         while(li.hasNext()) {
2465             targets.add(li.next());
2466         }
2467     }
2468
2469     public void setPlatformDefsBuildTargets(Vector<Object> targets) {
2470         getfpdPlatformDefs().setBuildTargets(targets);
2471     }
2472
2473     public void genPlatformDefsSkuInfo(String id, String name) {
2474         SkuInfoDocument.SkuInfo skuInfo = null;
2475         if (getfpdPlatformDefs().getSkuInfo() == null) {
2476             skuInfo = getfpdPlatformDefs().addNewSkuInfo();
2477         }
2478         skuInfo = getfpdPlatformDefs().getSkuInfo();
2479         if (skuInfo.getUiSkuNameList() == null || skuInfo.getUiSkuNameList().size() == 0) {
2480             SkuInfoDocument.SkuInfo.UiSkuName skuName = skuInfo.addNewUiSkuName();
2481             skuName.setSkuID(new BigInteger("0"));
2482             skuName.setStringValue("DEFAULT");
2483         }
2484         if (id.equals("0")) {
2485             return;
2486         }
2487         SkuInfoDocument.SkuInfo.UiSkuName skuName = skuInfo.addNewUiSkuName();
2488         skuName.setSkuID(new BigInteger(id));
2489         skuName.setStringValue(name);
2490     }
2491
2492     public int getPlatformDefsSkuInfoCount(){
2493         if (getfpdPlatformDefs().getSkuInfo() == null || getfpdPlatformDefs().getSkuInfo().getUiSkuNameList() == null) {
2494             return 0;
2495         }
2496         return getfpdPlatformDefs().getSkuInfo().getUiSkuNameList().size();
2497     }
2498
2499     public void getPlatformDefsSkuInfos(String[][] saa){
2500         if (getfpdPlatformDefs().getSkuInfo() == null || getfpdPlatformDefs().getSkuInfo().getUiSkuNameList() == null) {
2501             if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null) {
2502                 removeElement(getfpdDynPcdBuildDefs());
2503                 fpdDynPcdBuildDefs = null;
2504             }
2505             return ;
2506         }
2507
2508         List<SkuInfoDocument.SkuInfo.UiSkuName> l = getfpdPlatformDefs().getSkuInfo().getUiSkuNameList();
2509         ListIterator<SkuInfoDocument.SkuInfo.UiSkuName> li = l.listIterator();
2510         int i = 0;
2511         while(li.hasNext()) {
2512             SkuInfoDocument.SkuInfo.UiSkuName sku = li.next();
2513             saa[i][0] = sku.getSkuID()+"";
2514             saa[i][1] = sku.getStringValue();
2515             ++i;
2516         }
2517     }
2518
2519     public void removePlatformDefsSkuInfo(int i) {
2520         SkuInfoDocument.SkuInfo skuInfo = getfpdPlatformDefs().getSkuInfo();
2521         if (skuInfo == null || i == 0) {
2522             return ;
2523         }
2524
2525         XmlCursor cursor = skuInfo.newCursor();
2526         if (cursor.toFirstChild()) {
2527             for (int j = 0; j < i; ++j) {
2528                 cursor.toNextSibling();
2529             }
2530             cursor.removeXml();
2531         }
2532         cursor.dispose();
2533     }
2534
2535     public void updatePlatformDefsSkuInfo(int i, String id, String name) {
2536         SkuInfoDocument.SkuInfo skuInfo = getfpdPlatformDefs().getSkuInfo();
2537         if (skuInfo == null || i == 0) {
2538             return ;
2539         }
2540
2541         XmlCursor cursor = skuInfo.newCursor();
2542         if (cursor.toFirstChild()) {
2543             for (int j = 0; j < i; ++j) {
2544                 cursor.toNextSibling();
2545             }
2546             SkuInfoDocument.SkuInfo.UiSkuName sku = (SkuInfoDocument.SkuInfo.UiSkuName)cursor.getObject();
2547             sku.setSkuID(new BigInteger(id));
2548             sku.setStringValue(name);
2549         }
2550         cursor.dispose();
2551     }
2552
2553     public String getPlatformDefsInterDir(){
2554         if (getfpdPlatformDefs().getIntermediateDirectories() == null) {
2555             return null;
2556         }
2557         return getfpdPlatformDefs().getIntermediateDirectories().toString();
2558     }
2559
2560     public void setPlatformDefsInterDir(String interDir){
2561         getfpdPlatformDefs().setIntermediateDirectories(IntermediateOutputType.Enum.forString(interDir));
2562     }
2563
2564     public String getPlatformDefsOutputDir() {
2565         return getfpdPlatformDefs().getOutputDirectory();
2566     }
2567
2568     public void setPlatformDefsOutputDir(String outputDir) {
2569         if (outputDir != null && outputDir.length() > 0) {
2570             getfpdPlatformDefs().setOutputDirectory(outputDir);
2571         }
2572         else{
2573             XmlCursor cursor = getfpdPlatformDefs().newCursor();
2574             if (cursor.toChild(new QName(xmlNs, "OutputDirectory"))) {
2575                 cursor.removeXml();
2576             }
2577             cursor.dispose();
2578         }
2579     }
2580
2581     public FlashDocument.Flash getfpdFlash() {
2582         if (fpdFlash == null) {
2583             fpdFlash = fpdRoot.addNewFlash();
2584         }
2585         return fpdFlash;
2586     }
2587
2588     public void genFlashDefinitionFile(String file) {
2589         FlashDefinitionFileDocument.FlashDefinitionFile fdf = getfpdFlash().getFlashDefinitionFile();
2590         if (fdf == null) {
2591             fdf = getfpdFlash().addNewFlashDefinitionFile();
2592         }
2593
2594         fdf.setStringValue(file);
2595     }
2596
2597     public String getFlashDefinitionFile() {
2598         FlashDefinitionFileDocument.FlashDefinitionFile fdf = getfpdFlash().getFlashDefinitionFile();
2599         if (fdf == null) {
2600             return "";
2601         }
2602
2603         return fdf.getStringValue();
2604     }
2605
2606     public void genFvImagesNameValue(String name, String value) {
2607
2608         FvImagesDocument.FvImages fi = getfpdFlash().getFvImages();
2609         if (fi == null) {
2610             fi = getfpdFlash().addNewFvImages();
2611         }
2612
2613         FvImagesDocument.FvImages.NameValue nv = fi.addNewNameValue();
2614         nv.setName(name);
2615         nv.setValue(value);
2616     }
2617
2618     public void removeFvImagesNameValue(int i){
2619
2620         XmlObject o = getfpdFlash().getFvImages();
2621         if (o == null) {
2622             return;
2623         }
2624
2625         QName qNameValue = new QName(xmlNs, "NameValue");
2626         XmlCursor cursor = o.newCursor();
2627         if (cursor.toChild(qNameValue)) {
2628             for (int j = 0; j < i; ++j) {
2629                 cursor.toNextSibling(qNameValue);
2630             }
2631             cursor.removeXml();
2632         }
2633         cursor.dispose();
2634     }
2635
2636     public void updateFvImagesNameValue(int i, String name, String value){
2637
2638         XmlObject o = getfpdFlash().getFvImages();
2639         if (o == null) {
2640             return;
2641         }
2642
2643         QName qNameValue = new QName(xmlNs, "NameValue");
2644         XmlCursor cursor = o.newCursor();
2645         if (cursor.toChild(qNameValue)) {
2646             for (int j = 0; j < i; ++j) {
2647                 cursor.toNextSibling(qNameValue);
2648             }
2649             FvImagesDocument.FvImages.NameValue nv = (FvImagesDocument.FvImages.NameValue)cursor.getObject();
2650             nv.setName(name);
2651             nv.setValue(value);
2652         }
2653         cursor.dispose();
2654     }
2655
2656     public int getFvImagesNameValueCount() {
2657
2658         FvImagesDocument.FvImages fi = null;
2659         if ((fi = getfpdFlash().getFvImages()) == null || fi.getNameValueList() == null) {
2660             return 0;
2661         }
2662         return fi.getNameValueList().size();
2663     }
2664
2665     public void getFvImagesNameValues(String[][] nv) {
2666
2667         FvImagesDocument.FvImages fi = getfpdFlash().getFvImages();
2668         if (fi == null){
2669             return;
2670         }
2671         List<FvImagesDocument.FvImages.NameValue> l = fi.getNameValueList();
2672         int i = 0;
2673         ListIterator li = l.listIterator();
2674         while (li.hasNext()) {
2675             FvImagesDocument.FvImages.NameValue e = (FvImagesDocument.FvImages.NameValue) li
2676                                                                                                                     .next();
2677             nv[i][0] = e.getName();
2678             nv[i][1] = e.getValue();
2679
2680             i++;
2681         }
2682     }
2683
2684     public void getFvImagesFvImageFvImageNames (Vector<String> vImageNames) {
2685         FvImagesDocument.FvImages fis = getfpdFlash().getFvImages();
2686         if (fis == null || fis.getFvImageList() == null) {
2687             return;
2688         }
2689
2690         ListIterator<FvImagesDocument.FvImages.FvImage> li = fis.getFvImageList().listIterator();
2691         while (li.hasNext()) {
2692             FvImagesDocument.FvImages.FvImage fi = li.next();
2693             if (fi.getType().toString().equals("ImageName")) {
2694                 vImageNames.addAll(fi.getFvImageNamesList());
2695                 return;
2696             }
2697         }
2698     }
2699
2700     public void addFvImageFvImageNames (String[] fvNames) {
2701         FvImagesDocument.FvImages fis = getfpdFlash().getFvImages();
2702         if (fis == null || fis.getFvImageList() == null) {
2703             genFvImagesFvImage (fvNames, "ImageName", null);
2704             return;
2705         }
2706
2707         ListIterator<FvImagesDocument.FvImages.FvImage> li = fis.getFvImageList().listIterator();
2708         while (li.hasNext()) {
2709             FvImagesDocument.FvImages.FvImage fi = li.next();
2710             if (fi.getType().toString().equals("ImageName")) {
2711                 addFvImageNamesInFvImage (fi, fvNames);
2712                 return;
2713             }
2714         }
2715         genFvImagesFvImage (fvNames, "ImageName", null);
2716     }
2717
2718     public void addFvImageNamesInFvImage (FvImagesDocument.FvImages.FvImage fi, String[] fvNames) {
2719
2720         for (int i = 0; i < fvNames.length; ++i) {
2721             fi.addFvImageNames(fvNames[i]);
2722         }
2723     }
2724
2725     public void addFvImageNamesInFvImage (int i, String[] fvNames) {
2726         XmlObject o = getfpdFlash().getFvImages();
2727         if (o == null) {
2728             return;
2729         }
2730         XmlCursor cursor = o.newCursor();
2731         QName qFvImage = new QName(xmlNs, "FvImage");
2732         if (cursor.toChild(qFvImage)) {
2733             for (int j = 0; j < i; ++j) {
2734                 cursor.toNextSibling(qFvImage);
2735             }
2736             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
2737             addFvImageNamesInFvImage(fi, fvNames);
2738         }
2739         cursor.dispose();
2740     }
2741
2742     public void genFvImagesFvImage(String[] names, String types, Map<String, String> options) {
2743
2744         FvImagesDocument.FvImages fis = null;
2745         if ((fis = getfpdFlash().getFvImages()) == null) {
2746             fis = getfpdFlash().addNewFvImages();
2747         }
2748
2749         //
2750         //gen FvImage with FvImageNames array
2751         //
2752         FvImagesDocument.FvImages.FvImage fi = fis.addNewFvImage();
2753         for (int i = 0; i < names.length; ++i) {
2754             fi.addFvImageNames(names[i]);
2755         }
2756         fi.setType(FvImageTypes.Enum.forString(types));
2757         if (options != null){
2758             setFvImagesFvImageFvImageOptions(options, fi);
2759         }
2760     }
2761
2762     private void setFvImagesFvImageFvImageOptions(Map<String, String> options, FvImagesDocument.FvImages.FvImage fi){
2763         FvImagesDocument.FvImages.FvImage.FvImageOptions fio = fi.getFvImageOptions();
2764         if (fio == null){
2765             fio = fi.addNewFvImageOptions();
2766         }
2767
2768         Set<String> key = options.keySet();
2769         Iterator<String> i = key.iterator();
2770         while (i.hasNext()) {
2771
2772             FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = fio.addNewNameValue();
2773             String k = (String)i.next();
2774
2775             nv.setName(k);
2776             nv.setValue((String)options.get(k));
2777
2778         }
2779
2780     }
2781
2782
2783     public void removeFvImagesFvImage(int i) {
2784
2785         XmlObject o = getfpdFlash().getFvImages();
2786         if (o == null) {
2787             return;
2788         }
2789
2790         QName qFvImage = new QName(xmlNs, "FvImage");
2791         XmlCursor cursor = o.newCursor();
2792         if (cursor.toChild(qFvImage)) {
2793             for (int j = 0; j < i; ++j) {
2794                 cursor.toNextSibling(qFvImage);
2795             }
2796             cursor.removeXml();
2797         }
2798         cursor.dispose();
2799     }
2800
2801     /**
2802      * @param oldFvName
2803      * @param newFvName The New FV Name. If null, remove the old FvImageNames entry.
2804      */
2805     public void updateFvImageNameAll (String oldFvName, String newFvName) {
2806         if (getfpdFlash().getFvImages() == null || getfpdFlash().getFvImages().getFvImageList() == null) {
2807             return;
2808         }
2809         ListIterator<FvImagesDocument.FvImages.FvImage> li = getfpdFlash().getFvImages().getFvImageList().listIterator();
2810         while (li.hasNext()) {
2811             FvImagesDocument.FvImages.FvImage fi = li.next();
2812             updateFvImageNamesInFvImage (fi, oldFvName, newFvName);
2813             if (fi.getFvImageNamesList().size() == 0) {
2814                 li.remove();
2815             }
2816         }
2817     }
2818
2819     public void updateFvImageNamesInFvImage (int i, String oldFvName, String newFvName) {
2820         XmlObject o = getfpdFlash().getFvImages();
2821         if (o == null) {
2822             return;
2823         }
2824         XmlCursor cursor = o.newCursor();
2825         QName qFvImage = new QName(xmlNs, "FvImage");
2826         if (cursor.toChild(qFvImage)) {
2827             for (int j = 0; j < i; ++j) {
2828                 cursor.toNextSibling(qFvImage);
2829             }
2830             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
2831             updateFvImageNamesInFvImage (fi, oldFvName, newFvName);
2832         }
2833         cursor.dispose();
2834     }
2835     /**
2836      * @param fi
2837      * @param oldFvName The FV Name to be replaced.
2838      * @param newFvName The New FV Name. If null, remove the old FvImageNames entry.
2839      */
2840     public void updateFvImageNamesInFvImage (FvImagesDocument.FvImages.FvImage fi, String oldFvName, String newFvName) {
2841         QName qFvImageNames = new QName(xmlNs, "FvImageNames");
2842         XmlCursor cursor = fi.newCursor();
2843
2844         if (cursor.toChild(qFvImageNames)) {
2845             do {
2846                 String xmlValue = cursor.getTextValue();
2847                 if (xmlValue.equals(oldFvName)){
2848                     if (newFvName != null) {
2849                         cursor.setTextValue(newFvName);
2850                     }
2851                     else {
2852                         cursor.removeXml();
2853                     }
2854                 }
2855             }while (cursor.toNextSibling(qFvImageNames));
2856         }
2857
2858         cursor.dispose();
2859     }
2860
2861     /**update the Type attribute of ith FvImage with new type.
2862      * @param i
2863      * @param type
2864      */
2865     public void updateFvImagesFvImageType (int i, String type) {
2866         XmlObject o = getfpdFlash().getFvImages();
2867         if (o == null) {
2868             return;
2869         }
2870         XmlCursor cursor = o.newCursor();
2871         QName qFvImage = new QName(xmlNs, "FvImage");
2872         if (cursor.toChild(qFvImage)) {
2873             for (int j = 0; j < i; ++j) {
2874                 cursor.toNextSibling(qFvImage);
2875             }
2876             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
2877             fi.setType(FvImageTypes.Enum.forString(type));
2878         }
2879         cursor.dispose();
2880     }
2881
2882     public void updateFvImagesFvImage(int i, String[] names, String types, Map<String, String> options){
2883
2884         XmlObject o = getfpdFlash().getFvImages();
2885         if (o == null) {
2886             return;
2887         }
2888         XmlCursor cursor = o.newCursor();
2889         QName qFvImage = new QName(xmlNs, "FvImage");
2890         if (cursor.toChild(qFvImage)) {
2891             for (int j = 0; j < i; ++j) {
2892                 cursor.toNextSibling(qFvImage);
2893             }
2894             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
2895             fi.setType(FvImageTypes.Enum.forString(types));
2896
2897             //
2898             // remove old FvImageNames before adding new ones
2899             //
2900             QName qFvImageNames = new QName(xmlNs, "FvImageNames");
2901             cursor.toChild(qFvImageNames);
2902             cursor.removeXml();
2903             while (cursor.toNextSibling(qFvImageNames)) {
2904                 cursor.removeXml();
2905             }
2906
2907             for (int k = 0; k < names.length; ++k) {
2908                 fi.addFvImageNames(names[k]);
2909             }
2910             //
2911             // remove old FvImageOptions before adding new options
2912             //
2913             QName qFvImageOptions = new QName(xmlNs, "FvImageOptions");
2914             cursor.toNextSibling(qFvImageOptions);
2915             cursor.removeXml();
2916
2917             setFvImagesFvImageFvImageOptions(options, fi);
2918         }
2919         cursor.dispose();
2920     }
2921
2922     public int getFvImagesFvImageCount(String type) {
2923
2924         if (getfpdFlash().getFvImages() == null || getfpdFlash().getFvImages().getFvImageList() == null) {
2925             return 0;
2926         }
2927         List<FvImagesDocument.FvImages.FvImage> l = getfpdFlash().getFvImages().getFvImageList();
2928         ListIterator li = l.listIterator();
2929         int i = 0;
2930         while(li.hasNext()) {
2931             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)li.next();
2932             if (!fi.getType().toString().equals(type) && !type.equals("ALL")) {
2933                 continue;
2934             }
2935
2936             ++i;
2937         }
2938
2939         return i;
2940     }
2941
2942     public Vector<FvImagesDocument.FvImages.FvImage> getFvImagesFvImageWithName (String fvName, String type) {
2943         Vector<FvImagesDocument.FvImages.FvImage> vFvImage = new Vector<FvImagesDocument.FvImages.FvImage>();
2944         if (getfpdFlash().getFvImages() == null || getfpdFlash().getFvImages().getFvImageList() == null) {
2945             return vFvImage;
2946         }
2947         List<FvImagesDocument.FvImages.FvImage> l = getfpdFlash().getFvImages().getFvImageList();
2948         ListIterator li = l.listIterator();
2949         while(li.hasNext()) {
2950             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)li.next();
2951             if (!fi.getType().toString().equals(type) && !type.equals("ALL")) {
2952                 continue;
2953             }
2954             if (fi.getFvImageNamesList().contains(fvName)) {
2955                 vFvImage.add(fi);
2956             }
2957         }
2958
2959         return vFvImage;
2960     }
2961     /**
2962      * @param saa
2963      * @param type "ALL" means all FvImage types: ImageName, Options, Attributes, Components.
2964      */
2965     public void getFvImagesFvImages(String[][] saa, String type) {
2966
2967         if (getfpdFlash().getFvImages() == null) {
2968             return;
2969         }
2970         List<FvImagesDocument.FvImages.FvImage> l = getfpdFlash().getFvImages().getFvImageList();
2971         if (l == null) {
2972             return;
2973         }
2974         ListIterator li = l.listIterator();
2975         int i = 0;
2976         while(li.hasNext()) {
2977             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)li.next();
2978             if (!fi.getType().toString().equals(type) && !type.equals("ALL")) {
2979                 continue;
2980             }
2981             //
2982             // get FvImageNames array, space separated
2983             //
2984             List<String> lfn = fi.getFvImageNamesList();
2985             ListIterator lfni = lfn.listIterator();
2986             saa[i][0] = " ";
2987             while (lfni.hasNext()) {
2988                 saa[i][0] += (String)lfni.next();
2989                 saa[i][0] += " ";
2990             }
2991             saa[i][0] = saa[i][0].trim();
2992
2993             saa[i][1] = fi.getType()+"";
2994
2995             ++i;
2996         }
2997     }
2998
2999     public void removeFvImageNameValue (int i, String attributeName) {
3000         XmlObject o = getfpdFlash().getFvImages();
3001         if (o == null) {
3002             return;
3003         }
3004         XmlCursor cursor = o.newCursor();
3005         QName qFvImage = new QName(xmlNs, "FvImage");
3006         if (cursor.toChild(qFvImage)) {
3007             for (int j = 0; j < i; ++j) {
3008                 cursor.toNextSibling(qFvImage);
3009             }
3010             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
3011             removeFvImageNameValue (fi, attributeName);
3012         }
3013         cursor.dispose();
3014     }
3015     /**Remove from fi the attribute pair with attributeName in FvImageOptions.
3016      * @param fi
3017      * @param attributeName
3018      */
3019     public void removeFvImageNameValue (FvImagesDocument.FvImages.FvImage fi, String attributeName) {
3020         if (fi.getFvImageOptions() != null && fi.getFvImageOptions().getNameValueList() != null) {
3021             ListIterator<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> li = fi.getFvImageOptions().getNameValueList().listIterator();
3022             while (li.hasNext()) {
3023                 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = li.next();
3024                 if (nv.getName().equals(attributeName)) {
3025                     li.remove();
3026                 }
3027             }
3028         }
3029     }
3030
3031     public void removeTypedNamedFvImageNameValue (String fvName, String type, String optName) {
3032         Vector<FvImagesDocument.FvImages.FvImage> vFvImage = getFvImagesFvImageWithName(fvName, type);
3033         for (int i = 0; i < vFvImage.size(); ++i) {
3034             FvImagesDocument.FvImages.FvImage fi = vFvImage.get(i);
3035             removeFvImageNameValue (fi, optName);
3036         }
3037     }
3038
3039     /**Add name-value pair to FvImage element with type.
3040      * @param fvName FV name to add name-value pair.
3041      * @param type FvImage attribute.
3042      * @param name
3043      * @param value
3044      */
3045     public void setTypedNamedFvImageNameValue (String fvName, String type, String name, String value) {
3046         boolean fvImageExists = false;
3047         if (getfpdFlash().getFvImages() == null) {
3048             return;
3049         }
3050         List<FvImagesDocument.FvImages.FvImage> l = getfpdFlash().getFvImages().getFvImageList();
3051         if (l == null) {
3052             return;
3053         }
3054         ListIterator li = l.listIterator();
3055         while(li.hasNext()) {
3056             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)li.next();
3057             if (!fi.getType().toString().equals(type) && !type.equals("ALL")) {
3058                 continue;
3059             }
3060             if (!fi.getFvImageNamesList().contains(fvName)) {
3061                 continue;
3062             }
3063             fvImageExists = true;
3064             setFvImagesFvImageNameValue (fi, name, value, null);
3065         }
3066
3067         if (!fvImageExists) {
3068             HashMap<String, String> map = new HashMap<String, String>();
3069             map.put(name, value);
3070             genFvImagesFvImage(new String[]{fvName}, type, map);
3071         }
3072     }
3073
3074     /**Add to all FvImage elements with type, the name-value pair.
3075      * @param type
3076      * @param name
3077      * @param value
3078      */
3079     public void setTypedFvImageNameValue (String type, String name, String value) {
3080         if (getfpdFlash().getFvImages() == null) {
3081             return;
3082         }
3083         List<FvImagesDocument.FvImages.FvImage> l = getfpdFlash().getFvImages().getFvImageList();
3084         if (l == null) {
3085             return;
3086         }
3087         ListIterator li = l.listIterator();
3088         while(li.hasNext()) {
3089             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)li.next();
3090             if (!fi.getType().toString().equals(type) && !type.equals("ALL")) {
3091                 continue;
3092             }
3093             setFvImagesFvImageNameValue (fi, name, value, null);
3094         }
3095
3096     }
3097
3098     public void setFvImagesFvImageNameValue (int i, String name, String value) {
3099         XmlObject o = getfpdFlash().getFvImages();
3100         if (o == null) {
3101             return;
3102         }
3103         XmlCursor cursor = o.newCursor();
3104         QName qFvImage = new QName(xmlNs, "FvImage");
3105         if (cursor.toChild(qFvImage)) {
3106             for (int j = 0; j < i; ++j) {
3107                 cursor.toNextSibling(qFvImage);
3108             }
3109             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
3110             setFvImagesFvImageNameValue (fi, name, value, null);
3111         }
3112         cursor.dispose();
3113     }
3114
3115     /**Add to FvImage the name-value pair, or replace old name with newName, or generate new name-value pair if not exists before.
3116      * @param fi
3117      * @param name
3118      * @param value
3119      * @param newName
3120      */
3121     public void setFvImagesFvImageNameValue (FvImagesDocument.FvImages.FvImage fi, String name, String value, String newName) {
3122         if (fi.getFvImageOptions() == null || fi.getFvImageOptions().getNameValueList() == null) {
3123             FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = fi.addNewFvImageOptions().addNewNameValue();
3124             nv.setName(name);
3125             nv.setValue(value);
3126             if (newName != null) {
3127                 nv.setName(newName);
3128             }
3129             return;
3130         }
3131
3132         XmlCursor cursor = fi.getFvImageOptions().newCursor();
3133         if (cursor.toFirstChild()) {
3134             do {
3135                 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = (FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue)cursor.getObject();
3136                 if (nv.getName().equals(name)) {
3137                     nv.setValue(value);
3138                     if (newName != null) {
3139                         nv.setName(newName);
3140                     }
3141                     cursor.dispose();
3142                     return;
3143                 }
3144             }while (cursor.toNextSibling());
3145         }
3146
3147         FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = fi.getFvImageOptions().addNewNameValue();
3148         nv.setName(name);
3149         nv.setValue(value);
3150         if (newName != null) {
3151             nv.setName(newName);
3152         }
3153         cursor.dispose();
3154     }
3155
3156     public void getFvImagesFvImageOptions (String fvName, Map<String, String> m) {
3157         Vector<FvImagesDocument.FvImages.FvImage> vFvImage = getFvImagesFvImageWithName (fvName, "Options");
3158         for (int i = 0; i < vFvImage.size(); ++i) {
3159             FvImagesDocument.FvImages.FvImage fi = vFvImage.get(i);
3160             if (fi == null || fi.getFvImageOptions() == null || fi.getFvImageOptions().getNameValueList() == null) {
3161                 continue;
3162             }
3163
3164             ListIterator<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> li = fi.getFvImageOptions()
3165                                                                                             .getNameValueList()
3166                                                                                             .listIterator();
3167             while (li.hasNext()) {
3168                 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = li.next();
3169                 m.put(nv.getName(), nv.getValue());
3170             }
3171         }
3172     }
3173
3174     public int getFvImagePosInFvImages (String fvNameList, String type) {
3175         XmlObject o = getfpdFlash().getFvImages();
3176         if (o == null) {
3177             return -1;
3178         }
3179
3180         int pos = -1;
3181         String[] fvNameArray = fvNameList.trim().split(" ");
3182         Vector<String> vFvNames = new Vector<String>();
3183
3184
3185         XmlCursor cursor = o.newCursor();
3186         QName qFvImage = new QName(xmlNs, "FvImage");
3187         if (cursor.toChild(qFvImage)) {
3188             do {
3189                 pos++;
3190                 vFvNames.removeAllElements();
3191                 for (int i = 0; i < fvNameArray.length; ++i) {
3192                     vFvNames.add(fvNameArray[i]);
3193                 }
3194                 FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
3195                 if (!fi.getType().toString().equals(type)) {
3196                     continue;
3197                 }
3198                 if (fi.getFvImageNamesList() == null || fi.getFvImageNamesList().size() != vFvNames.size()) {
3199                     continue;
3200                 }
3201                 ListIterator<String> li = fi.getFvImageNamesList().listIterator();
3202                 while (li.hasNext()) {
3203                     String name = li.next();
3204                     vFvNames.remove(name);
3205                 }
3206                 if (vFvNames.size() == 0) {
3207                     cursor.dispose();
3208                     return pos;
3209                 }
3210
3211             }while (cursor.toNextSibling(qFvImage));
3212
3213         }
3214         cursor.dispose();
3215         return -1;
3216     }
3217     /**Get FvImage Options for FvImage i
3218      * @param i the ith FvImage
3219      */
3220     public void getFvImagesFvImageOptions(int i, Map<String, String> m) {
3221         XmlObject o = getfpdFlash().getFvImages();
3222         if (o == null) {
3223             return;
3224         }
3225         XmlCursor cursor = o.newCursor();
3226         QName qFvImage = new QName(xmlNs, "FvImage");
3227         if (cursor.toChild(qFvImage)) {
3228             for (int j = 0; j < i; ++j) {
3229                 cursor.toNextSibling(qFvImage);
3230             }
3231             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
3232             if (fi.getFvImageOptions() == null || fi.getFvImageOptions().getNameValueList() == null){
3233                 cursor.dispose();
3234                 return;
3235             }
3236             ListIterator<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> li = fi.getFvImageOptions().getNameValueList().listIterator();
3237             while(li.hasNext()){
3238                 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = li.next();
3239                 m.put(nv.getName(), nv.getValue());
3240             }
3241         }
3242         cursor.dispose();
3243     }
3244
3245     /**
3246      Get platform header element
3247      @return PlatformHeaderDocument.PlatformHeader
3248     **/
3249     public PlatformHeaderDocument.PlatformHeader getFpdHdr() {
3250         if (fpdHdr == null) {
3251             fpdHdr = fpdRoot.addNewPlatformHeader();
3252         }
3253
3254         return fpdHdr;
3255     }
3256
3257     public String getFpdHdrPlatformName() {
3258         return getFpdHdr().getPlatformName();
3259     }
3260
3261     public String getFpdHdrGuidValue() {
3262         return getFpdHdr().getGuidValue();
3263     }
3264
3265     public String getFpdHdrVer() {
3266         return getFpdHdr().getVersion();
3267     }
3268
3269     public String getFpdHdrAbs() {
3270         return getFpdHdr().getAbstract();
3271     }
3272
3273     public String getFpdHdrDescription() {
3274         return getFpdHdr().getDescription();
3275     }
3276
3277     public String getFpdHdrCopyright() {
3278         return getFpdHdr().getCopyright();
3279     }
3280
3281     public String getFpdHdrLicense() {
3282         LicenseDocument.License l = getFpdHdr().getLicense();
3283         if (l == null) {
3284             return null;
3285         }
3286         return l.getStringValue();
3287     }
3288
3289     public String getFpdHdrUrl() {
3290         LicenseDocument.License l = getFpdHdr().getLicense();
3291         if (l == null) {
3292             return null;
3293         }
3294         return l.getURL();
3295     }
3296
3297     public String getFpdHdrSpec() {
3298
3299         return "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052";
3300 //        return getFpdHdr().getSpecification();
3301     }
3302
3303     public void setFpdHdrPlatformName(String name){
3304         getFpdHdr().setPlatformName(name);
3305     }
3306
3307     public void setFpdHdrGuidValue(String guid){
3308         getFpdHdr().setGuidValue(guid);
3309     }
3310
3311     public void setFpdHdrVer(String v){
3312         getFpdHdr().setVersion(v);
3313     }
3314
3315     public void setFpdHdrAbs(String abs) {
3316         getFpdHdr().setAbstract(abs);
3317     }
3318
3319     public void setFpdHdrDescription(String desc){
3320         getFpdHdr().setDescription(desc);
3321     }
3322
3323     public void setFpdHdrCopyright(String cr) {
3324         getFpdHdr().setCopyright(cr);
3325     }
3326
3327     public void setFpdHdrLicense(String license){
3328         LicenseDocument.License l = getFpdHdr().getLicense();
3329         if (l == null) {
3330             getFpdHdr().addNewLicense().setStringValue(license);
3331         }
3332         else {
3333             l.setStringValue(license);
3334         }
3335     }
3336
3337     public void setFpdHdrUrl(String url){
3338         LicenseDocument.License l = getFpdHdr().getLicense();
3339
3340         l.setURL(url);
3341
3342     }
3343
3344     public void setFpdHdrSpec(String s){
3345         s = "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052";
3346         getFpdHdr().setSpecification(s);
3347     }
3348     /**
3349     Save the processed xml contents to file
3350
3351     @param fpdFile The file to save xml contents
3352     @throws IOException Exceptions during file operation
3353     **/
3354     public void saveAs(File fpdFile) throws IOException {
3355
3356        XmlOptions options = new XmlOptions();
3357
3358        options.setCharacterEncoding("UTF-8");
3359        options.setSavePrettyPrint();
3360        options.setSavePrettyPrintIndent(2);
3361        try {
3362            fpdd.save(fpdFile, options);
3363        } catch (IOException e) {
3364            e.printStackTrace();
3365        }
3366
3367     }
3368
3369     private String listToString(List l) {
3370         if (l == null) {
3371             return null;
3372         }
3373         String s = " ";
3374         ListIterator li = l.listIterator();
3375         while(li.hasNext()) {
3376             s += li.next();
3377             s += " ";
3378         }
3379         return s.trim();
3380     }
3381
3382     private void removeElement(XmlObject o) {
3383         XmlCursor cursor = o.newCursor();
3384         cursor.removeXml();
3385         cursor.dispose();
3386     }
3387 }
3388
3389 class PcdItemTypeConflictException extends Exception {
3390
3391     /**
3392      *
3393      */
3394     private static final long serialVersionUID = 1L;
3395     private String details = null;
3396
3397     PcdItemTypeConflictException(String pcdName, String info){
3398         ModuleIdentification mi = WorkspaceProfile.getModuleId(info);
3399         details = pcdName + " ItemType Conflicts with " + mi.getName() + " in Pkg " + mi.getPackageId().getName();
3400     }
3401
3402     public String getMessage() {
3403         return details;
3404     }
3405 }
3406
3407 class PcdDeclNotFound extends Exception {
3408
3409     /**
3410      *
3411      */
3412     private static final long serialVersionUID = 1L;
3413     private String details = null;
3414
3415     PcdDeclNotFound(String info) {
3416         details = "PcdDeclNotFound: " + info;
3417     }
3418
3419     public String getMessage() {
3420         return details;
3421     }
3422 }
3423
3424 class PcdValueMalFormed extends Exception {
3425
3426     /**
3427      *
3428      */
3429     private static final long serialVersionUID = 1L;
3430     private String details = null;
3431
3432     PcdValueMalFormed(String info) {
3433         details = "PcdValueMalFormed: " + info;
3434     }
3435
3436     public String getMessage() {
3437         return details;
3438     }
3439 }