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.frameworkwizard.platform.ui.global.GlobalData;
  61 import org.tianocore.frameworkwizard.platform.ui.global.SurfaceAreaQuery;
  62 import org.tianocore.frameworkwizard.platform.ui.id.ModuleIdentification;
  63 import org.tianocore.frameworkwizard.platform.ui.id.PackageIdentification;
  64
  65 /**
  66  This class processes fpd file contents such as add remove xml elements.
  67  @since PackageEditor 1.0
  68 **/
  69 public class FpdFileContents {
  70
  71     static final String xmlNs = "http://www.TianoCore.org/2006/Edk2.0";
  72
  73     private PlatformSurfaceAreaDocument fpdd = null;
  74
  75     private PlatformSurfaceAreaDocument.PlatformSurfaceArea fpdRoot = null;
  76
  77     private PlatformHeaderDocument.PlatformHeader fpdHdr = null;
  78
  79     private PlatformDefinitionsDocument.PlatformDefinitions fpdPlatformDefs = null;
  80
  81     private FlashDocument.Flash fpdFlash = null;
  82
  83     private BuildOptionsDocument.BuildOptions fpdBuildOpts = null;
  84
  85     private FrameworkModulesDocument.FrameworkModules fpdFrameworkModules = null;
  86
  87     private DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions fpdDynPcdBuildDefs = null;
  88
  89     private HashMap<String, ArrayList<String>> dynPcdMap = null;
  90
  91     /**
  92      * look through all pcd data in all ModuleSA, create pcd -> ModuleSA mappings.
  93      */
  94     public void initDynPcdMap() {
  95       if (dynPcdMap == null) {
  96           dynPcdMap = new HashMap<String, ArrayList<String>>();
  97           List<ModuleSADocument.ModuleSA> l = getfpdFrameworkModules().getModuleSAList();
  98           if (l == null) {
  99               return;
 100           }
 101           ListIterator<ModuleSADocument.ModuleSA> li = l.listIterator();
 102           while (li.hasNext()) {
 103               ModuleSADocument.ModuleSA msa = li.next();
 104               if (msa.getPcdBuildDefinition() == null || msa.getPcdBuildDefinition().getPcdDataList() == null) {
 105                   continue;
 106               }
 107               String ModuleInfo = msa.getModuleGuid() + " " + msa.getModuleVersion() +
 108                " " + msa.getPackageGuid() + " " + msa.getPackageVersion() + " " + listToString(msa.getSupArchList());
 109               List<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData> lp = msa.getPcdBuildDefinition().getPcdDataList();
 110               ListIterator<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData> lpi = lp.listIterator();
 111               while (lpi.hasNext()) {
 112                   PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = lpi.next();
 113                   String pcdKey = pcdData.getCName() + " " + pcdData.getTokenSpaceGuidCName();
 114                   if (dynPcdMap.get(pcdKey) == null) {
 115                       ArrayList<String> al = new ArrayList<String>();
 116                       al.add(ModuleInfo + " " + pcdData.getItemType().toString());
 117                       dynPcdMap.put(pcdKey, al);
 118                   }
 119                   else{
 120                       dynPcdMap.get(pcdKey).add(ModuleInfo + " " + pcdData.getItemType().toString());
 121                   }
 122               }
 123           }
 124       }
 125     }
 126
 127     public ArrayList<String> getDynPcdMapValue(String key) {
 128         return dynPcdMap.get(key);
 129     }
 130     /**
 131      Constructor to create a new spd file
 132      **/
 133     public FpdFileContents() {
 134
 135         fpdd = PlatformSurfaceAreaDocument.Factory.newInstance();
 136         fpdRoot = fpdd.addNewPlatformSurfaceArea();
 137
 138     }
 139
 140     /**
 141      Constructor for existing document object
 142      @param psa
 143      **/
 144     public FpdFileContents(PlatformSurfaceAreaDocument.PlatformSurfaceArea fpd) {
 145         fpdRoot = fpd;
 146         fpdHdr = fpdRoot.getPlatformHeader();
 147         fpdPlatformDefs = fpdRoot.getPlatformDefinitions();
 148         fpdBuildOpts = fpdRoot.getBuildOptions();
 149         fpdFrameworkModules = fpdRoot.getFrameworkModules();
 150         fpdDynPcdBuildDefs = fpdRoot.getDynamicPcdBuildDefinitions();
 151         fpdFlash = fpdRoot.getFlash();
 152     }
 153
 154     /**
 155      Constructor based on an existing spd file
 156
 157      @param f Existing spd file
 158      **/
 159     public FpdFileContents(File f) {
 160         try {
 161             fpdd = PlatformSurfaceAreaDocument.Factory.parse(f);
 162             fpdRoot = fpdd.getPlatformSurfaceArea();
 163         } catch (Exception e) {
 164             System.out.println(e.toString());
 165         }
 166     }
 167
 168     public DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions getfpdDynPcdBuildDefs() {
 169         if (fpdDynPcdBuildDefs == null){
 170             fpdDynPcdBuildDefs = fpdRoot.addNewDynamicPcdBuildDefinitions();
 171         }
 172         return fpdDynPcdBuildDefs;
 173     }
 174
 175     public FrameworkModulesDocument.FrameworkModules getfpdFrameworkModules() {
 176         if (fpdFrameworkModules == null){
 177             fpdFrameworkModules = fpdRoot.addNewFrameworkModules();
 178         }
 179         return fpdFrameworkModules;
 180     }
 181
 182     public int getFrameworkModulesCount() {
 183         if (getfpdFrameworkModules().getModuleSAList() == null){
 184             return 0;
 185         }
 186         return getfpdFrameworkModules().getModuleSAList().size();
 187     }
 188
 189     public void getFrameworkModulesInfo(String[][] saa) {
 190         if (getFrameworkModulesCount() == 0){
 191             return;
 192         }
 193
 194         ListIterator li = getfpdFrameworkModules().getModuleSAList().listIterator();
 195         int i = 0;
 196         while(li.hasNext()) {
 197             ModuleSADocument.ModuleSA msa = (ModuleSADocument.ModuleSA)li.next();
 198             saa[i][0] = msa.getModuleGuid();
 199             saa[i][1] = msa.getModuleVersion();
 200
 201             saa[i][2] = msa.getPackageGuid();
 202             saa[i][3] = msa.getPackageVersion();
 203             saa[i][4] = listToString(msa.getSupArchList());
 204             ++i;
 205         }
 206     }
 207
 208     public void getFrameworkModuleInfo(int i, String[] sa) {
 209         ModuleSADocument.ModuleSA msa = getModuleSA(i);
 210         if (msa == null) {
 211             return;
 212         }
 213         sa[0] = msa.getModuleGuid();
 214         sa[1] = msa.getModuleVersion();
 215         sa[2] = msa.getPackageGuid();
 216         sa[3] = msa.getPackageVersion();
 217         sa[4] = listToString(msa.getSupArchList());
 218     }
 219
 220     public ModuleSADocument.ModuleSA getModuleSA(String key) {
 221         String[] s = key.split(" ");
 222         if (getfpdFrameworkModules().getModuleSAList() == null) {
 223             return null;
 224         }
 225         ListIterator li = getfpdFrameworkModules().getModuleSAList().listIterator();
 226         while(li.hasNext()) {
 227             ModuleSADocument.ModuleSA msa = (ModuleSADocument.ModuleSA)li.next();
 228             if (msa.getModuleGuid().equals(s[0]) && msa.getPackageGuid().equals(s[2])) {
 229                 if (msa.getModuleVersion() != null) {
 230                     if (!msa.getModuleVersion().equals(s[1])) {
 231                         continue;
 232                     }
 233                 }
 234                 if (msa.getPackageVersion() != null) {
 235                     if (!msa.getPackageVersion().equals(s[3])) {
 236                         continue;
 237                     }
 238                 }
 239                 //ToDo add arch check for s[4]
 240                 if (msa.getSupArchList() != null) {
 241                     if (!listToString(msa.getSupArchList()).equals(s[4])) {
 242                         continue;
 243                     }
 244                 }
 245                 return msa;
 246             }
 247         }
 248         return null;
 249     }
 250
 251     private ModuleSADocument.ModuleSA getModuleSA(int i) {
 252         ModuleSADocument.ModuleSA msa = null;
 253         XmlCursor cursor = getfpdFrameworkModules().newCursor();
 254         if (cursor.toFirstChild()) {
 255             for (int j = 0; j < i; ++j) {
 256                 cursor.toNextSibling();
 257             }
 258             msa = (ModuleSADocument.ModuleSA)cursor.getObject();
 259         }
 260         cursor.dispose();
 261         return msa;
 262     }
 263
 264     public void removeModuleSA(int i) {
 265         XmlObject o = getfpdFrameworkModules();
 266         if (o == null) {
 267             return;
 268         }
 269
 270         XmlCursor cursor = o.newCursor();
 271         if (cursor.toFirstChild()) {
 272             for (int j = 0; j < i; ++j) {
 273                 cursor.toNextSibling();
 274             }
 275             //
 276             // remove pcd from dynPcdMap, if DynamicPcdBuildData exists, remove them too.
 277             //
 278             ModuleSADocument.ModuleSA moduleSa = (ModuleSADocument.ModuleSA)cursor.getObject();
 279             String moduleInfo = moduleSa.getModuleGuid() + " " + moduleSa.getModuleVersion() + " " +
 280             moduleSa.getPackageGuid()+ " " + moduleSa.getPackageVersion() + " " + listToString(moduleSa.getSupArchList());
 281             PcdBuildDefinitionDocument.PcdBuildDefinition pcdBuildDef = moduleSa.getPcdBuildDefinition();
 282             if (pcdBuildDef != null && pcdBuildDef.getPcdDataList() != null) {
 283                 ListIterator<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData> li = pcdBuildDef.getPcdDataList().listIterator();
 284                 while(li.hasNext()) {
 285                     PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = li.next();
 286                     maintainDynPcdMap(pcdData.getCName() + " " + pcdData.getTokenSpaceGuidCName(), moduleInfo);
 287                 }
 288             }
 289             cursor.removeXml();
 290             if (getFrameworkModulesCount() == 0) {
 291                 cursor.toParent();
 292                 cursor.removeXml();
 293             }
 294         }
 295         cursor.dispose();
 296     }
 297
 298     private void maintainDynPcdMap(String pcdKey, String moduleInfo) {
 299
 300         ArrayList<String> al = dynPcdMap.get(pcdKey);
 301         if (al == null) {
 302             return;
 303         }
 304         String[] s = moduleInfo.split(" ");
 305         for(int i = 0; i < al.size(); ++i){
 306             String consumer = al.get(i);
 307             if (consumer.contains(s[0]) && consumer.contains(s[2])){
 308                 String[] consumerPart = consumer.split(" ");
 309                 if (!consumerPart[4].equals(s[4])) {
 310                     continue;
 311                 }
 312                 al.remove(consumer);
 313                 break;
 314             }
 315         }
 316
 317         if (al.size() == 0) {
 318             dynPcdMap.remove(pcdKey);
 319             String[] s1 = pcdKey.split(" ");
 320             removeDynamicPcdBuildData(s1[0], s1[1]);
 321         }
 322
 323     }
 324     //
 325     // key for ModuleSA : "ModuleGuid ModuleVer PackageGuid PackageVer Arch"
 326     //
 327     public int getPcdDataCount(int i){
 328         ModuleSADocument.ModuleSA msa = getModuleSA(i);
 329
 330         if (msa == null || msa.getPcdBuildDefinition() == null || msa.getPcdBuildDefinition().getPcdDataList() == null){
 331             return 0;
 332         }
 333         return msa.getPcdBuildDefinition().getPcdDataList().size();
 334
 335     }
 336
 337     public void getPcdData(int i, String[][] saa) {
 338         ModuleSADocument.ModuleSA msa = getModuleSA(i);
 339
 340         if (msa == null || msa.getPcdBuildDefinition() == null || msa.getPcdBuildDefinition().getPcdDataList() == null){
 341             return;
 342         }
 343         ListIterator<PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData>li = msa.getPcdBuildDefinition().getPcdDataList().listIterator();
 344         for (int k = 0; k < saa.length; ++k) {
 345             PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = li.next();
 346             saa[k][0] = pcdData.getCName();
 347             saa[k][1] = pcdData.getTokenSpaceGuidCName();
 348             saa[k][2] = pcdData.getItemType()+"";
 349             saa[k][3] = pcdData.getToken().toString();
 350             saa[k][4] = pcdData.getMaxDatumSize()+"";
 351             saa[k][5] = pcdData.getDatumType()+"";
 352             saa[k][6] = pcdData.getValue();
 353
 354         }
 355     }
 356
 357     public void updatePcdData(String key, String cName, String tsGuid, String itemType, String maxSize, String value){
 358         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 359         if (msa == null || msa.getPcdBuildDefinition() == null){
 360             return;
 361         }
 362
 363         XmlCursor cursor = msa.getPcdBuildDefinition().newCursor();
 364         if (cursor.toFirstChild()){
 365             do {
 366                 PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = (PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData)cursor.getObject();
 367                 if (pcdData.getCName().equals(cName) && pcdData.getTokenSpaceGuidCName().equals(tsGuid)) {
 368                     pcdData.setItemType(PcdItemTypes.Enum.forString(itemType));
 369                     if(pcdData.getDatumType().equals("VOID*")) {
 370                         pcdData.setMaxDatumSize(new Integer(maxSize));
 371                     }
 372                     pcdData.setValue(value);
 373                     break;
 374                 }
 375             }
 376             while(cursor.toNextSibling());
 377         }
 378         cursor.dispose();
 379     }
 380
 381     /**Get original Pcd info from MSA & SPD files.
 382      * @param mi ModuleIdentification from which MSA & SPD come
 383      * @param cName PCD cName
 384      * @param sa Results: HelpText, Original item type.
 385      * @return
 386      */
 387     public boolean getPcdBuildDataInfo(ModuleIdentification mi, String cName, String[] sa) throws Exception{
 388         try {
 389
 390             ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = (ModuleSurfaceAreaDocument.ModuleSurfaceArea)GlobalData.getModuleXmlObject(mi);
 391             if (msa.getPcdCoded() == null) {
 392                 return false;
 393             }
 394
 395             Map<String, XmlObject> m = new HashMap<String, XmlObject>();
 396             m.put("ModuleSurfaceArea", msa);
 397             SurfaceAreaQuery.setDoc(m);
 398             PackageIdentification[] depPkgs = SurfaceAreaQuery.getDependencePkg(null);
 399             //
 400             // First look through MSA pcd entries.
 401             //
 402             List<PcdCodedDocument.PcdCoded.PcdEntry> l = msa.getPcdCoded().getPcdEntryList();
 403             ListIterator li = l.listIterator();
 404             while(li.hasNext()) {
 405                 PcdCodedDocument.PcdCoded.PcdEntry msaPcd = (PcdCodedDocument.PcdCoded.PcdEntry)li.next();
 406                 if (!msaPcd.getCName().equals(cName)) {
 407                     continue;
 408                 }
 409                 PcdDeclarationsDocument.PcdDeclarations.PcdEntry spdPcd = LookupPcdDeclaration(msaPcd, depPkgs);
 410                 if (spdPcd == null) {
 411                     //
 412                     // ToDo Error
 413                     //
 414                     throw new PcdDeclNotFound(mi.getName() + " " + msaPcd.getCName());
 415                 }
 416                 //
 417                 // Get Pcd help text and original item type.
 418                 //
 419                 sa[0] = spdPcd.getHelpText() + msaPcd.getHelpText();
 420                 sa[1] = msaPcd.getPcdItemType()+"";
 421                 return true;
 422             }
 423
 424
 425         }
 426         catch (Exception e){
 427 //            e.printStackTrace();
 428             throw e;
 429         }
 430
 431         return false;
 432     }
 433
 434     /**Remove PCDBuildDefinition entries from ModuleSA
 435      * @param moduleKey identifier of ModuleSA.
 436      * @param consumer where these entries come from.
 437      */
 438     public void removePcdData(String moduleKey, ModuleIdentification consumer) {
 439         try {
 440             ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = (ModuleSurfaceAreaDocument.ModuleSurfaceArea)GlobalData.getModuleXmlObject(consumer);
 441             if (msa.getPcdCoded() == null) {
 442                 return;
 443             }
 444
 445             List<PcdCodedDocument.PcdCoded.PcdEntry> l = msa.getPcdCoded().getPcdEntryList();
 446             ListIterator li = l.listIterator();
 447
 448             while(li.hasNext()) {
 449                 PcdCodedDocument.PcdCoded.PcdEntry msaPcd = (PcdCodedDocument.PcdCoded.PcdEntry)li.next();
 450                 ModuleSADocument.ModuleSA moduleSA = getModuleSA(moduleKey);
 451                 XmlCursor cursor = moduleSA.getPcdBuildDefinition().newCursor();
 452                 if (cursor.toFirstChild()) {
 453                     PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData pcdData = (PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData)cursor.getObject();
 454                     if (msaPcd.getCName().equals(pcdData.getCName()) && msaPcd.getTokenSpaceGuidCName().equals(pcdData.getTokenSpaceGuidCName())) {
 455
 456                         maintainDynPcdMap(pcdData.getCName()+" "+pcdData.getTokenSpaceGuidCName(), moduleKey);
 457                         cursor.removeXml();
 458                         break;
 459                     }
 460                     while (cursor.toNextSibling()) {
 461                         pcdData = (PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData)cursor.getObject();
 462                         if (msaPcd.getCName().equals(pcdData.getCName()) && msaPcd.getTokenSpaceGuidCName().equals(pcdData.getTokenSpaceGuidCName())) {
 463                             maintainDynPcdMap(pcdData.getCName()+" "+pcdData.getTokenSpaceGuidCName(), moduleKey);
 464                             cursor.removeXml();
 465                             break;
 466                         }
 467                     }
 468                 }
 469                 cursor.dispose();
 470             }
 471
 472         }
 473         catch (Exception e){
 474             e.printStackTrace();
 475
 476         }
 477     }
 478     //
 479     // key for ModuleSA : "ModuleGuid ModuleVer PackageGuid PackageVer Arch"
 480     //
 481     public int getLibraryInstancesCount(String key) {
 482         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 483         if (msa == null || msa.getLibraries() == null || msa.getLibraries().getInstanceList() == null){
 484             return 0;
 485         }
 486         return msa.getLibraries().getInstanceList().size();
 487     }
 488
 489     public void getLibraryInstances(String key, String[][] saa){
 490         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 491         if (msa == null || msa.getLibraries() == null || msa.getLibraries().getInstanceList() == null){
 492             return ;
 493         }
 494
 495         ListIterator<LibrariesDocument.Libraries.Instance> li = msa.getLibraries().getInstanceList().listIterator();
 496         for (int i = 0; i < saa.length; ++i) {
 497             LibrariesDocument.Libraries.Instance instance = li.next();
 498             saa[i][1] = instance.getModuleGuid();
 499             saa[i][2] = instance.getModuleVersion();
 500             saa[i][3] = instance.getPackageGuid();
 501             saa[i][4] = instance.getPackageVersion();
 502         }
 503     }
 504
 505     public void removeLibraryInstance(String key, int i) {
 506         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 507         if (msa == null || msa.getLibraries() == null){
 508             return ;
 509         }
 510
 511         XmlCursor cursor = msa.getLibraries().newCursor();
 512         if (cursor.toFirstChild()) {
 513             for (int j = 0; j < i; ++j) {
 514                 cursor.toNextSibling();
 515             }
 516             cursor.removeXml();
 517         }
 518
 519         cursor.dispose();
 520     }
 521
 522     public void genLibraryInstance(String mg, String mv, String pg, String pv, String key) {
 523         ModuleSADocument.ModuleSA msa = getModuleSA(key);
 524         if (msa == null){
 525             msa = getfpdFrameworkModules().addNewModuleSA();
 526         }
 527         LibrariesDocument.Libraries libs = msa.getLibraries();
 528         if(libs == null){
 529             libs = msa.addNewLibraries();
 530         }
 531
 532         LibrariesDocument.Libraries.Instance instance = libs.addNewInstance();
 533         instance.setModuleGuid(mg);
 534         instance.setModuleVersion(mv);
 535         instance.setPackageGuid(pg);
 536         instance.setPackageVersion(pv);
 537
 538     }
 539
 540     public String getFvBinding(String moduleKey){
 541         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 542         if (msa == null || msa.getModuleSaBuildOptions() == null) {
 543             return null;
 544         }
 545         return msa.getModuleSaBuildOptions().getFvBinding();
 546     }
 547
 548     public void setFvBinding(String moduleKey, String fvBinding){
 549         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 550         if (msa == null ) {
 551             return;
 552         }
 553         if(msa.getModuleSaBuildOptions() == null){
 554             msa.addNewModuleSaBuildOptions().setFvBinding(fvBinding);
 555             return;
 556         }
 557         msa.getModuleSaBuildOptions().setFvBinding(fvBinding);
 558     }
 559
 560     public String getFfsFileNameGuid(String moduleKey){
 561         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 562         if (msa == null || msa.getModuleSaBuildOptions() == null) {
 563             return null;
 564         }
 565         return msa.getModuleSaBuildOptions().getFfsFileNameGuid();
 566     }
 567
 568     public void setFfsFileNameGuid(String moduleKey, String fileGuid){
 569         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 570         if (msa == null ) {
 571             return;
 572         }
 573         if(msa.getModuleSaBuildOptions() == null){
 574             msa.addNewModuleSaBuildOptions();
 575
 576         }
 577         ModuleSaBuildOptionsDocument.ModuleSaBuildOptions msaBuildOpts= msa.getModuleSaBuildOptions();
 578         if (fileGuid != null) {
 579             msaBuildOpts.setFfsFileNameGuid(fileGuid);
 580         }
 581         else{
 582             XmlCursor cursor = msaBuildOpts.newCursor();
 583             if (cursor.toChild(xmlNs, "FfsFileNameGuid")) {
 584                 cursor.removeXml();
 585             }
 586             cursor.dispose();
 587         }
 588
 589     }
 590
 591     public String getFfsFormatKey(String moduleKey){
 592         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 593         if (msa == null || msa.getModuleSaBuildOptions() == null) {
 594             return null;
 595         }
 596         return msa.getModuleSaBuildOptions().getFfsFormatKey();
 597     }
 598
 599     public void setFfsFormatKey(String moduleKey, String ffsKey){
 600         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 601         if (msa == null ) {
 602             return;
 603         }
 604         if(msa.getModuleSaBuildOptions() == null){
 605             msa.addNewModuleSaBuildOptions().setFfsFormatKey(ffsKey);
 606             return;
 607         }
 608         msa.getModuleSaBuildOptions().setFfsFormatKey(ffsKey);
 609     }
 610
 611     public void getModuleSAOptions(String moduleKey, String[][] saa) {
 612         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 613         if (msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null
 614                         || msa.getModuleSaBuildOptions().getOptions().getOptionList() == null) {
 615             return ;
 616         }
 617
 618         List<OptionDocument.Option> lOpt = msa.getModuleSaBuildOptions().getOptions().getOptionList();
 619         ListIterator li = lOpt.listIterator();
 620         int i = 0;
 621         while(li.hasNext()) {
 622             OptionDocument.Option opt = (OptionDocument.Option)li.next();
 623             if (opt.getBuildTargets() != null) {
 624                 saa[i][0] = listToString(opt.getBuildTargets());
 625             }
 626             saa[i][1] = opt.getToolChainFamily();
 627             saa[i][2] = opt.getTagName();
 628             saa[i][3] = opt.getToolCode();
 629
 630             if (opt.getSupArchList() != null){
 631                 saa[i][4] = listToString(opt.getSupArchList());
 632
 633             }
 634
 635             saa[i][5] = opt.getStringValue();
 636
 637             ++i;
 638         }
 639     }
 640
 641     public int getModuleSAOptionsCount(String moduleKey){
 642         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 643         if (msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null
 644                         || msa.getModuleSaBuildOptions().getOptions().getOptionList() == null) {
 645             return 0;
 646         }
 647         return msa.getModuleSaBuildOptions().getOptions().getOptionList().size();
 648     }
 649
 650     public void genModuleSAOptionsOpt(String moduleKey, Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
 651         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 652         if (msa.getModuleSaBuildOptions() == null) {
 653             msa.addNewModuleSaBuildOptions();
 654         }
 655         if (msa.getModuleSaBuildOptions().getOptions() == null){
 656             msa.getModuleSaBuildOptions().addNewOptions();
 657         }
 658         OptionDocument.Option opt = msa.getModuleSaBuildOptions().getOptions().addNewOption();
 659         setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
 660     }
 661
 662     public void removeModuleSAOptionsOpt(String moduleKey, int i) {
 663         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 664         if (msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null) {
 665             return ;
 666         }
 667         OptionsDocument.Options opts = msa.getModuleSaBuildOptions().getOptions();
 668         XmlCursor cursor = opts.newCursor();
 669         if (cursor.toFirstChild()) {
 670             for (int j = 0; j < i; ++j){
 671                 cursor.toNextSibling();
 672             }
 673             cursor.removeXml();
 674         }
 675         cursor.dispose();
 676     }
 677
 678     public void updateModuleSAOptionsOpt(String moduleKey, int i, Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
 679         ModuleSADocument.ModuleSA msa = getModuleSA(moduleKey);
 680         if (msa.getModuleSaBuildOptions() == null || msa.getModuleSaBuildOptions().getOptions() == null) {
 681             return ;
 682         }
 683         OptionsDocument.Options opts = msa.getModuleSaBuildOptions().getOptions();
 684         XmlCursor cursor = opts.newCursor();
 685         if (cursor.toFirstChild()) {
 686             for (int j = 0; j < i; ++j){
 687                 cursor.toNextSibling();
 688             }
 689             OptionDocument.Option opt = (OptionDocument.Option)cursor.getObject();
 690             setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
 691         }
 692         cursor.dispose();
 693     }
 694
 695     /**add pcd information of module mi to a ModuleSA.
 696      * @param mi
 697      * @param moduleSa if null, generate a new ModuleSA.
 698      */
 699     public void addFrameworkModulesPcdBuildDefs(ModuleIdentification mi, String arch, ModuleSADocument.ModuleSA moduleSa) throws Exception {
 700         //ToDo add Arch filter
 701
 702         try {
 703             if (moduleSa == null) {
 704                 moduleSa = genModuleSA(mi, arch);
 705             }
 706
 707             ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = (ModuleSurfaceAreaDocument.ModuleSurfaceArea)GlobalData.getModuleXmlObject(mi);
 708             if (msa.getPcdCoded() == null) {
 709                 return;
 710             }
 711
 712             Map<String, XmlObject> m = new HashMap<String, XmlObject>();
 713             m.put("ModuleSurfaceArea", msa);
 714             SurfaceAreaQuery.setDoc(m);
 715             PackageIdentification[] depPkgs = SurfaceAreaQuery.getDependencePkg(null);
 716             //
 717             // Implementing InitializePlatformPcdBuildDefinitions
 718             //
 719             List<PcdCodedDocument.PcdCoded.PcdEntry> l = msa.getPcdCoded().getPcdEntryList();
 720             ListIterator li = l.listIterator();
 721             while(li.hasNext()) {
 722                 PcdCodedDocument.PcdCoded.PcdEntry msaPcd = (PcdCodedDocument.PcdCoded.PcdEntry)li.next();
 723                 PcdDeclarationsDocument.PcdDeclarations.PcdEntry spdPcd = LookupPcdDeclaration(msaPcd, depPkgs);
 724                 if (spdPcd == null) {
 725                     //
 726                     // ToDo Error
 727                     //
 728                     throw new PcdDeclNotFound(mi.getName() + " " + msaPcd.getCName());
 729                 }
 730                 //
 731                 // AddItem to ModuleSA PcdBuildDefinitions
 732                 //
 733                 String defaultVal = msaPcd.getDefaultValue() == null ? spdPcd.getDefaultValue() : msaPcd.getDefaultValue();
 734
 735                 genPcdData(msaPcd.getCName(), spdPcd.getToken(), msaPcd.getTokenSpaceGuidCName(), msaPcd.getPcdItemType().toString(), spdPcd.getDatumType()+"", defaultVal, moduleSa);
 736             }
 737
 738         }
 739         catch (Exception e){
 740 //            e.printStackTrace();
 741             throw e;
 742         }
 743
 744     }
 745
 746     private PcdDeclarationsDocument.PcdDeclarations.PcdEntry LookupPcdDeclaration (PcdCodedDocument.PcdCoded.PcdEntry msaPcd, PackageIdentification[] depPkgs) {
 747
 748         Map<String, XmlObject> m = new HashMap<String, XmlObject>();
 749         PcdDeclarationsDocument.PcdDeclarations.PcdEntry spdPcd = null;
 750         for (int i = 0; i < depPkgs.length; ++i) {
 751             m.put("PackageSurfaceArea", GlobalData.getPackageXmlObject(depPkgs[i]));
 752             SurfaceAreaQuery.setDoc(m);
 753             XmlObject[] xo = SurfaceAreaQuery.getSpdPcdDeclarations();
 754             if (xo == null) {
 755                 continue;
 756             }
 757             for (int j = 0; j < xo.length; ++j) {
 758                 spdPcd = (PcdDeclarationsDocument.PcdDeclarations.PcdEntry)xo[j];
 759                 if (msaPcd.getTokenSpaceGuidCName() == null) {
 760                     if (spdPcd.getCName().equals(msaPcd.getCName())) {
 761                         return spdPcd;
 762                     }
 763                 }
 764                 else{
 765                     if (spdPcd.getCName().equals(msaPcd.getCName()) && spdPcd.getTokenSpaceGuidCName().equals(msaPcd.getTokenSpaceGuidCName())) {
 766                         return spdPcd;
 767                     }
 768                 }
 769
 770             }
 771
 772         }
 773         return null;
 774     }
 775
 776     private ModuleSADocument.ModuleSA genModuleSA (ModuleIdentification mi, String arch) {
 777         PackageIdentification pi = GlobalData.getPackageForModule(mi);
 778         ModuleSADocument.ModuleSA msa = getfpdFrameworkModules().addNewModuleSA();
 779         msa.setModuleGuid(mi.getGuid());
 780         msa.setModuleVersion(mi.getVersion());
 781         msa.setPackageGuid(pi.getGuid());
 782         msa.setPackageVersion(pi.getVersion());
 783         if (arch != null) {
 784             Vector<String> v = new Vector<String>();
 785             v.add(arch);
 786             msa.setSupArchList(v);
 787         }
 788
 789         return msa;
 790     }
 791
 792     private void genPcdData (String cName, Object token, String tsGuid, String itemType, String dataType, String defaultVal, ModuleSADocument.ModuleSA moduleSa)
 793     throws PcdItemTypeConflictException, PcdValueMalFormed{
 794         if (moduleSa.getPcdBuildDefinition() == null){
 795             moduleSa.addNewPcdBuildDefinition();
 796         }
 797         //
 798         // constructe pcd to modulesa mapping first.
 799         // Attention : for any error condition, remove from map this pcd.
 800         //
 801         ArrayList<String> pcdConsumer = LookupPlatformPcdData(cName + " " + tsGuid);
 802         if (pcdConsumer == null) {
 803             pcdConsumer = new ArrayList<String>();
 804         }
 805         String listValue = moduleSa.getModuleGuid() + " " + moduleSa.getModuleVersion()
 806         + " " + moduleSa.getPackageGuid() + " " + moduleSa.getPackageVersion() + " " + listToString(moduleSa.getSupArchList())
 807         + " " + itemType;
 808         pcdConsumer.add(listValue);
 809         dynPcdMap.put(cName + " " + tsGuid, pcdConsumer);
 810         //
 811         // Special dynamic type, if this pcd already exists in other ModuleSA
 812         //
 813         if (itemType.equals("DYNAMIC")) {
 814
 815             ListIterator li = pcdConsumer.listIterator();
 816             while(li.hasNext()) {
 817                 String value = li.next().toString();
 818                 String[] valuePart= value.split(" ");
 819                 if (!valuePart[4].equals("DYNAMIC")) {
 820                     //ToDo error for same pcd, other type than dynamic
 821                     pcdConsumer.remove(listValue);
 822                     throw new PcdItemTypeConflictException(value);
 823                 }
 824             }
 825         }
 826         else {
 827             ListIterator li = pcdConsumer.listIterator();
 828             while(li.hasNext()) {
 829                 String value = li.next().toString();
 830                 String[] valuePart= value.split(" ");
 831                 if (valuePart[4].equals("DYNAMIC")) {
 832                     //ToDo error for same pcd, other type than non-dynamic
 833                     pcdConsumer.remove(listValue);
 834                     throw new PcdItemTypeConflictException(value);
 835                 }
 836             }
 837         }
 838
 839         PcdBuildDefinitionDocument.PcdBuildDefinition.PcdData fpdPcd = moduleSa.getPcdBuildDefinition().addNewPcdData();
 840         fpdPcd.setCName(cName);
 841         fpdPcd.setToken(token);
 842         fpdPcd.setTokenSpaceGuidCName(tsGuid);
 843         fpdPcd.setDatumType(PcdDataTypes.Enum.forString(dataType));
 844         fpdPcd.setItemType(PcdItemTypes.Enum.forString(itemType));
 845
 846         if (itemType.equals("DYNAMIC") || itemType.equals("DYNAMIC_EX")) {
 847             ArrayList<String> al = LookupDynamicPcdBuildDefinition(cName + " " + tsGuid);
 848             //
 849             // if only one module mapped to this pcd, then the one is myself. so no other module mapped.
 850             // so need to add one dyn pcd.
 851             //
 852             if (al.size() == 1) {
 853                 addDynamicPcdBuildData(cName, token, tsGuid, itemType, dataType, defaultVal);
 854             }
 855         }
 856         else {
 857             if (defaultVal != null){
 858                 fpdPcd.setValue(defaultVal);
 859             }
 860             else {
 861                 if (dataType.equals("UINT8") || dataType.equals("UINT16") || dataType.equals("UINT32") || dataType.equals("UINT64")) {
 862                     fpdPcd.setValue("0");
 863                 }
 864                 if (dataType.equals("BOOLEAN")){
 865                     fpdPcd.setValue("false");
 866                 }
 867                 if (dataType.equals("VOID*")) {
 868                     fpdPcd.setValue("");
 869                 }
 870             }
 871             if (dataType.equals("UINT8")){
 872                 fpdPcd.setMaxDatumSize(1);
 873             }
 874             if (dataType.equals("UINT16")) {
 875                 fpdPcd.setMaxDatumSize(2);
 876             }
 877             if (dataType.equals("UINT32")) {
 878                 fpdPcd.setMaxDatumSize(4);
 879             }
 880             if (dataType.equals("UINT64")){
 881                 fpdPcd.setMaxDatumSize(8);
 882             }
 883             if (dataType.equals("BOOLEAN")){
 884                 fpdPcd.setMaxDatumSize(1);
 885             }
 886             if (dataType.equals("VOID*")) {
 887                 int maxSize = setMaxSizeForPointer(fpdPcd.getValue());
 888                 fpdPcd.setMaxDatumSize(maxSize);
 889             }
 890         }
 891     }
 892
 893     public int setMaxSizeForPointer(String datum) throws PcdValueMalFormed{
 894         if (datum == null) {
 895             return 0;
 896         }
 897         char    ch     = datum.charAt(0);
 898         int     start, end;
 899         String  strValue;
 900         //
 901         // For void* type PCD, only three datum is support:
 902         // 1) Unicode: string with start char is "L"
 903         // 2) Ansci: String  is ""
 904         // 3) byte array: String start char "{"
 905         //
 906         if (ch == 'L') {
 907             start       = datum.indexOf('\"');
 908             end         = datum.lastIndexOf('\"');
 909             if ((start > end)           ||
 910                 (end   > datum.length())||
 911                 ((start == end) && (datum.length() > 0))) {
 912                 //ToDo Error handling here
 913                 throw new PcdValueMalFormed (datum);
 914             }
 915
 916             strValue    = datum.substring(start + 1, end);
 917             return strValue.length() * 2;
 918         } else if (ch == '\"'){
 919             start       = datum.indexOf('\"');
 920             end         = datum.lastIndexOf('\"');
 921             if ((start > end)           ||
 922                 (end   > datum.length())||
 923                 ((start == end) && (datum.length() > 0))) {
 924                 throw new PcdValueMalFormed (datum);
 925             }
 926             strValue    = datum.substring(start + 1, end);
 927             return strValue.length();
 928         } else if (ch =='{') {
 929             String[]  strValueArray;
 930
 931             start           = datum.indexOf('{');
 932             end             = datum.lastIndexOf('}');
 933             strValue        = datum.substring(start + 1, end);
 934             strValue        = strValue.trim();
 935             if (strValue.length() == 0) {
 936                 return 0;
 937             }
 938             strValueArray   = strValue.split(",");
 939             for (int index = 0; index < strValueArray.length; index ++) {
 940                     Integer value = Integer.decode(strValueArray[index].trim());
 941
 942                 if (value > 0xFF) {
 943 //                   "[FPD file error] The datum type of PCD %s in %s is VOID*, "+
 944 //                   "it is byte array in fact. But the element of %s exceed the byte range",
 945                     throw new PcdValueMalFormed (datum);
 946                 }
 947             }
 948             return strValueArray.length;
 949
 950
 951         } else {
 952 //            "[FPD file error] The datum type of PCD %s in %s is VOID*. For VOID* type, you have three format choise:\n "+
 953 //            "1) UNICODE string: like L\"xxxx\";\r\n"+
 954 //            "2) ANSIC string: like \"xxx\";\r\n"+
 955 //            "3) Byte array: like {0x2, 0x45, 0x23}\r\n"+
 956 //            "but the datum in seems does not following above format!",
 957             throw new PcdValueMalFormed (datum);
 958
 959         }
 960     }
 961
 962     private ArrayList<String> LookupDynamicPcdBuildDefinition(String dynPcdKey) {
 963         ArrayList<String> al = dynPcdMap.get(dynPcdKey);
 964
 965         return al;
 966     }
 967
 968     private ArrayList<String> LookupPlatformPcdData(String pcdKey) {
 969
 970         return dynPcdMap.get("pcdKey");
 971     }
 972
 973     public int getDynamicPcdBuildDataCount() {
 974         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null) {
 975             return 0;
 976         }
 977         return getfpdDynPcdBuildDefs().getPcdBuildDataList().size();
 978     }
 979
 980     public void getDynamicPcdBuildData(String[][] saa) {
 981         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null) {
 982             return ;
 983         }
 984         List<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData> l = getfpdDynPcdBuildDefs().getPcdBuildDataList();
 985         ListIterator<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData> li = l.listIterator();
 986         int i = 0;
 987         while(li.hasNext()) {
 988             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData dynPcd = li.next();
 989             saa[i][0] = dynPcd.getCName();
 990             saa[i][1] = dynPcd.getToken().toString();
 991             saa[i][2] = dynPcd.getTokenSpaceGuidCName();
 992             saa[i][3] = dynPcd.getMaxDatumSize()+"";
 993             saa[i][4] = dynPcd.getDatumType().toString();
 994
 995             ++i;
 996         }
 997     }
 998
 999     public void addDynamicPcdBuildData(String cName, Object token, String tsGuid, String itemType, String dataType, String defaultVal)
