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