Tools/Source/FrameworkWizard/src/org/tianocore/frameworkwizard/packaging/ui/SpdFileContents.java

   1 /** @file
   2   Java class SpdFileContents is used to parse spd 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.packaging.ui;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.util.ArrayList;
  18 import java.util.List;
  19 import java.util.ListIterator;
  20 import java.util.Vector;
  21
  22
  23 import org.apache.xmlbeans.XmlObject;
  24 import org.apache.xmlbeans.XmlOptions;
  25 import org.apache.xmlbeans.XmlCursor;
  26
  27 import org.tianocore.GuidDeclarationsDocument;
  28
  29 import org.tianocore.LibraryClassDeclarationsDocument;
  30
  31 import org.tianocore.ModuleTypeDef;
  32 import org.tianocore.MsaFilesDocument;
  33 import org.tianocore.PackageDefinitionsDocument;
  34 import org.tianocore.PackageHeadersDocument;
  35 import org.tianocore.PackageSurfaceAreaDocument;
  36 import org.tianocore.PcdDataTypes;
  37 import org.tianocore.PcdDeclarationsDocument;
  38 import org.tianocore.PpiDeclarationsDocument;
  39 import org.tianocore.ProtocolDeclarationsDocument;
  40 import org.tianocore.SpdHeaderDocument;
  41 import org.tianocore.GuidDeclarationsDocument.GuidDeclarations;
  42
  43 /**
  44  This class processes spd file contents such as add remove xml elements.
  45
  46  @since PackageEditor 1.0
  47 **/
  48
  49 public class SpdFileContents {
  50
  51     private File file = null;
  52
  53     private PackageSurfaceAreaDocument psad = null;
  54
  55     private PackageSurfaceAreaDocument.PackageSurfaceArea psaRoot = null;
  56
  57     private SpdHeaderDocument.SpdHeader spdHdr = null;
  58
  59     private PackageDefinitionsDocument.PackageDefinitions spdPkgDefs = null;
  60
  61     private LibraryClassDeclarationsDocument.LibraryClassDeclarations spdLibClassDeclarations = null;
  62
  63     private MsaFilesDocument.MsaFiles spdMsaFiles = null;
  64
  65     private PackageHeadersDocument.PackageHeaders spdModHdrs = null;
  66
  67     private GuidDeclarationsDocument.GuidDeclarations spdGuidDeclarations = null;
  68
  69     private ProtocolDeclarationsDocument.ProtocolDeclarations spdProtocolDeclarations = null;
  70
  71     private PpiDeclarationsDocument.PpiDeclarations spdPpiDeclarations = null;
  72
  73     private PcdDeclarationsDocument.PcdDeclarations spdPcdDefinitions = null;
  74
  75     /**
  76      Constructor to create a new spd file
  77     **/
  78     public SpdFileContents() {
  79
  80         psad = PackageSurfaceAreaDocument.Factory.newInstance();
  81         psaRoot = psad.addNewPackageSurfaceArea();
  82
  83     }
  84
  85     /**
  86      Constructor for existing document object
  87        @param psa
  88     **/
  89     public SpdFileContents(PackageSurfaceAreaDocument.PackageSurfaceArea psa) {
  90         psaRoot = psa;
  91         spdHdr = psaRoot.getSpdHeader();
  92         spdPkgDefs = psaRoot.getPackageDefinitions();
  93     }
  94     /**
  95      Constructor based on an existing spd file
  96
  97      @param f Existing spd file
  98     **/
  99     public SpdFileContents(File f) {
 100         try {
 101             psad = PackageSurfaceAreaDocument.Factory.parse(f);
 102             psaRoot = psad.getPackageSurfaceArea();
 103             file = f;
 104         } catch (Exception e) {
 105             System.out.println(e.toString());
 106         }
 107     }
 108
 109     /**
 110      Remove existing pcd definitions elements using XmlCursor
 111     **/
 112     public void removeSpdPcdDefinition() {
 113         XmlObject o = psaRoot.getPcdDeclarations();
 114         if (o == null)
 115             return;
 116         XmlCursor cursor = o.newCursor();
 117         cursor.removeXml();
 118         spdPcdDefinitions = null;
 119         cursor.dispose();
 120     }
 121
 122     public void removeSpdPcdDefinition(int i){
 123         XmlObject o = psaRoot.getPcdDeclarations();
 124         if (o == null)
 125             return;
 126         XmlCursor cursor = o.newCursor();
 127         if (cursor.toFirstChild()) {
 128             for (int j = 0; j < i; ++j) {
 129                 cursor.toNextSibling();
 130             }
 131             cursor.removeXml();
 132             if (getSpdPcdDefinitionCount() == 0) {
 133                 cursor.toParent();
 134                 cursor.removeXml();
 135             }
 136         }
 137         cursor.dispose();
 138     }
 139
 140     /**
 141      Remove existing ppi declarations using XmlCursor
 142     **/
 143     public void removeSpdPpiDeclaration() {
 144         XmlObject o = psaRoot.getPpiDeclarations();
 145         if (o == null)
 146             return;
 147         XmlCursor cursor = o.newCursor();
 148         cursor.removeXml();
 149         spdPpiDeclarations = null;
 150         cursor.dispose();
 151     }
 152
 153     public void removeSpdPpiDeclaration(int i){
 154         XmlObject o = psaRoot.getPpiDeclarations();
 155         if (o == null)
 156             return;
 157         XmlCursor cursor = o.newCursor();
 158         if (cursor.toFirstChild()) {
 159             for (int j = 0; j < i; ++j) {
 160                 cursor.toNextSibling();
 161             }
 162             cursor.removeXml();
 163             if (getSpdPpiDeclarationCount() == 0){
 164                 cursor.toParent();
 165                 cursor.removeXml();
 166             }
 167         }
 168         cursor.dispose();
 169     }
 170     /**
 171      Remove existing protocols declarations using XmlCursor
 172     **/
 173     public void removeSpdProtocolDeclaration() {
 174         XmlObject o = psaRoot.getProtocolDeclarations();
 175         if (o == null)
 176             return;
 177         XmlCursor cursor = o.newCursor();
 178         cursor.removeXml();
 179         spdProtocolDeclarations = null;
 180         cursor.dispose();
 181     }
 182
 183     public void removeSpdProtocolDeclaration(int i) {
 184         XmlObject o = psaRoot.getProtocolDeclarations();
 185         if (o == null)
 186             return;
 187         XmlCursor cursor = o.newCursor();
 188         if (cursor.toFirstChild()) {
 189             for (int j = 0; j < i; ++j) {
 190                 cursor.toNextSibling();
 191             }
 192             cursor.removeXml();
 193             if (getSpdProtocolDeclarationCount() == 0) {
 194                 cursor.toParent();
 195                 cursor.removeXml();
 196             }
 197         }
 198         cursor.dispose();
 199     }
 200     /**
 201      Remove existing GUID declarations using XmlCursor
 202     **/
 203     public void removeSpdGuidDeclaration() {
 204         XmlObject o = psaRoot.getGuidDeclarations();
 205         if (o == null)
 206             return;
 207         XmlCursor cursor = o.newCursor();
 208         cursor.removeXml();
 209         spdGuidDeclarations = null;
 210         cursor.dispose();
 211     }
 212
 213     public void removeSpdGuidDeclaration(int i) {
 214         XmlObject o = psaRoot.getGuidDeclarations();
 215         if (o == null)
 216             return;
 217         XmlCursor cursor = o.newCursor();
 218         if (cursor.toFirstChild()) {
 219             for (int j = 0; j < i; ++j) {
 220                 cursor.toNextSibling();
 221             }
 222             cursor.removeXml();
 223             if (getSpdGuidDeclarationCount() == 0) {
 224                 cursor.toParent();
 225                 cursor.removeXml();
 226             }
 227         }
 228         cursor.dispose();
 229     }
 230
 231     /**
 232      Remove existing spd package include files using XmlCursor
 233     **/
 234     public void removeSpdPkgHeader() {
 235         XmlObject o = psaRoot.getPackageHeaders();
 236         if (o == null)
 237             return;
 238         XmlCursor cursor = o.newCursor();
 239         cursor.removeXml();
 240         spdModHdrs = null;
 241         cursor.dispose();
 242     }
 243
 244     public void removeSpdPkgHeader(int i){
 245         XmlObject o = psaRoot.getPackageHeaders();
 246         if (o == null)
 247             return;
 248         XmlCursor cursor = o.newCursor();
 249         if (cursor.toFirstChild()) {
 250             for (int j = 0; j < i; ++j) {
 251                 cursor.toNextSibling();
 252             }
 253             cursor.removeXml();
 254             if (getSpdPackageHeaderCount() == 0) {
 255                 cursor.toParent();
 256                 cursor.removeXml();
 257             }
 258         }
 259         cursor.dispose();
 260     }
 261
 262     /**
 263      Remove existing msa files using XmlCursor
 264     **/
 265     public void removeSpdMsaFile() {
 266         XmlObject o = psaRoot.getMsaFiles();
 267         if (o == null)
 268             return;
 269         XmlCursor cursor = o.newCursor();
 270         cursor.removeXml();
 271         spdMsaFiles = null;
 272         cursor.dispose();
 273     }
 274
 275     public void removeSpdMsaFile(int i){
 276         XmlObject o = psaRoot.getMsaFiles();
 277         if (o == null)
 278             return;
 279         XmlCursor cursor = o.newCursor();
 280         if (cursor.toFirstChild()) {
 281             for (int j = 0; j < i; ++j) {
 282                 cursor.toNextSibling();
 283             }
 284             cursor.removeXml();
 285             if (getSpdMsaFileCount() == 0) {
 286                 cursor.toParent();
 287                 cursor.removeXml();
 288             }
 289         }
 290         cursor.dispose();
 291     }
 292
 293     /**
 294      Remove existing library class declarations using XmlCursor
 295     **/
 296     public void removeSpdLibClass() {
 297         XmlObject o = psaRoot.getLibraryClassDeclarations();
 298         if (o == null)
 299             return;
 300         XmlCursor cursor = o.newCursor();
 301         cursor.removeXml();
 302         spdLibClassDeclarations = null;
 303         cursor.dispose();
 304     }
 305
 306     public void removeSpdLibClass(int i) {
 307         XmlObject o = psaRoot.getLibraryClassDeclarations();
 308         if (o == null)
 309             return;
 310         XmlCursor cursor = o.newCursor();
 311         if (cursor.toFirstChild()) {
 312             for (int j = 0; j < i; ++j) {
 313                 cursor.toNextSibling();
 314             }
 315             cursor.removeXml();
 316             if (getSpdLibClassDeclarationCount() == 0) {
 317                 cursor.toParent();
 318                 cursor.removeXml();
 319             }
 320         }
 321         cursor.dispose();
 322     }
 323
 324     public void updateSpdLibClass(int i, String lib, String hdr, String hlp, String clsUsage, String instanceVer, String hdrAttribArch, String hdrAttribModType) {
 325         XmlObject o = psaRoot.getLibraryClassDeclarations();
 326         if (o == null)
 327             return;
 328
 329         XmlCursor cursor = o.newCursor();
 330         if (cursor.toFirstChild()) {
 331             for (int j = 0; j < i; ++j) {
 332                 cursor.toNextSibling();
 333             }
 334             LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass lc = (LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass)cursor.getObject();
 335             lc.setName(lib);
 336             lc.setIncludeHeader(hdr);
 337             lc.setHelpText(hlp);
 338             if (clsUsage != null) {
 339               lc.setRecommendedInstanceGuid(clsUsage);
 340               if (instanceVer != null){
 341                 lc.setRecommendedInstanceVersion(instanceVer);
 342               } else {
 343                 lc.unsetRecommendedInstanceVersion();
 344               }
 345             } else {
 346               lc.unsetRecommendedInstanceGuid();
 347               lc.unsetRecommendedInstanceVersion();
 348             }
 349
 350             if (stringToList(hdrAttribArch) != null){
 351               lc.setSupArchList(stringToList(hdrAttribArch));
 352             } else {
 353               lc.unsetSupArchList();
 354             }
 355             if (stringToList(hdrAttribModType) != null){
 356               lc.setSupModuleList(stringToList(hdrAttribModType));
 357             } else {
 358               lc.unsetSupModuleList();
 359             }
 360         }
 361
 362         cursor.dispose();
 363     }
 364
 365     public void updateSpdMsaFile(int i, String msaFile, String mName, String v, String g){
 366         XmlObject o = psaRoot.getMsaFiles();
 367         if (o == null)
 368             return;
 369
 370         XmlCursor cursor = o.newCursor();
 371         if (cursor.toFirstChild()) {
 372             for (int j = 0; j < i; ++j) {
 373                 cursor.toNextSibling();
 374             }
 375             cursor.setTextValue(msaFile);
 376
 377         }
 378
 379         cursor.dispose();
 380     }
 381
 382     public void updateSpdGuidDecl(int i, String name, String cName, String guid, String hlp, String archList,
 383                                   String modTypeList, String guidTypeList){
 384         XmlObject o = psaRoot.getGuidDeclarations();
 385         if (o == null){
 386             return;
 387         }
 388
 389         XmlCursor cursor = o.newCursor();
 390         if (cursor.toFirstChild()) {
 391             for (int j = 0; j < i; ++j) {
 392                 cursor.toNextSibling();
 393             }
 394             GuidDeclarationsDocument.GuidDeclarations.Entry e = (GuidDeclarationsDocument.GuidDeclarations.Entry)cursor.getObject();
 395             e.setName(name);
 396             e.setCName(cName);
 397             e.setGuidValue(guid);
 398             e.setHelpText(hlp);
 399             if (stringToList(guidTypeList) != null) {
 400                 e.setGuidTypeList(stringToList(guidTypeList));
 401             }
 402             else{
 403                 e.unsetGuidTypeList();
 404             }
 405             if (stringToList(archList) != null){
 406                 e.setSupArchList(stringToList(archList));
 407             }
 408             else{
 409                 e.unsetSupArchList();
 410             }
 411             if (stringToList(modTypeList) != null) {
 412                 e.setSupModuleList(stringToList(modTypeList));
 413             }
 414             else{
 415                 e.unsetSupModuleList();
 416             }
 417
 418         }
 419         cursor.dispose();
 420     }
 421
 422     public void updateSpdPpiDecl(int i, String name, String cName, String guid, String hlp, String archList,
 423                                  String modTypeList){
 424         XmlObject o = psaRoot.getPpiDeclarations();
 425         if (o == null){
 426             return;
 427         }
 428
 429         XmlCursor cursor = o.newCursor();
 430         if (cursor.toFirstChild()) {
 431             for (int j = 0; j < i; ++j) {
 432                 cursor.toNextSibling();
 433             }
 434             PpiDeclarationsDocument.PpiDeclarations.Entry e = (PpiDeclarationsDocument.PpiDeclarations.Entry)cursor.getObject();
 435             e.setName(name);
 436             e.setCName(cName);
 437             e.setGuidValue(guid);
 438             e.setHelpText(hlp);
 439             if (stringToList(archList) != null){
 440                 e.setSupArchList(stringToList(archList));
 441             }
 442             else{
 443                 e.unsetSupArchList();
 444             }
 445             if (stringToList(modTypeList) != null) {
 446                 e.setSupModuleList(stringToList(modTypeList));
 447             }
 448             else{
 449                 e.unsetSupModuleList();
 450             }
 451         }
 452         cursor.dispose();
 453     }
 454
 455     public void updateSpdProtocolDecl(int i, String name, String cName, String guid, String hlp, String archList,
 456                                       String modTypeList){
 457         XmlObject o = psaRoot.getProtocolDeclarations();
 458         if (o == null){
 459             return;
 460         }
 461
 462         XmlCursor cursor = o.newCursor();
 463         if (cursor.toFirstChild()) {
 464             for (int j = 0; j < i; ++j) {
 465                 cursor.toNextSibling();
 466             }
 467             ProtocolDeclarationsDocument.ProtocolDeclarations.Entry e = (ProtocolDeclarationsDocument.ProtocolDeclarations.Entry)cursor.getObject();
 468             e.setName(name);
 469             e.setCName(cName);
 470             e.setGuidValue(guid);
 471             e.setHelpText(hlp);
 472             if (stringToList(archList) != null){
 473                 e.setSupArchList(stringToList(archList));
 474             }
 475             else{
 476                 e.unsetSupArchList();
 477             }
 478             if (stringToList(modTypeList) != null) {
 479                 e.setSupModuleList(stringToList(modTypeList));
 480             }
 481             else{
 482                 e.unsetSupModuleList();
 483             }
 484         }
 485         cursor.dispose();
 486     }
 487
 488     public void updateSpdPkgHdr(int i, String pkgName, String hdrName){
 489         XmlObject o = psaRoot.getPackageHeaders();
 490         if (o == null){
 491             return;
 492         }
 493
 494         XmlCursor cursor = o.newCursor();
 495         if (cursor.toFirstChild()) {
 496             for (int j = 0; j < i; ++j) {
 497                 cursor.toNextSibling();
 498             }
 499
 500             PackageHeadersDocument.PackageHeaders.IncludePkgHeader iph = (PackageHeadersDocument.PackageHeaders.IncludePkgHeader)cursor.getObject();
 501             iph.setModuleType(ModuleTypeDef.Enum.forString(pkgName));
 502             iph.setStringValue(hdrName);
 503         }
 504         cursor.dispose();
 505     }
 506
 507     public void updateSpdPcdDefinition(int i, String cName, String token, String dataType, String pcdItemTypes,
 508                                        String spaceGuid, String defaultString, String help, String archList, String modTypeList){
 509         XmlObject o = psaRoot.getPcdDeclarations();
 510         if (o == null)
 511             return;
 512         XmlCursor cursor = o.newCursor();
 513         if (cursor.toFirstChild()) {
 514             for (int j = 0; j < i; ++j) {
 515                 cursor.toNextSibling();
 516             }
 517             PcdDeclarationsDocument.PcdDeclarations.PcdEntry e = (PcdDeclarationsDocument.PcdDeclarations.PcdEntry)cursor.getObject();
 518             e.setCName(cName);
 519             e.setToken(token);
 520             e.setDatumType(PcdDataTypes.Enum.forString(dataType));
 521             if (pcdItemTypes != null && pcdItemTypes.length() > 0) {
 522                 String usage[] = pcdItemTypes.split("( )+");
 523                 List<String> l = new ArrayList<String>();
 524                 for (int k = 0; k < usage.length; ++k) {
 525                     l.add(usage[k]);
 526                 }
 527                 e.setValidUsage(l);
 528             }
 529
 530             e.setTokenSpaceGuidCName(spaceGuid);
 531             e.setDefaultValue(defaultString);
 532             e.setHelpText(help);
 533             if (archList != null && archList.length() > 0){
 534                 e.setSupArchList(stringToList(archList));
 535             }
 536             if (modTypeList != null && modTypeList.length() > 0){
 537                 e.setSupModuleList(stringToList(modTypeList));
 538             }
 539         }
 540         cursor.dispose();
 541     }
 542     /**
 543      Get spd file header contents into String array
 544
 545      @param s Caller allocated String array
 546     **/
 547     public void getSpdHdrDetails(String[] s) {
 548         if (getSpdHdr() == null) {
 549             spdHdr = psaRoot.addNewSpdHeader();
 550         }
 551         s[0] = getSpdHdrPkgName();
 552         s[1] = getSpdHdr().getGuidValue();
 553         s[2] = getSpdHdrVer();
 554 //        s[3] = getSpdHdr().getAbstract();
 555         s[4] = getSpdHdr().getDescription();
 556         s[5] = getSpdHdr().getCopyright();
 557         s[6] = getSpdHdrLicense();
 558
 559     }
 560
 561     /**
 562      Get the number of library class declarations from the size of List
 563
 564      @return int
 565     **/
 566     public int getSpdLibClassDeclarationCount() {
 567         if (psaRoot.getLibraryClassDeclarations() == null
 568             || psaRoot.getLibraryClassDeclarations().getLibraryClassList() == null) {
 569             return 0;
 570         }
 571         return psaRoot.getLibraryClassDeclarations().getLibraryClassList().size();
 572     }
 573
 574     /**
 575      Get available library class declaration into String array
 576      @param libClass Caller allocated two-dimentional String array
 577     **/
 578     public void getSpdLibClassDeclarations(String[][] libClass) {
 579         if (psaRoot.getLibraryClassDeclarations() == null){
 580             return;
 581         }
 582
 583         List<LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass> l = psaRoot.getLibraryClassDeclarations().getLibraryClassList();
 584         int i = 0;
 585         ListIterator li = l.listIterator();
 586         while (li.hasNext()) {
 587             LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass lc = (LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass) li.next();
 588             if (lc != null) {
 589                 libClass[i][0] = lc.getName();
 590                 libClass[i][1] = lc.getIncludeHeader();
 591                 libClass[i][2] = lc.getHelpText();
 592 // LAH added logic so you cannot set the version unless the GUID is defined.
 593 /* LAH do not set now
 594                 if (lc.getRecommendedInstanceGuid() != null) {
 595                   libClass[i][3] = lc.getRecommendedInstanceGuid();
 596                   if (lc.getRecommendedInstanceVersion() != null) {
 597                     libClass[i][4] = lc.getRecommendedInstanceVersion();
 598                   }
 599                 }
 600 */
 601                 if (lc.getSupArchList() != null) {
 602                     libClass[i][5] = listToString(lc.getSupArchList());
 603                 }
 604                 if (lc.getSupModuleList() != null) {
 605                     libClass[i][6] = listToString(lc.getSupModuleList());
 606                 }
 607
 608             }
 609
 610             i++;
 611         }
 612
 613     }
 614
 615     /**
 616     Get the number of Msa files from the size of List
 617
 618     @return int
 619    **/
 620     public int getSpdMsaFileCount() {
 621         if (psaRoot.getMsaFiles() == null || psaRoot.getMsaFiles().getFilenameList() == null) {
 622             return 0;
 623         }
 624         return psaRoot.getMsaFiles().getFilenameList().size();
 625     }
 626
 627     /**
 628     Get available Msa file into String array
 629
 630     @param msaFile Caller allocated two-dimentional String array
 631    **/
 632     public void getSpdMsaFiles(String[][] msaFile) {
 633         if (psaRoot.getMsaFiles() == null) {
 634             return;
 635         }
 636         List<String> l = psaRoot.getMsaFiles().getFilenameList();
 637         int i = 0;
 638         ListIterator li = l.listIterator();
 639         while (li.hasNext()) {
 640             msaFile[i][0] = (String)li.next();
 641
 642             i++;
 643         }
 644     }
 645
 646     /**
 647     Get the number of include header files in PackageHeaders from the size of List
 648
 649     @return int
 650    **/
 651     public int getSpdPackageHeaderCount() {
 652         if (psaRoot.getPackageHeaders() == null || psaRoot.getPackageHeaders().getIncludePkgHeaderList() == null) {
 653             return 0;
 654         }
 655         return psaRoot.getPackageHeaders().getIncludePkgHeaderList().size();
 656     }
 657
 658     /**
 659     Get available package header contents into String array
 660
 661     @param pkgHeader Caller allocated two-dimentional String array
 662    **/
 663     public void getSpdPackageHeaders(String[][] pkgHeader) {
 664         if (psaRoot.getPackageHeaders() == null) {
 665             return;
 666         }
 667
 668         List<PackageHeadersDocument.PackageHeaders.IncludePkgHeader> l = psaRoot.getPackageHeaders().getIncludePkgHeaderList();
 669         int i = 0;
 670         ListIterator li = l.listIterator();
 671         while (li.hasNext()) {
 672             PackageHeadersDocument.PackageHeaders.IncludePkgHeader ih = (PackageHeadersDocument.PackageHeaders.IncludePkgHeader) li.next();
 673             if (ih.getModuleType() != null) {
 674                 pkgHeader[i][0] = ih.getModuleType().toString();
 675             }
 676
 677             pkgHeader[i][1] = ih.getStringValue();
 678             i++;
 679         }
 680     }
 681
 682     /**
 683     Get the number of GUID declarations from the size of List
 684
 685     @return int
 686    **/
 687     public int getSpdGuidDeclarationCount() {
 688         if (psaRoot.getGuidDeclarations() == null || psaRoot.getGuidDeclarations().getEntryList() == null) {
 689             return 0;
 690         }
 691         return psaRoot.getGuidDeclarations().getEntryList().size();
 692     }
 693
 694     /**
 695     Get available Guid declaration contents into String array
 696
 697     @param guid Caller allocated two-dimentional String array
 698    **/
 699     public void getSpdGuidDeclarations(String[][] guid) {
 700         if (psaRoot.getGuidDeclarations() == null) {
 701             return;
 702         }
 703
 704         List<GuidDeclarationsDocument.GuidDeclarations.Entry> l = psaRoot.getGuidDeclarations().getEntryList();
 705         int i = 0;
 706         ListIterator li = l.listIterator();
 707         while (li.hasNext()) {
 708             GuidDeclarationsDocument.GuidDeclarations.Entry e = (GuidDeclarationsDocument.GuidDeclarations.Entry) li
 709                                                                                                                     .next();
 710             guid[i][0] = e.getName();
 711             guid[i][1] = e.getCName();
 712             if (e.getGuidValue() != null) {
 713                 guid[i][2] = e.getGuidValue();
 714             }
 715             guid[i][3] = e.getHelpText();
 716             guid[i][4] = listToString(e.getSupArchList());
 717             guid[i][5] = listToString(e.getSupModuleList());
 718             guid[i][6] = listToString(e.getGuidTypeList());
 719             i++;
 720         }
 721     }
 722
 723     /**
 724     Get the number of protocol declarations from the size of List
 725
 726     @return int
 727    **/
 728     public int getSpdProtocolDeclarationCount() {
 729         if (psaRoot.getProtocolDeclarations() == null || psaRoot.getProtocolDeclarations().getEntryList() == null) {
 730             return 0;
 731         }
 732         return psaRoot.getProtocolDeclarations().getEntryList().size();
 733     }
 734
 735     /**
 736     Get available protocol declaration contents into String array
 737
 738     @param protocol Caller allocated two-dimentional String array
 739    **/
 740     public void getSpdProtocolDeclarations(String[][] protocol) {
 741         if (psaRoot.getProtocolDeclarations() == null) {
 742             return;
 743         }
 744
 745         List<ProtocolDeclarationsDocument.ProtocolDeclarations.Entry> l = psaRoot.getProtocolDeclarations()
 746                                                                                  .getEntryList();
 747         int i = 0;
 748         ListIterator li = l.listIterator();
 749         while (li.hasNext()) {
 750             ProtocolDeclarationsDocument.ProtocolDeclarations.Entry e = (ProtocolDeclarationsDocument.ProtocolDeclarations.Entry) li
 751                                                                                                                                     .next();
 752             protocol[i][0] = e.getName();
 753             protocol[i][1] = e.getCName();
 754             if (e.getGuidValue() != null) {
 755                 protocol[i][2] = e.getGuidValue();
 756             }
 757             protocol[i][3] = e.getHelpText();
 758             protocol[i][4] = listToString(e.getSupArchList());
 759             protocol[i][5] = listToString(e.getSupModuleList());
 760             i++;
 761         }
 762     }
 763
 764     /**
 765     Get the number of Ppi declarations from the size of List
 766
 767     @return int
 768    **/
 769     public int getSpdPpiDeclarationCount() {
 770         if (psaRoot.getPpiDeclarations() == null || psaRoot.getPpiDeclarations().getEntryList() == null) {
 771             return 0;
 772         }
 773         return psaRoot.getPpiDeclarations().getEntryList().size();
 774     }
 775
 776     /**
 777     Get available Ppi declaration contents into String array
 778
 779     @param ppi Caller allocated two-dimentional String array
 780    **/
 781     public void getSpdPpiDeclarations(String[][] ppi) {
 782         if (psaRoot.getPpiDeclarations() == null) {
 783             return;
 784         }
 785
 786         List<PpiDeclarationsDocument.PpiDeclarations.Entry> l = psaRoot.getPpiDeclarations().getEntryList();
 787         int i = 0;
 788         ListIterator li = l.listIterator();
 789         while (li.hasNext()) {
 790             PpiDeclarationsDocument.PpiDeclarations.Entry e = (PpiDeclarationsDocument.PpiDeclarations.Entry) li.next();
 791             ppi[i][0] = e.getName();
 792             ppi[i][1] = e.getCName();
 793             if (e.getGuidValue() != null) {
 794                 ppi[i][2] = e.getGuidValue();
 795             }
 796             ppi[i][3] = e.getHelpText();
 797             ppi[i][4] = listToString(e.getSupArchList());
 798             ppi[i][5] = listToString(e.getSupModuleList());
 799
 800             i++;
 801         }
 802     }
 803
 804     /**
 805     Get the number of Pcd definitions from the size of List
 806
 807     @return int
 808    **/
 809     public int getSpdPcdDefinitionCount() {
 810         if (psaRoot.getPcdDeclarations() == null || psaRoot.getPcdDeclarations().getPcdEntryList() == null) {
 811             return 0;
 812         }
 813         return psaRoot.getPcdDeclarations().getPcdEntryList().size();
 814     }
 815
 816     /**
 817     Get available Pcd definition contents into String array
 818
 819     @param pcd Caller allocated two-dimentional String array
 820    **/
 821     public void getSpdPcdDefinitions(String[][] pcd, String pcdUsage[][]) {
 822         if (psaRoot.getPcdDeclarations() == null) {
 823             return;
 824         }
 825
 826         List<PcdDeclarationsDocument.PcdDeclarations.PcdEntry> l = psaRoot.getPcdDeclarations().getPcdEntryList();
 827         int i = 0;
 828         while (i < l.size()) {
 829             PcdDeclarationsDocument.PcdDeclarations.PcdEntry e = (PcdDeclarationsDocument.PcdDeclarations.PcdEntry)l.get(i);
 830             pcd[i][0] = e.getCName();
 831             pcd[i][1] = e.getToken() + "";
 832             pcd[i][2] = e.getTokenSpaceGuidCName();
 833             if (e.getDatumType() != null) {
 834                 pcd[i][3] = e.getDatumType().toString();
 835             }
 836             pcd[i][4] = e.getDefaultValue()+"";
 837             pcd[i][5] = e.getHelpText();
 838             String archList = listToString(e.getSupArchList());
 839             if (archList != null) {
 840                 pcd[i][6] = archList;
 841             }
 842             String modTypeList = listToString(e.getSupModuleList());
 843             if (modTypeList != null) {
 844                 pcd[i][7] = modTypeList;
 845             }
 846
 847             int j = 0;
 848             while (j < e.getValidUsage().size() && j < 5) {
 849                 pcdUsage[i][j] = (String)e.getValidUsage().get(j);
 850                 ++j;
 851             }
 852             i++;
 853         }
 854     }
 855
 856     /**
 857      Save the processed xml contents to file
 858
 859      @param spdFile The file to save xml contents
 860      @throws IOException Exceptions during file operation
 861     **/
 862     public void saveAs(File spdFile) throws IOException {
 863
 864         XmlOptions options = new XmlOptions();
 865
 866         options.setCharacterEncoding("UTF-8");
 867         options.setSavePrettyPrint();
 868         options.setSavePrettyPrintIndent(2);
 869         try {
 870             psad.save(spdFile, options);
 871         } catch (IOException e) {
 872             e.printStackTrace();
 873         }
 874
 875     }
 876
 877     /**
 878      Generate SpdHeader contents using parameters passed in.
 879
 880      @param pkgName PackageName
 881      @param pkgGuid Guid
 882      @param pkgVer Version
 883      @param pkgAbs Abstract
 884      @param pkgDes Description
 885      @param pkgCpRight Copyright
 886      @param pkgLicense License
 887      @param pkgCreateDate Created
 888      @param pkgUpdateDate Updated
 889      @param pkgURL URL
 890      @param pkgType PackageType
 891      @param pkgRdOnly ReadOnly
 892      @param pkgRePkg RePackage
 893      @param pkgSpec Reserved
 894      @param pkgOutDir Reserved
 895     **/
 896     public void genSpdHeader(String pkgName, String pkgGuid, String pkgVer, String pkgAbs, String pkgDes,
 897                              String pkgCpRight, String pkgLicense, String pkgCreateDate, String pkgUpdateDate,
 898                              String pkgURL, String pkgType, String pkgRdOnly, String pkgRePkg, String pkgSpec,
 899                              String pkgOutDir) {
 900         if (getSpdHdr() == null) {
 901             spdHdr = psaRoot.addNewSpdHeader();
 902         }
 903
 904         setSpdHdrPkgName(pkgName);
 905         setSpdHdrGuidValue(pkgGuid);
 906         setSpdHdrVer(pkgVer);
 907         setSpdHdrAbs(pkgAbs);
 908         setSpdHdrDescription(pkgDes);
 909         setSpdHdrCopyright(pkgCpRight);
 910         setSpdHdrLicense(pkgLicense);
 911
 912
 913         setSpdHdrSpec(pkgSpec);
 914     }
 915
 916     /**
 917      Generate library class declaration element using parameters passed in
 918
 919      @param libClassBaseName LibraryClass element value
 920      @param libClassUsage Reserved
 921      @param incHdrFileName IncludeHeader element value
 922      @param incHdrAttribGuid Reserved
 923      @param incHdrAttribArch Reserved
 924      @param incHdrAttribPath Reserved
 925      @param incHdrAttribClass Reserved
 926      @param incHdrAttribVer Reserved
 927      @param incHdrAttribOverrideID Reserved
 928      @param incHdrAttribModuleType Reserved
 929     **/
 930     public void genSpdLibClassDeclarations(String libClassBaseName, String instanceUsage, String incHdrFileName,
 931                                            String help, String incHdrAttribArch, String incHdrAttribPath,
 932                                            String incHdrAttribClass, String incHdrAttribVer,
 933                                            String incHdrAttribOverrideID, String incHdrAttribModuleType) {
 934         if (getSpdLibClassDeclarations() == null) {
 935             spdLibClassDeclarations = psaRoot.addNewLibraryClassDeclarations();
 936         }
 937         //
 938         // add contents under LibraryClassDeclarations tag
 939         //
 940         setSpdLibClassDeclaration(libClassBaseName, instanceUsage, incHdrFileName, help, incHdrAttribArch,
 941                                   incHdrAttribPath, incHdrAttribClass, incHdrAttribVer, incHdrAttribOverrideID,
 942                                   incHdrAttribModuleType, spdLibClassDeclarations);
 943     }
 944
 945     /**
 946      Set library class declaration contents under parent tag
 947
 948      @param clsName LibraryClass element value
 949      @param clsUsage Reserved
 950      @param hdrFile IncludeHeader element value
 951      @param hdrAttribGuid Reserved
 952      @param hdrAttribArch Reserved
 953      @param hdrAttribPath Reserved
 954      @param hdrAttribClass Reserved
 955      @param hdrAttribVer Reserved
 956      @param hdrAttribOverID Reserved
 957      @param hdrAttribModType Reserved
 958      @param parent The tag under which library class declaration goes to
 959     **/
 960     public void setSpdLibClassDeclaration(String clsName, String clsUsage, String hdrFile, String help,
 961                                           String hdrAttribArch, String hdrAttribPath, String hdrAttribClass,
 962                                           String instanceVer, String hdrAttribOverID, String hdrAttribModType,
 963                                           XmlObject parent) {
 964
 965         setSpdLibraryClass(clsName, hdrFile, help, clsUsage, instanceVer, hdrAttribArch, hdrAttribModType, parent);
 966
 967     }
 968
 969     /**
 970      Set the contents of LibraryClass under parent element
 971
 972      @param clsName LibraryClass element value
 973      @param clsUsage Reserved
 974      @param parent The tag under which library class declaration goes to
 975     **/
 976     public void setSpdLibraryClass(String clsName, String clsIncludeFile, String help, String clsUsage, String instanceVer, String hdrAttribArch, String hdrAttribModType, XmlObject parent) {
 977         LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass lc = ((LibraryClassDeclarationsDocument.LibraryClassDeclarations) parent).addNewLibraryClass();
 978         lc.setName(clsName);
 979         lc.setIncludeHeader(clsIncludeFile);
 980         lc.setHelpText(help);
 981 // LAH added logic so you cannot set the version unless the GUID is defined.
 982 /* LAH
 983         if (clsUsage != null) {
 984           lc.setRecommendedInstanceGuid(clsUsage);
 985           if (instanceVer != null) {
 986             lc.setRecommendedInstanceVersion(instanceVer);
 987           }
 988         }
 989 */
 990         if (hdrAttribArch != null) {
 991             lc.setSupArchList(stringToList(hdrAttribArch));
 992         }
 993         if (hdrAttribModType != null) {
 994           lc.setSupModuleList(stringToList(hdrAttribModType));
 995         } else {
 996           lc.unsetSupModuleList();
 997         }
 998
 999     }
1000
1001     /**
1002      Set contents of IncludeHeader under parent element
1003
1004      @param modType Reserved
1005      @param hdrFile IncludeHeader element value
1006      @param hdrAttribGuid Reserved
1007      @param hdrAttribArch Reserved
1008      @param hdrAttribPath Reserved
1009      @param hdrAttribClass Reserved
1010      @param hdrAttribVer Reserved
1011      @param hdrAttribOverID Reserved
1012      @param parent The tag under which library class declaration goes to
1013     **/
1014     public void setSpdIncludeHeader(String modType, String hdrFile, String hdrAttribGuid, String hdrAttribArch,
1015                                     String hdrAttribPath, String hdrAttribClass, String hdrAttribVer,
1016                                     String hdrAttribOverID, XmlObject parent) {
1017
1018         if (parent instanceof LibraryClassDeclarationsDocument.LibraryClassDeclarations) {
1019         } else if (parent instanceof PackageHeadersDocument.PackageHeaders) {
1020             PackageHeadersDocument.PackageHeaders.IncludePkgHeader ih = null;
1021             ih = ((PackageHeadersDocument.PackageHeaders) parent).addNewIncludePkgHeader();
1022             ih.setStringValue(hdrFile);
1023             ih.setModuleType(ModuleTypeDef.Enum.forString(modType));
1024         } else {
1025             return;
1026         }
1027
1028         if (hdrAttribGuid != null) {
1029         }
1030         if (hdrAttribPath != null) {
1031         }
1032         if (hdrAttribClass != null) {
1033         }
1034         if (hdrAttribVer != null) {
1035         }
1036         if (hdrAttribOverID != null) {
1037         }
1038
1039     }
1040
1041     /**
1042      Generate MsaFile element.
1043
1044      @param msaFileName MsaFile element value
1045      @param archType Reserved
1046     **/
1047     public void genSpdMsaFiles(String msaFileName, String moduleName, String ver, String guid) {
1048         if (getSpdMsaFiles() == null) {
1049             spdMsaFiles = psaRoot.addNewMsaFiles();
1050         }
1051         setSpdMsaFile(msaFileName, moduleName, ver, guid, spdMsaFiles);
1052
1053     }
1054
1055     /**
1056      Set MsaFile contents under parent element.
1057
1058      @param msaFileName MsaFile element value
1059      @param parent Element under which MsaFile goes to
1060     **/
1061     public void setSpdMsaFile(String msaFileName, String moduleName, String ver, String guid, XmlObject parent) {
1062         MsaFilesDocument.MsaFiles f = (MsaFilesDocument.MsaFiles)parent;
1063         f.addNewFilename().setStringValue(msaFileName);
1064 //        f.setFilename(msaFileName);
1065 //        f.setModuleName(moduleName);
1066 //        f.setModuleVersion(ver);
1067 //        f.setModuleGuid(guid);
1068     }
1069
1070     /**
1071      Generate PackageHeader element using parameters passed in.
1072
1073      @param ModHdrModType ModuleType attribute of IncludeHeader element
1074      @param hdrFile IncludeHeader element value
1075      @param hdrAttribGuid Reserved
1076      @param hdrAttribArch Reserved
1077      @param hdrAttribPath Reserved
1078      @param hdrAttribClass Reserved
1079      @param hdrAttribVer Reserved
1080      @param hdrAttribOverID Reserved
1081     **/
1082     public void genSpdModuleHeaders(String ModHdrModType, String hdrFile, String hdrAttribGuid, String hdrAttribArch,
1083                                     String hdrAttribPath, String hdrAttribClass, String hdrAttribVer,
1084                                     String hdrAttribOverID) {
1085         if (getSpdModHdrs() == null) {
1086             spdModHdrs = psaRoot.addNewPackageHeaders();
1087         }
1088
1089         //
1090         // add IncludeHeader under PackageHeaders element
1091         //
1092         setSpdIncludeHeader(ModHdrModType, hdrFile, hdrAttribGuid, hdrAttribArch, hdrAttribPath, hdrAttribClass,
1093                             hdrAttribVer, hdrAttribOverID, spdModHdrs);
1094     }
1095
1096     /**
1097      Generate GUID declaration element using parameters passed in.
1098
1099      @param guidDeclEntryName Name attribute of Entry element
1100      @param guidDeclCName CName element value
1101      @param guidDeclGuid Guid element value
1102      @param guidDeclFeatureFlag Reserved
1103     **/
1104     public void genSpdGuidDeclarations(String guidDeclEntryName, String guidDeclCName, String guidDeclGuid,
1105                                        String guidDeclHelp, Vector<String> archList, Vector<String> modTypeList,
1106                                        Vector<String> guidTypeList) {
1107         if (getSpdGuidDeclarations() == null) {
1108             spdGuidDeclarations = psaRoot.addNewGuidDeclarations();
1109         }
1110
1111         setSpdEntry(guidDeclEntryName, guidDeclCName, guidDeclGuid, guidDeclHelp, archList, modTypeList, guidTypeList, spdGuidDeclarations);
1112     }
1113
1114     /**
1115     Generate protocol declaration element using parameters passed in.
1116
1117     @param protocolDeclEntryName Name attribute of Entry element
1118     @param protocolDeclCName CName element value
1119     @param protocolDeclGuid Guid element value
1120     @param protocolDeclFeatureFlag Reserved
1121    **/
1122     public void genSpdProtocolDeclarations(String protocolDeclEntryName, String protocolDeclCName,
1123                                            String protocolDeclGuid, String protocolDeclFeatureFlag,
1124                                            Vector<String> archList, Vector<String> modTypeList) {
1125         if (getSpdProtocolDeclarations() == null) {
1126             spdProtocolDeclarations = psaRoot.addNewProtocolDeclarations();
1127         }
1128
1129         setSpdEntry(protocolDeclEntryName, protocolDeclCName, protocolDeclGuid, protocolDeclFeatureFlag,
1130                     archList, modTypeList, null, spdProtocolDeclarations);
1131     }
1132
1133     /**
1134     Generate PPI declaration element using parameters passed in.
1135
1136     @param ppiDeclEntryName Name attribute of Entry element
1137     @param ppiDeclCName CName element value
1138     @param ppiDeclGuid Guid element value
1139     @param ppiDeclFeatureFlag Reserved
1140    **/
1141     public void genSpdPpiDeclarations(String ppiDeclEntryName, String ppiDeclCName, String ppiDeclGuid,
1142                                       String ppiDeclFeatureFlag, Vector<String> archList, Vector<String> modTypeList) {
1143         if (getSpdPpiDeclarations() == null) {
1144             spdPpiDeclarations = psaRoot.addNewPpiDeclarations();
1145         }
1146
1147         setSpdEntry(ppiDeclEntryName, ppiDeclCName, ppiDeclGuid, ppiDeclFeatureFlag, archList, modTypeList, null, spdPpiDeclarations);
1148     }
1149
1150     /**
1151      Set Entry contents using parameters passed in
1152
1153      @param entryName Name attribute of Entry element
1154      @param cName CName element value
1155      @param guid Guid element value
1156      @param featureFlag Reserved
1157      @param parent The tag under which Entry element goes to
1158     **/
1159     public void setSpdEntry(String entryName, String cName, String guid, String help,
1160                             Vector<String> archList, Vector<String> modTypeList,
1161                             Vector<String> guidTypeList, XmlObject parent) {
1162
1163         if (parent instanceof GuidDeclarationsDocument.GuidDeclarations) {
1164             GuidDeclarationsDocument.GuidDeclarations.Entry e = ((GuidDeclarations) parent).addNewEntry();
1165             e.setName(entryName);
1166             e.setCName(cName);
1167             e.setGuidValue(guid);
1168             e.setHelpText(help);
1169             e.setGuidTypeList(guidTypeList);
1170             e.setSupArchList(archList);
1171             e.setSupModuleList(modTypeList);
1172 //            if (guidTypeList != null && guidTypeList.size() > 0) {
1173 //                e.setGuidTypeList(new ArrayList<String>(guidTypeList));
1174 //            }
1175 //            if (archList != null && archList.size() > 0){
1176 //                e.setSupArchList(new ArrayList<String>(archList));
1177 //            }
1178 //            if (modTypeList != null && modTypeList.size() > 0) {
1179 //                e.setSupModuleList(new ArrayList<String>(modTypeList));
1180 //            }
1181             return;
1182         }
1183         if (parent instanceof ProtocolDeclarationsDocument.ProtocolDeclarations) {
1184             ProtocolDeclarationsDocument.ProtocolDeclarations.Entry pe = ((ProtocolDeclarationsDocument.ProtocolDeclarations) parent)
1185                                                                                                                                      .addNewEntry();
1186             pe.setName(entryName);
1187             pe.setCName(cName);
1188             pe.setGuidValue(guid);
1189             pe.setHelpText(help);
1190             pe.setSupArchList(archList);
1191             pe.setSupModuleList(modTypeList);
1192 //            if (archList != null && archList.size() > 0){
1193 //                pe.setSupArchList(new ArrayList<String>(archList));
1194 //            }
1195 //            if (modTypeList != null && modTypeList.size() > 0) {
1196 //                pe.setSupModuleList(new ArrayList<String>(modTypeList));
1197 //            }
1198             return;
1199         }
1200         if (parent instanceof PpiDeclarationsDocument.PpiDeclarations) {
1201             PpiDeclarationsDocument.PpiDeclarations.Entry ppe = ((PpiDeclarationsDocument.PpiDeclarations) parent)
1202                                                                                                                   .addNewEntry();
1203             ppe.setName(entryName);
1204             ppe.setCName(cName);
1205             ppe.setGuidValue(guid);
1206             ppe.setHelpText(help);
1207             ppe.setSupArchList(archList);
1208             ppe.setSupModuleList(modTypeList);
1209 //            if (archList != null && archList.size() > 0){
1210 //                ppe.setSupArchList(new ArrayList<String>(archList));
1211 //            }
1212 //            if (archList != null && modTypeList.size() > 0) {
1213 //                ppe.setSupModuleList(new ArrayList<String>(modTypeList));
1214 //            }
1215             return;
1216         }
1217
1218         return;
1219
1220     }
1221
1222     /**
1223      Generate Pcd definition using parameters passed in
1224
1225      @param pcdItemTypes ItemType attribute of PcdEntry element
1226      @param cName C_Name element value
1227      @param token Token element value
1228      @param dataType DatumType element value
1229      @param skuEnable Reserved
1230      @param sku Reserved
1231      @param maxSku Reserved
1232      @param hiiEnable Reserved
1233      @param varGuid Reserved
1234      @param varName Reserved
1235      @param defaultString DefaultString element value
1236     **/
1237     public void genSpdPcdDefinitions(String cName, String token, String dataType, String pcdItemTypes,
1238                                      String spaceGuid, String defaultString, String help, String archList,
1239                                      String modTypeList) {
1240         if (getSpdPcdDefinitions() == null) {
1241             spdPcdDefinitions = psaRoot.addNewPcdDeclarations();
1242         }
1243
1244         setSpdPcdEntry(pcdItemTypes, cName, token, dataType, spaceGuid, help,
1245                        defaultString, archList, modTypeList, spdPcdDefinitions);
1246     }
1247
1248     /**
1249      Set Pcd entry contents under parent tag
1250
1251      @param pcdItemTypes ItemType attribute of PcdEntry element
1252      @param cName C_Name element value
1253      @param token Token element value
1254      @param dataType DatumType element value
1255      @param spaceGuid Reserved
1256      @param help Reserved
1257      @param defaultString DefaultString element value
1258      @param parent Tag under which PcdEntry goes to
1259     **/
1260     public void setSpdPcdEntry(String pcdItemTypes, String cName, String token, String dataType, String spaceGuid, String help,
1261                                String defaultString, String archList, String modTypeList, XmlObject parent) {
1262
1263         PcdDeclarationsDocument.PcdDeclarations.PcdEntry pe = ((PcdDeclarationsDocument.PcdDeclarations) parent).addNewPcdEntry();
1264
1265         //ToDo: maybe multiple types in, need parse pcdItemTypes.
1266         String usage[] = pcdItemTypes.split("( )+");
1267         List<String> l = new ArrayList<String>();
1268         for (int i = 0; i < usage.length; ++i) {
1269             l.add(usage[i]);
1270         }
1271         pe.setValidUsage(l);
1272         pe.setCName(cName);
1273         pe.setToken(token);
1274         pe.setDatumType(PcdDataTypes.Enum.forString(dataType));
1275         pe.setDefaultValue(defaultString);
1276         pe.setTokenSpaceGuidCName(spaceGuid);
1277         pe.setHelpText(help);
1278         if (archList != null){
1279           pe.setSupArchList(stringToList(archList));
1280         } else {
1281           pe.unsetSupArchList();
1282         }
1283         if (modTypeList != null){
1284           pe.setSupModuleList(stringToList(modTypeList));
1285         } else {
1286           pe.unsetSupModuleList();
1287         }
1288     }
1289
1290     /**
1291      Get PpiDeclarations element
1292
1293      @return PpiDeclarationsDocument.PpiDeclarations
1294     **/
1295     public PpiDeclarationsDocument.PpiDeclarations getSpdPpiDeclarations() {
1296         if (spdPpiDeclarations == null) {
1297             spdPpiDeclarations = psaRoot.getPpiDeclarations();
1298         }
1299         return spdPpiDeclarations;
1300     }
1301
1302     /**
1303     Get ProtocolDeclarations element
1304
1305     @return ProtocolDeclarationsDocument.ProtocolDeclarations
1306     **/
1307     public ProtocolDeclarationsDocument.ProtocolDeclarations getSpdProtocolDeclarations() {
1308         if (spdProtocolDeclarations == null) {
1309             spdProtocolDeclarations = psaRoot.getProtocolDeclarations();
1310         }
1311         return spdProtocolDeclarations;
1312     }
1313
1314     /**
1315     Get GuidDeclarations element
1316
1317     @return GuidDeclarationsDocument.GuidDeclarations
1318     **/
1319     public GuidDeclarationsDocument.GuidDeclarations getSpdGuidDeclarations() {
1320         if (spdGuidDeclarations == null) {
1321             spdGuidDeclarations = psaRoot.getGuidDeclarations();
1322         }
1323         return spdGuidDeclarations;
1324     }
1325
1326     /**
1327      Get PcdDefinitions element
1328
1329      @return PcdDefinitionsDocument.PcdDefinitions
1330     **/
1331     public PcdDeclarationsDocument.PcdDeclarations getSpdPcdDefinitions() {
1332         if (spdPcdDefinitions == null) {
1333             spdPcdDefinitions = psaRoot.getPcdDeclarations();
1334         }
1335         return spdPcdDefinitions;
1336     }
1337
1338     /**
1339      Get PackageHeaders element
1340
1341      @return PackageHeadersDocument.PackageHeaders
1342     **/
1343     public PackageHeadersDocument.PackageHeaders getSpdModHdrs() {
1344         if (spdModHdrs == null) {
1345             spdModHdrs = psaRoot.getPackageHeaders();
1346         }
1347         return spdModHdrs;
1348     }
1349
1350     /**
1351      Get MsaFiles element
1352
1353      @return MsaFilesDocument.MsaFiles
1354     **/
1355     public MsaFilesDocument.MsaFiles getSpdMsaFiles() {
1356         if (spdMsaFiles == null) {
1357             spdMsaFiles = psaRoot.getMsaFiles();
1358         }
1359         return spdMsaFiles;
1360     }
1361
1362     /**
1363      Get LibraryClassDeclarations element
1364
1365      @return LibraryClassDeclarationsDocument.LibraryClassDeclarations
1366     **/
1367     public LibraryClassDeclarationsDocument.LibraryClassDeclarations getSpdLibClassDeclarations() {
1368         if (spdLibClassDeclarations == null) {
1369             spdLibClassDeclarations = psaRoot.getLibraryClassDeclarations();
1370         }
1371         return spdLibClassDeclarations;
1372     }
1373
1374     public PackageDefinitionsDocument.PackageDefinitions getSpdPkgDefs() {
1375         if (spdPkgDefs == null) {
1376             spdPkgDefs = psaRoot.addNewPackageDefinitions();
1377         }
1378         return spdPkgDefs;
1379     }
1380     /**
1381      Get SpdHeader element
1382
1383      @return SpdHeaderDocument.SpdHeader
1384     **/
1385     public SpdHeaderDocument.SpdHeader getSpdHdr() {
1386         if (spdHdr == null) {
1387             spdHdr = psaRoot.addNewSpdHeader();
1388         }
1389         return spdHdr;
1390     }
1391
1392     /**
1393      Set value to Guid element
1394
1395      @param guid The value set to Guid element
1396     **/
1397     public void setSpdHdrGuidValue(String guid) {
1398         getSpdHdr().setGuidValue(guid);
1399     }
1400
1401     /**
1402     Get Version element under SpdHdr
1403
1404     @return String
1405    **/
1406     public String getSpdHdrVer() {
1407         return getSpdHdr().getVersion();
1408     }
1409
1410     /**
1411     Set value to Version element
1412
1413     @param ver The value set to Version element
1414    **/
1415     public void setSpdHdrVer(String ver) {
1416         getSpdHdr().setVersion(ver);
1417     }
1418
1419     public String getSpdHdrAbs(){
1420         return getSpdHdr().getAbstract();
1421
1422     }
1423
1424     /**
1425      Set value to Abstract element
1426
1427      @param abs The value set to Abstract element
1428      **/
1429     public void setSpdHdrAbs(String abs) {
1430
1431         getSpdHdr().setAbstract(abs);
1432     }
1433
1434     public String getSpdHdrDescription(){
1435        return getSpdHdr().getDescription();
1436     }
1437     /**
1438     Set value to Description element
1439
1440     @param des The value set to Description element
1441     **/
1442     public void setSpdHdrDescription(String des) {
1443        getSpdHdr().setDescription(des);
1444     }
1445
1446     public String getSpdHdrCopyright(){
1447         return getSpdHdr().getCopyright();
1448     }
1449     /**
1450      Set value to Copyright element
1451
1452      @param cpRit The value set to Copyright element
1453      **/
1454     public void setSpdHdrCopyright(String cpRit) {
1455
1456         getSpdHdr().setCopyright(cpRit);
1457
1458     }
1459     /**
1460      Get License element under SpdHdr
1461
1462      @return String
1463      **/
1464     public String getSpdHdrLicense() {
1465         if (getSpdHdr().getLicense() != null) {
1466             return getSpdHdr().getLicense().getStringValue();
1467         }
1468         return null;
1469     }
1470
1471     /**
1472     Set value to License element
1473
1474     @param license The value set to License element
1475    **/
1476     public void setSpdHdrLicense(String license) {
1477         if (getSpdHdr().getLicense() == null){
1478             getSpdHdr().addNewLicense().setStringValue(license);
1479         }
1480         else {
1481             getSpdHdr().getLicense().setStringValue(license);
1482         }
1483     }
1484
1485     public String getSpdHdrUrl(){
1486         if (getSpdHdr().getLicense() != null) {
1487             return getSpdHdr().getLicense().getURL();
1488         }
1489         return null;
1490     }
1491
1492     public void setSpdHdrUrl(String url){
1493         getSpdHdr().getLicense().setURL(url);
1494     }
1495
1496     /**
1497     Get PackageName element under SpdHdr
1498
1499     @return String
1500    **/
1501     public String getSpdHdrPkgName() {
1502
1503         return getSpdHdr().getPackageName();
1504     }
1505
1506     /**
1507     Set value to PackageName element
1508
1509     @param pkgName The value set to PackageName element
1510    **/
1511     public void setSpdHdrPkgName(String pkgName) {
1512         getSpdHdr().setPackageName(pkgName);
1513     }
1514
1515     public String getSpdHdrGuidValue(){
1516         return getSpdHdr().getGuidValue();
1517     }
1518
1519     /**
1520     Reserved method
1521
1522     @return SpecificationDocument.Specification
1523    **/
1524     public String getSpdHdrSpec() {
1525         return "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052";
1526 //        return getSpdHdr().getSpecification();
1527     }
1528
1529     /**
1530     Reserved method
1531
1532     @param spec
1533    **/
1534     public void setSpdHdrSpec(String spec) {
1535         spec = "FRAMEWORK_BUILD_PACKAGING_SPECIFICATION   0x00000052";
1536         getSpdHdr().setSpecification(spec);
1537
1538     }
1539
1540    public String getSpdPkgDefsRdOnly(){
1541         return getSpdPkgDefs().getReadOnly() + "";
1542     }
1543     /**
1544     Set value to ReadOnly element
1545
1546     @param rdOnly The value set to ReadOnly element
1547    **/
1548     public void setSpdPkgDefsRdOnly(String rdOnly) {
1549
1550         getSpdPkgDefs().setReadOnly(new Boolean(rdOnly));
1551     }
1552
1553     public String getSpdPkgDefsRePkg(){
1554         return getSpdPkgDefs().getRePackage() + "";
1555     }
1556     /**
1557     Set value to RePackage element
1558
1559     @param rePkg The value set to RePackage element
1560    **/
1561     public void setSpdPkgDefsRePkg(String rePkg) {
1562
1563         getSpdPkgDefs().setRePackage(new Boolean(rePkg));
1564     }
1565
1566     /**
1567     Set value to URL element
1568
1569     @param url The value set to URL element
1570    **/
1571 //    public void setSpdHdrURL(String url) {
1572 //        getSpdHdr().setURL(url);
1573 //    }
1574
1575     /**
1576      Get xml file
1577
1578      @return File
1579     **/
1580     public File getFile() {
1581         return file;
1582     }
1583
1584     /**
1585      Set file
1586
1587      @param file File with xml format
1588     **/
1589     public void setFile(File file) {
1590         this.file = file;
1591     }
1592
1593     private List<String> stringToList(String s){
1594         if (s == null || s.length() == 0) {
1595             return null;
1596         }
1597         Vector<String> al = new Vector<String>();
1598         String[] sArray = s.split(" ");
1599         for(int i = 0; i < sArray.length; ++i){
1600             al.add(sArray[i]);
1601         }
1602         return al;
1603     }
1604
1605     private String listToString(List l) {
1606         if (l == null) {
1607             return null;
1608         }
1609         String s = " ";
1610         ListIterator li = l.listIterator();
1611         while(li.hasNext()) {
1612             s += li.next();
1613             s += " ";
1614         }
1615         return s.trim();
1616     }
1617
1618 }