1000     throws PcdValueMalFormed{
1001         DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData dynPcdData = getfpdDynPcdBuildDefs().addNewPcdBuildData();
1002         dynPcdData.setItemType(PcdItemTypes.Enum.forString(itemType));
1003         dynPcdData.setCName(cName);
1004         dynPcdData.setToken(token);
1005         dynPcdData.setTokenSpaceGuidCName(tsGuid);
1006         dynPcdData.setDatumType(PcdDataTypes.Enum.forString(dataType));
1007
1008         BigInteger bigInt = new BigInteger("0");
1009         DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = dynPcdData.addNewSkuInfo();
1010         skuInfo.setSkuId(bigInt);
1011         if (defaultVal != null){
1012             skuInfo.setValue(defaultVal);
1013         }
1014         else {
1015             if (dataType.equals("UINT8")){
1016                 skuInfo.setValue("0");
1017             }
1018             if (dataType.equals("UINT16")) {
1019                 skuInfo.setValue("0");
1020             }
1021             if (dataType.equals("UINT32")) {
1022                 skuInfo.setValue("0");
1023             }
1024             if (dataType.equals("UINT64")){
1025                 skuInfo.setValue("0");
1026             }
1027             if (dataType.equals("BOOLEAN")){
1028                 skuInfo.setValue("false");
1029             }
1030             if (dataType.equals("VOID*")) {
1031                 skuInfo.setValue("");
1032             }
1033         }
1034         if (dataType.equals("UINT8")){
1035             dynPcdData.setMaxDatumSize(1);
1036         }
1037         if (dataType.equals("UINT16")) {
1038             dynPcdData.setMaxDatumSize(2);
1039         }
1040         if (dataType.equals("UINT32")) {
1041             dynPcdData.setMaxDatumSize(4);
1042         }
1043         if (dataType.equals("UINT64")){
1044             dynPcdData.setMaxDatumSize(8);
1045         }
1046         if (dataType.equals("BOOLEAN")){
1047             dynPcdData.setMaxDatumSize(1);
1048         }
1049         if (dataType.equals("VOID*")) {
1050             int maxSize = setMaxSizeForPointer(defaultVal);
1051             dynPcdData.setMaxDatumSize(maxSize);
1052         }
1053     }
1054
1055     public void removeDynamicPcdBuildData(String cName, String tsGuid) {
1056         XmlObject o = getfpdDynPcdBuildDefs();
1057
1058         XmlCursor cursor = o.newCursor();
1059         if (cursor.toFirstChild()) {
1060             do {
1061                 DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdBuildData =
1062                     (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1063                 if (pcdBuildData.getCName().equals(cName) && pcdBuildData.getTokenSpaceGuidCName().equals(tsGuid)) {
1064                     cursor.removeXml();
1065                     if (getDynamicPcdBuildDataCount() == 0) {
1066                         cursor.toParent();
1067                         cursor.removeXml();
1068                     }
1069                     cursor.dispose();
1070                     return;
1071                 }
1072             }
1073             while (cursor.toNextSibling());
1074         }
1075         cursor.dispose();
1076     }
1077     //
1078     // Get the Sku Info count of ith dyn pcd element.
1079     //
1080     public int getDynamicPcdSkuInfoCount(int i){
1081         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1082             return 0;
1083         }
1084
1085         int skuInfoCount = 0;
1086         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1087         if (cursor.toFirstChild()) {
1088             for (int j = 0; j < i; ++j) {
1089                 cursor.toNextSibling();
1090             }
1091             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1092             if (pcdData.getSkuInfoList() == null) {
1093                 skuInfoCount = 0;
1094             }
1095             else {
1096                 skuInfoCount = pcdData.getSkuInfoList().size();
1097             }
1098         }
1099         cursor.dispose();
1100         return skuInfoCount;
1101     }
1102
1103     public void getDynamicPcdSkuInfos(int i, String[][] saa){
1104         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1105             return;
1106         }
1107
1108         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1109         if (cursor.toFirstChild()) {
1110             for (int j = 0; j < i; ++j) {
1111                 cursor.toNextSibling();
1112             }
1113             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1114             if (pcdData.getSkuInfoList() == null) {
1115                 cursor.dispose();
1116                 return;
1117             }
1118             else {
1119                 ListIterator<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo> li = pcdData.getSkuInfoList().listIterator();
1120                 int k = 0;
1121                 while (li.hasNext()) {
1122                     DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = li.next();
1123                     saa[k][0] = skuInfo.getSkuId()+"";
1124                     saa[k][1] = skuInfo.getVariableName();
1125                     saa[k][2] = skuInfo.getVariableGuid();
1126                     saa[k][3] = skuInfo.getVariableOffset();
1127                     saa[k][4] = skuInfo.getHiiDefaultValue();
1128                     saa[k][5] = skuInfo.getVpdOffset();
1129                     saa[k][6] = skuInfo.getValue();
1130                     ++k;
1131                 }
1132
1133             }
1134         }
1135         cursor.dispose();
1136
1137     }
1138
1139     public String getDynamicPcdBuildDataValue(int i){
1140         String value = null;
1141         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1142             return value;
1143         }
1144
1145         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1146         if (cursor.toFirstChild()) {
1147             for (int j = 0; j < i; ++j) {
1148                 cursor.toNextSibling();
1149             }
1150             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1151             if (pcdData.getSkuInfoList() == null) {
1152                 value = null;
1153             }
1154             else {
1155                 value = pcdData.getSkuInfoArray(0).getValue();
1156             }
1157         }
1158         cursor.dispose();
1159         return value;
1160     }
1161
1162     public String getDynamicPcdBuildDataVpdOffset(int i){
1163         String vpdOffset = null;
1164         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1165             return vpdOffset;
1166         }
1167
1168         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1169         if (cursor.toFirstChild()) {
1170             for (int j = 0; j < i; ++j) {
1171                 cursor.toNextSibling();
1172             }
1173             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1174             if (pcdData.getSkuInfoList() == null) {
1175                 vpdOffset = null;
1176             }
1177             else {
1178                 vpdOffset = pcdData.getSkuInfoArray(0).getVpdOffset();
1179             }
1180         }
1181         cursor.dispose();
1182         return vpdOffset;
1183     }
1184
1185     public void removeDynamicPcdBuildDataSkuInfo(int i) {
1186         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1187             return;
1188         }
1189
1190         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1191         if (cursor.toFirstChild()) {
1192             for (int j = 0; j < i; ++j) {
1193                 cursor.toNextSibling();
1194             }
1195             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1196             if (pcdData.getSkuInfoList() == null) {
1197                 cursor.dispose();
1198                 return;
1199             }
1200             else {
1201                 QName qSkuInfo = new QName(xmlNs, "SkuInfo");
1202                 cursor.toChild(qSkuInfo);
1203                 cursor.removeXml();
1204             }
1205         }
1206         cursor.dispose();
1207     }
1208     //
1209     // generate sku info for ith dyn pcd build data.
1210     //
1211     public void genDynamicPcdBuildDataSkuInfo(String id, String varName, String varGuid, String varOffset,
1212                                               String hiiDefault, String vpdOffset, String value, int i) {
1213         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1214             return;
1215         }
1216
1217         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1218         if (cursor.toFirstChild()) {
1219             for (int j = 0; j < i; ++j) {
1220                 cursor.toNextSibling();
1221             }
1222             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1223             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = pcdData.addNewSkuInfo();
1224             skuInfo.setSkuId(new BigInteger(id));
1225             if (varName != null){
1226                 skuInfo.setVariableName(varName);
1227                 skuInfo.setVariableGuid(varGuid);
1228                 skuInfo.setVariableOffset(varOffset);
1229                 skuInfo.setHiiDefaultValue(hiiDefault);
1230             }
1231             else if (vpdOffset != null){
1232                 skuInfo.setVpdOffset(vpdOffset);
1233             }
1234             else{
1235                 skuInfo.setValue(value);
1236             }
1237         }
1238     }
1239
1240     public void updateDynamicPcdBuildDataSkuInfo(String id, String varName, String varGuid, String varOffset,
1241                                                  String hiiDefault, String vpdOffset, String value, int i){
1242         if (getfpdDynPcdBuildDefs().getPcdBuildDataList() == null || getfpdDynPcdBuildDefs().getPcdBuildDataList().size() == 0) {
1243             return;
1244         }
1245
1246         XmlCursor cursor = getfpdDynPcdBuildDefs().newCursor();
1247         if (cursor.toFirstChild()) {
1248             for (int j = 0; j < i; ++j) {
1249                 cursor.toNextSibling();
1250             }
1251             DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData pcdData = (DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData)cursor.getObject();
1252             ListIterator<DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo> li = pcdData.getSkuInfoList().listIterator();
1253             while (li.hasNext()) {
1254                 DynamicPcdBuildDefinitionsDocument.DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo skuInfo = li.next();
1255                 if (skuInfo.getSkuId().toString().equals(id)){
1256                     if (varName != null){
1257                         skuInfo.setVariableName(varName);
1258                         skuInfo.setVariableGuid(varGuid);
1259                         skuInfo.setVariableOffset(varOffset);
1260                         skuInfo.setHiiDefaultValue(hiiDefault);
1261                     }
1262                     else if (vpdOffset != null){
1263                         skuInfo.setVpdOffset(vpdOffset);
1264                     }
1265                     else{
1266                         skuInfo.setValue(value);
1267                     }
1268                     break;
1269                 }
1270             }
1271         }
1272     }
1273
1274     public BuildOptionsDocument.BuildOptions getfpdBuildOpts() {
1275         if (fpdBuildOpts == null) {
1276             fpdBuildOpts = fpdRoot.addNewBuildOptions();
1277         }
1278         return fpdBuildOpts;
1279     }
1280
1281     public void genBuildOptionsUserDefAntTask (String id, String fileName, String execOrder) {
1282         UserDefinedAntTasksDocument.UserDefinedAntTasks udats = getfpdBuildOpts().getUserDefinedAntTasks();
1283         if (udats == null) {
1284             udats = getfpdBuildOpts().addNewUserDefinedAntTasks();
1285         }
1286
1287         AntTaskDocument.AntTask at = udats.addNewAntTask();
1288         setBuildOptionsUserDefAntTask(id, fileName, execOrder, at);
1289     }
1290
1291     private void setBuildOptionsUserDefAntTask(String id, String fileName, String execOrder, AntTaskDocument.AntTask at) {
1292         at.setId(new Integer(id));
1293         XmlCursor cursor = at.newCursor();
1294         if (fileName != null){
1295             at.setFilename(fileName);
1296         }
1297         else if (cursor.toChild(xmlNs, "Filename")) {
1298             cursor.removeXml();
1299         }
1300         if (execOrder != null) {
1301             at.setAntCmdOptions(execOrder);
1302         }
1303         else if (cursor.toChild(xmlNs, "AntCmdOptions")) {
1304             cursor.removeXml();
1305         }
1306         cursor.dispose();
1307     }
1308
1309     public void removeBuildOptionsUserDefAntTask(int i) {
1310         XmlObject o = getfpdBuildOpts().getUserDefinedAntTasks();
1311         if (o == null) {
1312             return;
1313         }
1314         XmlCursor cursor = o.newCursor();
1315         if (cursor.toFirstChild()) {
1316             for (int j = 0; j < i; ++j) {
1317                 cursor.toNextSibling();
1318             }
1319             cursor.removeXml();
1320             if (getBuildOptionsUserDefAntTaskCount() == 0) {
1321                 cursor.toParent();
1322                 cursor.removeXml();
1323             }
1324         }
1325         cursor.dispose();
1326     }
1327
1328     public void updateBuildOptionsUserDefAntTask(int i, String id, String fileName, String execOrder){
1329         XmlObject o = getfpdBuildOpts().getUserDefinedAntTasks();
1330         if (o == null) {
1331             return;
1332         }
1333         XmlCursor cursor = o.newCursor();
1334         if (cursor.toFirstChild()) {
1335             for (int j = 0; j < i; ++j) {
1336                 cursor.toNextSibling();
1337             }
1338             AntTaskDocument.AntTask at = (AntTaskDocument.AntTask)cursor.getObject();
1339             setBuildOptionsUserDefAntTask(id, fileName, execOrder, at);
1340         }
1341         cursor.dispose();
1342     }
1343
1344     public int getBuildOptionsUserDefAntTaskCount() {
1345         UserDefinedAntTasksDocument.UserDefinedAntTasks udats = getfpdBuildOpts().getUserDefinedAntTasks();
1346         if (udats == null || udats.getAntTaskList() == null) {
1347             return 0;
1348         }
1349
1350         return udats.getAntTaskList().size();
1351     }
1352
1353     public void getBuildOptionsUserDefAntTasks(String[][] saa) {
1354         UserDefinedAntTasksDocument.UserDefinedAntTasks udats = getfpdBuildOpts().getUserDefinedAntTasks();
1355         if (udats == null || udats.getAntTaskList() == null) {
1356             return ;
1357         }
1358
1359         List<AntTaskDocument.AntTask> l = udats.getAntTaskList();
1360         ListIterator li = l.listIterator();
1361         int i = 0;
1362         while (li.hasNext()) {
1363             AntTaskDocument.AntTask at = (AntTaskDocument.AntTask)li.next();
1364             saa[i][0] = at.getId() + "";
1365             saa[i][1] = saa[i][2] = "";
1366             if (at.getFilename() != null){
1367                 saa[i][1] = at.getFilename();
1368             }
1369             if (at.getAntCmdOptions() != null) {
1370                 saa[i][2] = at.getAntCmdOptions();
1371             }
1372             ++i;
1373         }
1374     }
1375     public void genBuildOptionsOpt(Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
1376         OptionsDocument.Options opts = getfpdBuildOpts().getOptions();
1377         if (opts == null) {
1378             opts = getfpdBuildOpts().addNewOptions();
1379         }
1380         OptionDocument.Option opt = opts.addNewOption();
1381         setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
1382     }
1383
1384     private void setBuildOptionsOpt(Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents, OptionDocument.Option opt){
1385         opt.setStringValue(contents);
1386
1387         opt.setBuildTargets(buildTargets);
1388         opt.setToolChainFamily(toolChain);
1389         opt.setTagName(tagName);
1390         opt.setToolCode(toolCmd);
1391
1392         if (archList != null) {
1393             opt.setSupArchList(archList);
1394         }
1395         else {
1396             if (opt.isSetSupArchList()) {
1397                 opt.unsetSupArchList();
1398             }
1399         }
1400     }
1401
1402     public void removeBuildOptionsOpt(int i){
1403
1404         XmlObject o = getfpdBuildOpts().getOptions();
1405         if (o == null) {
1406             return;
1407         }
1408
1409         XmlCursor cursor = o.newCursor();
1410         if (cursor.toFirstChild()) {
1411             for (int j = 0; j < i; ++j) {
1412                 cursor.toNextSibling();
1413             }
1414             cursor.removeXml();
1415             if (getBuildOptionsOptCount() == 0) {
1416                 cursor.toParent();
1417                 cursor.removeXml();
1418             }
1419         }
1420         cursor.dispose();
1421     }
1422
1423     public void updateBuildOptionsOpt(int i, Vector<Object> buildTargets, String toolChain, String tagName, String toolCmd, Vector<Object> archList, String contents) {
1424         XmlObject o = getfpdBuildOpts().getOptions();
1425         if (o == null) {
1426             return;
1427         }
1428
1429         XmlCursor cursor = o.newCursor();
1430         if (cursor.toFirstChild()) {
1431             for (int j = 0; j < i; ++j) {
1432                 cursor.toNextSibling();
1433             }
1434             OptionDocument.Option opt = (OptionDocument.Option)cursor.getObject();
1435             setBuildOptionsOpt(buildTargets, toolChain, tagName, toolCmd, archList, contents, opt);
1436         }
1437         cursor.dispose();
1438     }
1439
1440     public int getBuildOptionsOptCount(){
1441         if (getfpdBuildOpts().getOptions() == null || getfpdBuildOpts().getOptions().getOptionList() == null) {
1442             return 0;
1443         }
1444         return getfpdBuildOpts().getOptions().getOptionList().size();
1445     }
1446
1447     public void getBuildOptionsOpts(String[][] saa) {
1448         if (getfpdBuildOpts().getOptions() == null || getfpdBuildOpts().getOptions().getOptionList() == null) {
1449             return ;
1450         }
1451
1452         List<OptionDocument.Option> lOpt = getfpdBuildOpts().getOptions().getOptionList();
1453         ListIterator li = lOpt.listIterator();
1454         int i = 0;
1455         while(li.hasNext()) {
1456             OptionDocument.Option opt = (OptionDocument.Option)li.next();
1457             if (opt.getBuildTargets() != null) {
1458                 saa[i][0] = listToString(opt.getBuildTargets());
1459             }
1460             saa[i][1] = opt.getToolChainFamily();
1461             if (opt.getSupArchList() != null){
1462                 saa[i][2] = listToString(opt.getSupArchList());
1463
1464             }
1465             saa[i][3] = opt.getToolCode();
1466             saa[i][4] = opt.getTagName();
1467             saa[i][5] = opt.getStringValue();
1468
1469             ++i;
1470         }
1471     }
1472
1473     public void genBuildOptionsFfs(String ffsKey, String type) {
1474         BuildOptionsDocument.BuildOptions.Ffs ffs = getfpdBuildOpts().addNewFfs();
1475         ffs.setFfsKey(ffsKey);
1476         if (type != null) {
1477             ffs.addNewSections().setEncapsulationType(type);
1478         }
1479     }
1480
1481     public void updateBuildOptionsFfsSectionsType(int i, String type) {
1482         BuildOptionsDocument.BuildOptions.Ffs ffs = getfpdBuildOpts().addNewFfs();
1483         if (type != null) {
1484             ffs.addNewSections().setEncapsulationType(type);
1485         }
1486     }
1487
1488     public void genBuildOptionsFfsAttribute(int i, String name, String value) {
1489         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1490         BuildOptionsDocument.BuildOptions.Ffs.Attribute attrib = ffs.addNewAttribute();
1491         attrib.setName(name);
1492         attrib.setValue(value);
1493     }
1494
1495     /**update jth attribute of ith ffs.
1496      * @param i
1497      * @param j
1498      */
1499     public void updateBuildOptionsFfsAttribute(int i, int j, String name, String value){
1500         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1501         XmlCursor cursor = ffs.newCursor();
1502         QName qAttrib = new QName(xmlNs, "Attribute");
1503         if (cursor.toChild(qAttrib)) {
1504             for (int k = 0; k < j; ++k) {
1505                 cursor.toNextSibling(qAttrib);
1506             }
1507             BuildOptionsDocument.BuildOptions.Ffs.Attribute attrib = (BuildOptionsDocument.BuildOptions.Ffs.Attribute)cursor.getObject();
1508             attrib.setName(name);
1509             attrib.setValue(value);
1510         }
1511         cursor.dispose();
1512     }
1513
1514     public void removeBuildOptionsFfsAttribute(int i, int j){
1515         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1516         XmlCursor cursor = ffs.newCursor();
1517         QName qAttrib = new QName(xmlNs, "Attribute");
1518         if (cursor.toChild(qAttrib)) {
1519             for (int k = 0; k < j; ++k) {
1520                 cursor.toNextSibling(qAttrib);
1521             }
1522             cursor.removeXml();
1523         }
1524         cursor.dispose();
1525     }
1526
1527     public void genBuildOptionsFfsSectionsSection(int i, String sectionType) {
1528         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1529         if (ffs == null) {
1530             return;
1531         }
1532         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1533
1534         if (sections == null){
1535             sections = ffs.addNewSections();
1536         }
1537         sections.addNewSection().setSectionType(EfiSectionType.Enum.forString(sectionType));
1538     }
1539
1540     public void removeBuildOptionsFfsSectionsSection(int i, int j) {
1541         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1542         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1543         if (sections == null) {
1544             return;
1545         }
1546         XmlCursor cursor = sections.newCursor();
1547         QName qSection = new QName(xmlNs, "Section");
1548         if (cursor.toChild(qSection)) {
1549             for (int k = 0; k < j; ++k) {
1550                 cursor.toNextSibling(qSection);
1551             }
1552             cursor.removeXml();
1553         }
1554         cursor.dispose();
1555     }
1556
1557     public void updateBuildOptionsFfsSectionsSection(int i, int j, String type){
1558         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1559         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1560         if (sections == null) {
1561             return;
1562         }
1563         XmlCursor cursor = sections.newCursor();
1564         QName qSection = new QName(xmlNs, "Section");
1565         if (cursor.toChild(qSection)) {
1566             for (int k = 0; k < j; ++k) {
1567                 cursor.toNextSibling(qSection);
1568             }
1569             BuildOptionsDocument.BuildOptions.Ffs.Sections.Section section = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Section)cursor.getObject();
1570             section.setSectionType(EfiSectionType.Enum.forString(type));
1571         }
1572         cursor.dispose();
1573     }
1574
1575     public void genBuildOptionsFfsSectionsSections(int i, String encapType) {
1576         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1577         if (ffs == null) {
1578             return;
1579         }
1580         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1581
1582         if (sections == null){
1583             sections = ffs.addNewSections();
1584         }
1585         sections.addNewSections().setEncapsulationType(encapType);
1586     }
1587
1588     public void removeBuildOptionsFfsSectionsSections(int i, int j) {
1589         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1590         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1591         if (sections == null) {
1592             return;
1593         }
1594         XmlCursor cursor = sections.newCursor();
1595         QName qSections = new QName(xmlNs, "Sections");
1596         if (cursor.toChild(qSections)) {
1597             for (int k = 0; k < j; ++k) {
1598                 cursor.toNextSibling(qSections);
1599             }
1600             cursor.removeXml();
1601         }
1602         cursor.dispose();
1603     }
1604
1605     public void updateBuildOptionsFfsSectionsSections(int i, int j, String type) {
1606         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1607         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1608         if (sections == null) {
1609             return;
1610         }
1611         XmlCursor cursor = sections.newCursor();
1612         QName qSections = new QName(xmlNs, "Sections");
1613         if (cursor.toChild(qSections)) {
1614             for (int k = 0; k < j; ++k) {
1615                 cursor.toNextSibling(qSections);
1616             }
1617             BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2 sections2 = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2)cursor.getObject();
1618             sections2.setEncapsulationType(type);
1619         }
1620         cursor.dispose();
1621     }
1622
1623     public void genBuildOptionsFfsSectionsSectionsSection(int i, int j, String type) {
1624         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1625         if (ffs == null) {
1626             return;
1627         }
1628         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1629         XmlCursor cursor = sections.newCursor();
1630         QName qSections = new QName(xmlNs, "Sections");
1631         if (cursor.toChild(qSections)){
1632             for (int k = 0; k < j; ++k) {
1633                 cursor.toNextSibling(qSections);
1634             }
1635             BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2 sections2 = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2)cursor.getObject();
1636             sections2.addNewSection().setSectionType(EfiSectionType.Enum.forString(type));
1637         }
1638         cursor.dispose();
1639     }
1640
1641     public void removeBuildOptionsFfsSectionsSectionsSection(int i, int j, int k) {
1642         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1643         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1644         if (sections == null) {
1645             return;
1646         }
1647         XmlCursor cursor = sections.newCursor();
1648         QName qSections = new QName(xmlNs, "Sections");
1649         if (cursor.toChild(qSections)) {
1650             for (int l = 0; l < j; ++l) {
1651                 cursor.toNextSibling(qSections);
1652             }
1653             if (cursor.toFirstChild()) {
1654                 int m = 0;
1655                 for (; m < k; ++m) {
1656                     cursor.toNextSibling();
1657                 }
1658                 cursor.removeXml();
1659                 if (m == 0) {
1660                     cursor.toParent();
1661                     cursor.removeXml();
1662                 }
1663             }
1664         }
1665         cursor.dispose();
1666     }
1667
1668     public void updateBuildOptionsFfsSectionsSectionsSection(int i, int j, int k, String type) {
1669         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1670         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1671         if (sections == null) {
1672             return;
1673         }
1674         XmlCursor cursor = sections.newCursor();
1675         QName qSections = new QName(xmlNs, "Sections");
1676         if (cursor.toChild(qSections)) {
1677             for (int l = 0; l < j; ++l) {
1678                 cursor.toNextSibling(qSections);
1679             }
1680             if (cursor.toFirstChild()) {
1681                 for (int m = 0; m < k; ++m) {
1682                     cursor.toNextSibling();
1683                 }
1684                 BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section section = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section)cursor.getObject();
1685                 section.setSectionType(EfiSectionType.Enum.forString(type));
1686             }
1687         }
1688         cursor.dispose();
1689     }
1690
1691     public void getBuildOptionsFfsSectionsSectionsSection(int i, int j, ArrayList<String> al) {
1692         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1693         if (ffs == null) {
1694             return;
1695         }
1696         BuildOptionsDocument.BuildOptions.Ffs.Sections sections = ffs.getSections();
1697         XmlCursor cursor = sections.newCursor();
1698         QName qSections = new QName(xmlNs, "Sections");
1699         if (cursor.toChild(qSections)){
1700             for (int k = 0; k < j; ++k) {
1701                 cursor.toNextSibling(qSections);
1702             }
1703             BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2 sections2 = (BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2)cursor.getObject();
1704             if (sections2.getSectionList() == null){
1705                 cursor.dispose();
1706                 return;
1707             }
1708             ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section> li = sections2.getSectionList().listIterator();
1709             while(li.hasNext()) {
1710                 BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2.Section section = li.next();
1711                 if (section.isSetSectionType()) {
1712                     al.add(section.getSectionType().toString());
1713                 }
1714
1715             }
1716         }
1717         cursor.dispose();
1718
1719     }
1720
1721     public int getBuildOptionsFfsCount(){
1722         if (getfpdBuildOpts().getFfsList() == null) {
1723             return 0;
1724         }
1725         return getfpdBuildOpts().getFfsList().size();
1726     }
1727
1728     public void getBuildOptionsFfsKey(String[][] saa) {
1729         if (getfpdBuildOpts().getFfsList() == null) {
1730             return;
1731         }
1732         ListIterator<BuildOptionsDocument.BuildOptions.Ffs> li = getfpdBuildOpts().getFfsList().listIterator();
1733         int i = 0;
1734         while(li.hasNext()){
1735             BuildOptionsDocument.BuildOptions.Ffs ffs = li.next();
1736             saa[i][0] = ffs.getFfsKey();
1737             ++i;
1738         }
1739     }
1740
1741     public void updateBuildOptionsFfsKey(int i, String key) {
1742         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1743         ffs.setFfsKey(key);
1744     }
1745
1746     /**Get ith FFS key and contents.
1747      * @param saa
1748      */
1749     public void getBuildOptionsFfs(int i, String[] sa, LinkedHashMap<String, String> ffsAttribMap, ArrayList<String> firstLevelSections, ArrayList<String> firstLevelSection) {
1750         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1751
1752         if (ffs != null) {
1753
1754             sa[0] = ffs.getFfsKey();
1755             if (ffs.getSections() != null) {
1756                 if(ffs.getSections().getEncapsulationType() != null){
1757                     sa[1] = ffs.getSections().getEncapsulationType();
1758                 }
1759                 if (ffs.getSections().getSectionList() != null){
1760                     ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Sections.Section> li = ffs.getSections().getSectionList().listIterator();
1761                     while (li.hasNext()) {
1762                         firstLevelSection.add(li.next().getSectionType().toString());
1763                     }
1764                 }
1765                 if (ffs.getSections().getSectionsList() != null) {
1766                     ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Sections.Sections2> li = ffs.getSections().getSectionsList().listIterator();
1767                     while(li.hasNext()) {
1768                         firstLevelSections.add(li.next().getEncapsulationType());
1769                     }
1770                 }
1771             }
1772             if (ffs.getAttributeList() != null) {
1773                 ListIterator<BuildOptionsDocument.BuildOptions.Ffs.Attribute> li = ffs.getAttributeList().listIterator();
1774                 while(li.hasNext()) {
1775                     BuildOptionsDocument.BuildOptions.Ffs.Attribute attrib = li.next();
1776                     ffsAttribMap.put(attrib.getName(), attrib.getValue());
1777                 }
1778
1779             }
1780         }
1781
1782
1783     }
1784
1785     private BuildOptionsDocument.BuildOptions.Ffs getFfs(int i) {
1786         XmlObject o = getfpdBuildOpts();
1787         BuildOptionsDocument.BuildOptions.Ffs ffs = null;
1788
1789         XmlCursor cursor = o.newCursor();
1790         QName qFfs = new QName(xmlNs, "Ffs");
1791         if (cursor.toChild(qFfs)) {
1792             for (int j = 0; j < i; ++j) {
1793                 cursor.toNextSibling(qFfs);
1794             }
1795             ffs = (BuildOptionsDocument.BuildOptions.Ffs)cursor.getObject();
1796         }
1797         cursor.dispose();
1798         return ffs;
1799     }
1800
1801     public void removeBuildOptionsFfs(int i) {
1802         BuildOptionsDocument.BuildOptions.Ffs ffs = getFfs(i);
1803         if (ffs == null){
1804             return;
1805         }
1806
1807         XmlCursor cursor = ffs.newCursor();
1808         cursor.removeXml();
1809         cursor.dispose();
1810     }
1811
1812
1813
1814     public PlatformDefinitionsDocument.PlatformDefinitions getfpdPlatformDefs(){
1815         if (fpdPlatformDefs == null){
1816             fpdPlatformDefs = fpdRoot.addNewPlatformDefinitions();
1817         }
1818         return fpdPlatformDefs;
1819     }
1820
1821     public void getPlatformDefsSupportedArchs(Vector<Object> archs){
1822         if (getfpdPlatformDefs().getSupportedArchitectures() == null) {
1823             return;
1824         }
1825         ListIterator li = getfpdPlatformDefs().getSupportedArchitectures().listIterator();
1826         while(li.hasNext()) {
1827             archs.add(li.next());
1828         }
1829     }
1830
1831     public void setPlatformDefsSupportedArchs(Vector<Object> archs) {
1832         if (archs != null) {
1833             getfpdPlatformDefs().setSupportedArchitectures(archs);
1834         }
1835 //        else {
1836 //            XmlCursor cursor = getfpdPlatformDefs().newCursor();
1837 //            if (cursor.toChild(xmlNs, "SupportedArchitectures")) {
1838 //                cursor.removeXml();
1839 //            }
1840 //            cursor.dispose();
1841 //        }
1842     }
1843
1844     public void getPlatformDefsBuildTargets(Vector<Object> targets) {
1845         if (getfpdPlatformDefs().getBuildTargets() == null) {
1846             return;
1847         }
1848         ListIterator li = getfpdPlatformDefs().getBuildTargets().listIterator();
1849         while(li.hasNext()) {
1850             targets.add(li.next());
1851         }
1852     }
1853
1854     public void setPlatformDefsBuildTargets(Vector<Object> targets) {
1855         getfpdPlatformDefs().setBuildTargets(targets);
1856     }
1857
1858     public void genPlatformDefsSkuInfo(String id, String name) {
1859         SkuInfoDocument.SkuInfo skuInfo = null;
1860         if (getfpdPlatformDefs().getSkuInfo() == null) {
1861             skuInfo = getfpdPlatformDefs().addNewSkuInfo();
1862         }
1863         skuInfo = getfpdPlatformDefs().getSkuInfo();
1864         if (skuInfo.getUiSkuNameList() == null || skuInfo.getUiSkuNameList().size() == 0) {
1865             SkuInfoDocument.SkuInfo.UiSkuName skuName = skuInfo.addNewUiSkuName();
1866             skuName.setSkuID(new BigInteger("0"));
1867             skuName.setStringValue("DEFAULT");
1868         }
1869         if (id.equals("0")) {
1870             return;
1871         }
1872         SkuInfoDocument.SkuInfo.UiSkuName skuName = skuInfo.addNewUiSkuName();
1873         skuName.setSkuID(new BigInteger(id));
1874         skuName.setStringValue(name);
1875     }
1876
1877     public int getPlatformDefsSkuInfoCount(){
1878         if (getfpdPlatformDefs().getSkuInfo() == null || getfpdPlatformDefs().getSkuInfo().getUiSkuNameList() == null) {
1879             return 0;
1880         }
1881         return getfpdPlatformDefs().getSkuInfo().getUiSkuNameList().size();
1882     }
1883
1884     public void getPlatformDefsSkuInfos(String[][] saa){
1885         if (getfpdPlatformDefs().getSkuInfo() == null || getfpdPlatformDefs().getSkuInfo().getUiSkuNameList() == null) {
1886             return ;
1887         }
1888
1889         List<SkuInfoDocument.SkuInfo.UiSkuName> l = getfpdPlatformDefs().getSkuInfo().getUiSkuNameList();
1890         ListIterator<SkuInfoDocument.SkuInfo.UiSkuName> li = l.listIterator();
1891         int i = 0;
1892         while(li.hasNext()) {
1893             SkuInfoDocument.SkuInfo.UiSkuName sku = li.next();
1894             saa[i][0] = sku.getSkuID()+"";
1895             saa[i][1] = sku.getStringValue();
1896             ++i;
1897         }
1898     }
1899
1900     public void removePlatformDefsSkuInfo(int i) {
1901         SkuInfoDocument.SkuInfo skuInfo = getfpdPlatformDefs().getSkuInfo();
1902         if (skuInfo == null || i == 0) {
1903             return ;
1904         }
1905
1906         XmlCursor cursor = skuInfo.newCursor();
1907         if (cursor.toFirstChild()) {
1908             for (int j = 0; j < i; ++j) {
1909                 cursor.toNextSibling();
1910             }
1911             cursor.removeXml();
1912         }
1913         cursor.dispose();
1914     }
1915
1916     public void updatePlatformDefsSkuInfo(int i, String id, String name) {
1917         SkuInfoDocument.SkuInfo skuInfo = getfpdPlatformDefs().getSkuInfo();
1918         if (skuInfo == null || i == 0) {
1919             return ;
1920         }
1921
1922         XmlCursor cursor = skuInfo.newCursor();
1923         if (cursor.toFirstChild()) {
1924             for (int j = 0; j < i; ++j) {
1925                 cursor.toNextSibling();
1926             }
1927             SkuInfoDocument.SkuInfo.UiSkuName sku = (SkuInfoDocument.SkuInfo.UiSkuName)cursor.getObject();
1928             sku.setSkuID(new BigInteger(id));
1929             sku.setStringValue(name);
1930         }
1931         cursor.dispose();
1932     }
1933
1934     public String getPlatformDefsInterDir(){
1935         if (getfpdPlatformDefs().getIntermediateDirectories() == null) {
1936             return null;
1937         }
1938         return getfpdPlatformDefs().getIntermediateDirectories().toString();
1939     }
1940
1941     public void setPlatformDefsInterDir(String interDir){
1942         getfpdPlatformDefs().setIntermediateDirectories(IntermediateOutputType.Enum.forString(interDir));
1943     }
1944
1945     public String getPlatformDefsOutputDir() {
1946         return getfpdPlatformDefs().getOutputDirectory();
1947     }
1948
1949     public void setPlatformDefsOutputDir(String outputDir) {
1950         if (outputDir != null && outputDir.length() > 0) {
1951             getfpdPlatformDefs().setOutputDirectory(outputDir);
1952         }
1953         else{
1954             XmlCursor cursor = getfpdPlatformDefs().newCursor();
1955             if (cursor.toChild(new QName(xmlNs, "OutputDirectory"))) {
1956                 cursor.removeXml();
1957             }
1958             cursor.dispose();
1959         }
1960     }
1961
1962     public FlashDocument.Flash getfpdFlash() {
1963         if (fpdFlash == null) {
1964             fpdFlash = fpdRoot.addNewFlash();
1965         }
1966         return fpdFlash;
1967     }
1968
1969     public void genFlashDefinitionFile(String file) {
1970         FlashDefinitionFileDocument.FlashDefinitionFile fdf = getfpdFlash().getFlashDefinitionFile();
1971         if (fdf == null) {
1972             fdf = getfpdFlash().addNewFlashDefinitionFile();
1973         }
1974
1975         fdf.setStringValue(file);
1976     }
1977
1978     public String getFlashDefinitionFile() {
1979         FlashDefinitionFileDocument.FlashDefinitionFile fdf = getfpdFlash().getFlashDefinitionFile();
1980         if (fdf == null) {
1981             return "";
1982         }
1983
1984         return fdf.getStringValue();
1985     }
1986
1987     public void genFvImagesNameValue(String name, String value) {
1988
1989         FvImagesDocument.FvImages fi = getfpdFlash().getFvImages();
1990         if (fi == null) {
1991             fi = getfpdFlash().addNewFvImages();
1992         }
1993
1994         FvImagesDocument.FvImages.NameValue nv = fi.addNewNameValue();
1995         nv.setName(name);
1996         nv.setValue(value);
1997     }
1998
1999     public void removeFvImagesNameValue(int i){
2000
2001         XmlObject o = getfpdFlash().getFvImages();
2002         if (o == null) {
2003             return;
2004         }
2005
2006         QName qNameValue = new QName(xmlNs, "NameValue");
2007         XmlCursor cursor = o.newCursor();
2008         if (cursor.toChild(qNameValue)) {
2009             for (int j = 0; j < i; ++j) {
2010                 cursor.toNextSibling(qNameValue);
2011             }
2012             cursor.removeXml();
2013         }
2014         cursor.dispose();
2015     }
2016
2017     public void updateFvImagesNameValue(int i, String name, String value){
2018
2019         XmlObject o = getfpdFlash().getFvImages();
2020         if (o == null) {
2021             return;
2022         }
2023
2024         QName qNameValue = new QName(xmlNs, "NameValue");
2025         XmlCursor cursor = o.newCursor();
2026         if (cursor.toChild(qNameValue)) {
2027             for (int j = 0; j < i; ++j) {
2028                 cursor.toNextSibling(qNameValue);
2029             }
2030             FvImagesDocument.FvImages.NameValue nv = (FvImagesDocument.FvImages.NameValue)cursor.getObject();
2031             nv.setName(name);
2032             nv.setValue(value);
2033         }
2034         cursor.dispose();
2035     }
2036
2037     public int getFvImagesNameValueCount() {
2038
2039         FvImagesDocument.FvImages fi = null;
2040         if ((fi = getfpdFlash().getFvImages()) == null || fi.getNameValueList() == null) {
2041             return 0;
2042         }
2043         return fi.getNameValueList().size();
2044     }
2045
2046     public void getFvImagesNameValues(String[][] nv) {
2047
2048         FvImagesDocument.FvImages fi = getfpdFlash().getFvImages();
2049         if (fi == null){
2050             return;
2051         }
2052         List<FvImagesDocument.FvImages.NameValue> l = fi.getNameValueList();
2053         int i = 0;
2054         ListIterator li = l.listIterator();
2055         while (li.hasNext()) {
2056             FvImagesDocument.FvImages.NameValue e = (FvImagesDocument.FvImages.NameValue) li
2057                                                                                                                     .next();
2058             nv[i][0] = e.getName();
2059             nv[i][1] = e.getValue();
2060
2061             i++;
2062         }
2063     }
2064
2065     public void genFvImagesFvImage(String[] names, String types, Map<String, String> options) {
2066
2067         FvImagesDocument.FvImages fis = null;
2068         if ((fis = getfpdFlash().getFvImages()) == null) {
2069             fis = getfpdFlash().addNewFvImages();
2070         }
2071
2072         //
2073         //gen FvImage with FvImageNames array
2074         //
2075         FvImagesDocument.FvImages.FvImage fi = fis.addNewFvImage();
2076         for (int i = 0; i < names.length; ++i) {
2077             fi.addFvImageNames(names[i]);
2078         }
2079         fi.setType(FvImageTypes.Enum.forString(types));
2080         if (options != null){
2081             setFvImagesFvImageFvImageOptions(options, fi);
2082         }
2083     }
2084
2085     private void setFvImagesFvImageFvImageOptions(Map<String, String> options, FvImagesDocument.FvImages.FvImage fi){
2086         FvImagesDocument.FvImages.FvImage.FvImageOptions fio = fi.getFvImageOptions();
2087         if (fio == null){
2088             fio = fi.addNewFvImageOptions();
2089         }
2090
2091         Set<String> key = options.keySet();
2092         Iterator<String> i = key.iterator();
2093         while (i.hasNext()) {
2094
2095             FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = fio.addNewNameValue();
2096             String k = (String)i.next();
2097
2098             nv.setName(k);
2099             nv.setValue((String)options.get(k));
2100
2101         }
2102
2103     }
2104
2105
2106     public void removeFvImagesFvImage(int i) {
2107
2108         XmlObject o = getfpdFlash().getFvImages();
2109         if (o == null) {
2110             return;
2111         }
2112
2113         QName qFvImage = new QName(xmlNs, "FvImage");
2114         XmlCursor cursor = o.newCursor();
2115         if (cursor.toChild(qFvImage)) {
2116             for (int j = 0; j < i; ++j) {
2117                 cursor.toNextSibling(qFvImage);
2118             }
2119             cursor.removeXml();
2120         }
2121         cursor.dispose();
2122     }
2123
2124     public void updateFvImagesFvImage(int i, String[] names, String types, Map<String, String> options){
2125
2126         XmlObject o = getfpdFlash().getFvImages();
2127         if (o == null) {
2128             return;
2129         }
2130         XmlCursor cursor = o.newCursor();
2131         QName qFvImage = new QName(xmlNs, "FvImage");
2132         if (cursor.toChild(qFvImage)) {
2133             for (int j = 0; j < i; ++j) {
2134                 cursor.toNextSibling(qFvImage);
2135             }
2136             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
2137             fi.setType(FvImageTypes.Enum.forString(types));
2138
2139             //
2140             // remove old FvImageNames before adding new ones
2141             //
2142             QName qFvImageNames = new QName(xmlNs, "FvImageNames");
2143             cursor.toChild(qFvImageNames);
2144             cursor.removeXml();
2145             while (cursor.toNextSibling(qFvImageNames)) {
2146                 cursor.removeXml();
2147             }
2148
2149             for (int k = 0; k < names.length; ++k) {
2150                 fi.addFvImageNames(names[k]);
2151             }
2152             //
2153             // remove old FvImageOptions before adding new options
2154             //
2155             QName qFvImageOptions = new QName(xmlNs, "FvImageOptions");
2156             cursor.toNextSibling(qFvImageOptions);
2157             cursor.removeXml();
2158
2159             setFvImagesFvImageFvImageOptions(options, fi);
2160         }
2161         cursor.dispose();
2162     }
2163
2164     public int getFvImagesFvImageCount() {
2165
2166         if (getfpdFlash().getFvImages() == null || getfpdFlash().getFvImages().getFvImageList() == null) {
2167             return 0;
2168         }
2169         return getfpdFlash().getFvImages().getFvImageList().size();
2170     }
2171
2172     /**Only Get Fv image setting - name and type.
2173      * @param saa
2174      */
2175     public void getFvImagesFvImages(String[][] saa) {
2176
2177         if (getfpdFlash().getFvImages() == null) {
2178             return;
2179         }
2180         List<FvImagesDocument.FvImages.FvImage> l = getfpdFlash().getFvImages().getFvImageList();
2181         if (l == null) {
2182             return;
2183         }
2184         ListIterator li = l.listIterator();
2185         int i = 0;
2186         while(li.hasNext()) {
2187             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)li.next();
2188             //
2189             // get FvImageNames array, space separated
2190             //
2191             List<String> lfn = fi.getFvImageNamesList();
2192             ListIterator lfni = lfn.listIterator();
2193             saa[i][0] = " ";
2194             while (lfni.hasNext()) {
2195                 saa[i][0] += (String)lfni.next();
2196                 saa[i][0] += " ";
2197             }
2198             saa[i][0] = saa[i][0].trim();
2199
2200             saa[i][1] = fi.getType()+"";
2201
2202             ++i;
2203         }
2204     }
2205
2206     /**Get FvImage Options for FvImage i
2207      * @param i the ith FvImage
2208      */
2209     public void getFvImagesFvImageOptions(int i, Map<String, String> m) {
2210         XmlObject o = getfpdFlash().getFvImages();
2211         if (o == null) {
2212             return;
2213         }
2214         XmlCursor cursor = o.newCursor();
2215         QName qFvImage = new QName(xmlNs, "FvImage");
2216         if (cursor.toChild(qFvImage)) {
2217             for (int j = 0; j < i; ++j) {
2218                 cursor.toNextSibling(qFvImage);
2219             }
2220             FvImagesDocument.FvImages.FvImage fi = (FvImagesDocument.FvImages.FvImage)cursor.getObject();
2221             if (fi.getFvImageOptions() == null || fi.getFvImageOptions().getNameValueList() == null){
2222                 return;
2223             }
2224             ListIterator<FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue> li = fi.getFvImageOptions().getNameValueList().listIterator();
2225             while(li.hasNext()){
2226                 FvImagesDocument.FvImages.FvImage.FvImageOptions.NameValue nv = li.next();
2227                 m.put(nv.getName(), nv.getValue());
2228             }
2229         }
2230     }
2231
2232     /**
2233      Get platform header element
2234      @return PlatformHeaderDocument.PlatformHeader
2235     **/
2236     public PlatformHeaderDocument.PlatformHeader getFpdHdr() {
2237         if (fpdHdr == null) {
2238             fpdHdr = fpdRoot.addNewPlatformHeader();
2239         }
2240         genPlatformDefsSkuInfo("0", "DEFAULT");
2241         return fpdHdr;
2242     }
2243
2244     public String getFpdHdrPlatformName() {
2245         return getFpdHdr().getPlatformName();
2246     }
2247
2248     public String getFpdHdrGuidValue() {
2249         return getFpdHdr().getGuidValue();
2250     }
2251
2252     public String getFpdHdrVer() {
2253         return getFpdHdr().getVersion();
2254     }
2255
2256     public String getFpdHdrAbs() {
2257         return getFpdHdr().getAbstract();
2258     }
2259
2260     public String getFpdHdrDescription() {
2261         return getFpdHdr().getDescription();
2262     }
2263
2264     public String getFpdHdrCopyright() {
2265         return getFpdHdr().getCopyright();
2266     }
2267
2268     public String getFpdHdrLicense() {
2269         LicenseDocument.License l = getFpdHdr().getLicense();
2270         if (l == null) {
2271             return null;
2272         }
2273         return l.getStringValue();
2274     }
2275
2276     public String getFpdHdrUrl() {
2277         LicenseDocument.License l = getFpdHdr().getLicense();
2278         if (l == null) {
2279             return null;
2280         }
2281         return l.getURL();
2282     }
2283
2284     public String getFpdHdrSpec() {
2285
2286         return "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052";
2287 //        return getFpdHdr().getSpecification();
2288     }
2289
2290     public void setFpdHdrPlatformName(String name){
2291         getFpdHdr().setPlatformName(name);
2292     }
2293
2294     public void setFpdHdrGuidValue(String guid){
2295         getFpdHdr().setGuidValue(guid);
2296     }
2297
2298     public void setFpdHdrVer(String v){
2299         getFpdHdr().setVersion(v);
2300     }
2301
2302     public void setFpdHdrAbs(String abs) {
2303         getFpdHdr().setAbstract(abs);
2304     }
2305
2306     public void setFpdHdrDescription(String desc){
2307         getFpdHdr().setDescription(desc);
2308     }
2309
2310     public void setFpdHdrCopyright(String cr) {
2311         getFpdHdr().setCopyright(cr);
2312     }
2313
2314     public void setFpdHdrLicense(String license){
2315         LicenseDocument.License l = getFpdHdr().getLicense();
2316         if (l == null) {
2317             getFpdHdr().addNewLicense().setStringValue(license);
2318         }
2319         else {
2320             l.setStringValue(license);
2321         }
2322     }
2323
2324     public void setFpdHdrUrl(String url){
2325         LicenseDocument.License l = getFpdHdr().getLicense();
2326
2327         l.setURL(url);
2328
2329     }
2330
2331     public void setFpdHdrSpec(String s){
2332         s = "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052";
2333         getFpdHdr().setSpecification(s);
2334     }
2335     /**
2336     Save the processed xml contents to file
2337
2338     @param fpdFile The file to save xml contents
2339     @throws IOException Exceptions during file operation
2340     **/
2341     public void saveAs(File fpdFile) throws IOException {
2342
2343        XmlOptions options = new XmlOptions();
2344
2345        options.setCharacterEncoding("UTF-8");
2346        options.setSavePrettyPrint();
2347        options.setSavePrettyPrintIndent(2);
2348        try {
2349            fpdd.save(fpdFile, options);
2350        } catch (IOException e) {
2351            e.printStackTrace();
2352        }
2353
2354     }
2355
2356     private String listToString(List l) {
2357         if (l == null) {
2358             return null;
2359         }
2360         String s = " ";
2361         ListIterator li = l.listIterator();
2362         while(li.hasNext()) {
2363             s += li.next();
2364             s += " ";
2365         }
2366         return s.trim();
2367     }
2368 }
2369
2370 class PcdItemTypeConflictException extends Exception {
2371
2372     /**
2373      *
2374      */
2375     private static final long serialVersionUID = 1L;
2376     private String details = null;
2377
2378     PcdItemTypeConflictException(String info){
2379         details = info;
2380     }
2381
2382     public String getMessage() {
2383         return details;
2384     }
2385 }
2386
2387 class PcdDeclNotFound extends Exception {
2388
2389     /**
2390      *
2391      */
2392     private static final long serialVersionUID = 1L;
2393     private String details = null;
2394
2395     PcdDeclNotFound(String info) {
2396         details = info;
2397     }
2398
2399     public String getMessage() {
2400         return details;
2401     }
2402 }
2403
2404 class PcdValueMalFormed extends Exception {
2405
2406     /**
2407      *
2408      */
2409     private static final long serialVersionUID = 1L;
2410     private String details = null;
2411
2412     PcdValueMalFormed(String info) {
2413         details = info;
2414     }
2415
2416     public String getMessage() {
2417         return details;
2418     }
2419 }