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