Tools/Source/GenBuild/org/tianocore/build/fpd/FpdParserTask.java

   1 /** @file
   2  This file is ANT task FpdParserTask.
   3
   4  FpdParserTask is used to parse FPD (Framework Platform Description) and generate
   5  build.out.xml. It is for Package or Platform build use.
   6
   7  Copyright (c) 2006, Intel Corporation
   8  All rights reserved. This program and the accompanying materials
   9  are licensed and made available under the terms and conditions of the BSD License
  10  which accompanies this distribution.  The full text of the license may be found at
  11  http://opensource.org/licenses/bsd-license.php
  12
  13  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15  **/
  16 package org.tianocore.build.fpd;
  17
  18 import java.io.BufferedWriter;
  19 import java.io.File;
  20 import java.io.FileWriter;
  21 import java.io.IOException;
  22 import java.util.HashMap;
  23 import java.util.Iterator;
  24 import java.util.LinkedHashMap;
  25 import java.util.LinkedHashSet;
  26 import java.util.Map;
  27 import java.util.Set;
  28 import java.util.Vector;
  29
  30 import org.apache.tools.ant.BuildException;
  31 import org.apache.tools.ant.Task;
  32 import org.apache.tools.ant.taskdefs.Ant;
  33 import org.apache.tools.ant.taskdefs.Property;
  34 import org.apache.xmlbeans.XmlException;
  35 import org.apache.xmlbeans.XmlObject;
  36
  37 import org.tianocore.common.definitions.EdkDefinitions;
  38 import org.tianocore.common.exception.EdkException;
  39 import org.tianocore.common.logger.EdkLog;
  40 import org.tianocore.pcd.action.ActionMessage;
  41 import org.tianocore.build.FrameworkBuildTask;
  42 import org.tianocore.build.global.GlobalData;
  43 import org.tianocore.build.global.OutputManager;
  44 import org.tianocore.build.global.SurfaceAreaQuery;
  45 import org.tianocore.build.id.FpdModuleIdentification;
  46 import org.tianocore.build.id.ModuleIdentification;
  47 import org.tianocore.build.id.PackageIdentification;
  48 import org.tianocore.build.id.PlatformIdentification;
  49 import org.tianocore.build.pcd.action.PlatformPcdPreprocessActionForBuilding;
  50 import org.tianocore.build.toolchain.ToolChainAttribute;
  51 import org.tianocore.build.toolchain.ToolChainElement;
  52 import org.tianocore.build.toolchain.ToolChainMap;
  53 import org.w3c.dom.NamedNodeMap;
  54 import org.w3c.dom.Node;
  55 import org.w3c.dom.NodeList;
  56
  57 /**
  58   <code>FpdParserTask</code> is an ANT task. The main function is parsing Framework
  59   Platform Descritpion (FPD) XML file and generating its ANT build script for
  60   corresponding platform.
  61
  62   <p>The task sets global properties PLATFORM, PLATFORM_DIR, PLATFORM_RELATIVE_DIR
  63   and BUILD_DIR. </p>
  64
  65   <p>The task generates ${PLATFORM}_build.xml file which will be called by top level
  66   build.xml. The task also generate Fv.inf files (File is for Tool GenFvImage). </p>
  67
  68   <p>FpdParserTask task stores all FPD information to GlobalData. And parse
  69   tools definition file to set up compiler options for different Target and
  70   different ToolChainTag. </p>
  71
  72   <p>The method parseFpdFile is also prepared for single module build. </p>
  73
  74   @since GenBuild 1.0
  75 **/
  76 public class FpdParserTask extends Task {
  77
  78     private File fpdFile = null;
  79
  80     PlatformIdentification platformId;
  81
  82     private String type;
  83
  84     ///
  85     /// Mapping from modules identification to out put file name
  86     ///
  87     Map<FpdModuleIdentification, String> outfiles = new LinkedHashMap<FpdModuleIdentification, String>();
  88
  89     ///
  90     /// Mapping from FV name to its modules
  91     ///
  92     Map<String, Set<FpdModuleIdentification>> fvs = new HashMap<String, Set<FpdModuleIdentification>>();
  93
  94     ///
  95     /// FpdParserTask can specify some ANT properties.
  96     ///
  97     private Vector<Property> properties = new Vector<Property>();
  98
  99     SurfaceAreaQuery saq = null;
 100
 101     boolean isUnified = true;
 102
 103     /**
 104       Public construct method. It is necessary for ANT task.
 105     **/
 106     public FpdParserTask() {
 107     }
 108
 109     /**
 110      ANT task's entry method. The main steps is described as following:
 111
 112      <ul>
 113      <li>Initialize global information (Framework DB, SPD files and all MSA files
 114      listed in SPD). This step will execute only once in whole build process;</li>
 115      <li>Parse specified FPD file; </li>
 116      <li>Generate FV.inf files; </li>
 117      <li>Generate PlatformName_build.xml file for Flatform build; </li>
 118      <li>Collect PCD information. </li>
 119      </ul>
 120
 121      @throws BuildException
 122      Surface area is not valid.
 123     **/
 124     public void execute() throws BuildException {
 125         this.setTaskName("FpdParser");
 126
 127         //
 128         // Parse FPD file
 129         //
 130         parseFpdFile();
 131
 132         //
 133         // Prepare BUILD_DIR
 134         //
 135         isUnified = OutputManager.getInstance().prepareBuildDir(getProject());
 136
 137         String buildDir = getProject().getProperty("BUILD_DIR");
 138         //
 139         // For every Target and ToolChain
 140         //
 141         String[] targetList = GlobalData.getToolChainInfo().getTargets();
 142         for (int i = 0; i < targetList.length; i++) {
 143             String[] toolchainList = GlobalData.getToolChainInfo().getTagnames();
 144             for(int j = 0; j < toolchainList.length; j++) {
 145                 //
 146                 // Prepare FV_DIR
 147                 //
 148                 String ffsCommonDir = buildDir + File.separatorChar
 149                                 + targetList[i] + "_"
 150                                 + toolchainList[j];
 151                 File fvDir = new File(ffsCommonDir + File.separatorChar + "FV");
 152                 fvDir.mkdirs();
 153                 getProject().setProperty("FV_DIR", fvDir.getPath().replaceAll("(\\\\)", "/"));
 154
 155                 //
 156                 // Gen Fv.inf files
 157                 //
 158                 genFvInfFiles(ffsCommonDir);
 159             }
 160         }
 161
 162         //
 163         // Gen build.xml
 164         //
 165         String platformBuildFile = buildDir + File.separatorChar + platformId.getName() + "_build.xml";
 166         PlatformBuildFileGenerator fileGenerator = new PlatformBuildFileGenerator(getProject(), outfiles, fvs, isUnified, saq, platformBuildFile);
 167         fileGenerator.genBuildFile();
 168
 169         //
 170         // Ant call ${PLATFORM}_build.xml
 171         //
 172         Ant ant = new Ant();
 173         ant.setProject(getProject());
 174         ant.setAntfile(platformBuildFile);
 175         ant.setTarget(type);
 176         ant.setInheritAll(true);
 177         ant.init();
 178         ant.execute();
 179     }
 180
 181     /**
 182       Generate Fv.inf files. The Fv.inf file is composed with four
 183       parts: Options, Attributes, Components and Files. The Fv.inf files
 184       will be under FV_DIR.
 185
 186       @throws BuildException
 187                   File write FV.inf files error.
 188     **/
 189     void genFvInfFiles(String ffsCommonDir) throws BuildException {
 190         String[] validFv = saq.getFpdValidImageNames();
 191         for (int i = 0; i < validFv.length; i++) {
 192             //
 193             // Get all global variables from FPD and set them to properties
 194             //
 195             String[][] globalVariables = saq.getFpdGlobalVariable();
 196             for (int j = 0; j < globalVariables.length; j++) {
 197                 getProject().setProperty(globalVariables[j][0], globalVariables[j][1]);
 198             }
 199
 200             getProject().setProperty("FV_FILENAME", validFv[i]);
 201
 202             File fvFile = new File(getProject().replaceProperties( getProject().getProperty("FV_DIR") + File.separatorChar + validFv[i] + ".inf"));
 203             if (fvFile.exists() && (fvFile.lastModified() >= fpdFile.lastModified())) {
 204                 //
 205                 // don't re-generate FV.inf if fpd has not been changed
 206                 //
 207                 continue;
 208             }
 209             fvFile.getParentFile().mkdirs();
 210
 211             try {
 212                 FileWriter fw = new FileWriter(fvFile);
 213                 BufferedWriter bw = new BufferedWriter(fw);
 214
 215                 //
 216                 // Options
 217                 //
 218                 String[][] options = saq.getFpdOptions(validFv[i]);
 219                 if (options.length > 0) {
 220                     bw.write("[options]");
 221                     bw.newLine();
 222                     for (int j = 0; j < options.length; j++) {
 223                         StringBuffer str = new StringBuffer(100);
 224                         str.append(options[j][0]);
 225                         while (str.length() < 40) {
 226                             str.append(' ');
 227                         }
 228                         str.append("=  ");
 229                         str.append(options[j][1]);
 230                         bw.write(getProject().replaceProperties(str.toString()));
 231                         bw.newLine();
 232                     }
 233                     bw.newLine();
 234                 }
 235
 236                 //
 237                 // Attributes;
 238                 //
 239                 String[][] attributes = saq.getFpdAttributes(validFv[i]);
 240                 if (attributes.length > 0) {
 241                     bw.write("[attributes]");
 242                     bw.newLine();
 243                     for (int j = 0; j < attributes.length; j++) {
 244                         StringBuffer str = new StringBuffer(100);
 245                         str.append(attributes[j][0]);
 246                         while (str.length() < 40) {
 247                             str.append(' ');
 248                         }
 249                         str.append("=  ");
 250                         str.append(attributes[j][1]);
 251                         bw.write(getProject().replaceProperties(str.toString()));
 252                         bw.newLine();
 253                     }
 254                     bw.newLine();
 255                 }
 256
 257                 //
 258                 // Components
 259                 //
 260                 String[][] components = saq.getFpdComponents(validFv[i]);
 261                 if (components.length > 0) {
 262                     bw.write("[components]");
 263                     bw.newLine();
 264                     for (int j = 0; j < components.length; j++) {
 265                         StringBuffer str = new StringBuffer(100);
 266                         str.append(components[j][0]);
 267                         while (str.length() < 40) {
 268                             str.append(' ');
 269                         }
 270                         str.append("=  ");
 271                         str.append(components[j][1]);
 272                         bw.write(getProject().replaceProperties(str.toString()));
 273                         bw.newLine();
 274                     }
 275                     bw.newLine();
 276                 }
 277
 278                 //
 279                 // Files
 280                 //
 281                 Set<FpdModuleIdentification> moduleSeqSet = getModuleSequenceForFv(validFv[i]);
 282
 283                 Set<FpdModuleIdentification> filesSet = fvs.get(validFv[i]);
 284
 285                 FpdModuleIdentification[] files = null;
 286
 287                 if (moduleSeqSet == null) {
 288                     if (filesSet != null) {
 289                         files = filesSet.toArray(new FpdModuleIdentification[filesSet.size()]);
 290                     }
 291                 } else if (filesSet == null) {
 292                     if (moduleSeqSet.size() != 0) {
 293                         throw new BuildException("Can not find any modules belongs to FV[" + validFv[i] + "], but listed some in BuildOptions.UserExtensions[@UserID='IMAGES' @Identifier='1']");
 294                     }
 295                 } else {
 296                     //
 297                     // if moduleSeqSet and filesSet is inconsistent, report error
 298                     //
 299                     if(moduleSeqSet.size() != filesSet.size()){
 300                         throw new BuildException("Modules for FV[" + validFv[i] + "] defined in FrameworkModules and in BuildOptions.UserExtensions[@UserID='IMAGES' @Identifier='1'] are inconsistent. ");
 301                     } else {
 302                         //
 303                         // whether all modules in moduleSeqSet listed in filesSet
 304                         //
 305                         Iterator<FpdModuleIdentification> iter = moduleSeqSet.iterator();
 306                         while (iter.hasNext()) {
 307                             FpdModuleIdentification item = iter.next();
 308                             if (!filesSet.contains(item)) {
 309                                 throw new BuildException("Can not find " + item + " belongs to FV[" + validFv[i] + "]");
 310                             }
 311                         }
 312                     }
 313
 314                     files = moduleSeqSet.toArray(new FpdModuleIdentification[moduleSeqSet.size()]);
 315                 }
 316
 317
 318                 if (files != null) {
 319                     bw.write("[files]");
 320                     bw.newLine();
 321                     for (int j = 0; j < files.length; j++) {
 322                         String str = ffsCommonDir + File.separatorChar + outfiles.get(files[j]);
 323                         bw.write(getProject().replaceProperties("EFI_FILE_NAME = " + str));
 324                         bw.newLine();
 325                     }
 326                 }
 327                 bw.flush();
 328                 bw.close();
 329                 fw.close();
 330             } catch (IOException ex) {
 331                 BuildException buildException = new BuildException("Generation of the FV file [" + fvFile.getPath() + "] failed!\n" + ex.getMessage());
 332                 buildException.setStackTrace(ex.getStackTrace());
 333                 throw buildException;
 334             } catch (EdkException ex) {
 335                 BuildException buildException = new BuildException("Generation of the FV file [" + fvFile.getPath() + "] failed!\n" + ex.getMessage());
 336                 buildException.setStackTrace(ex.getStackTrace());
 337                 throw buildException;
 338             }
 339         }
 340     }
 341     /**
 342       This method is used for Single Module Build.
 343
 344
 345       @throws BuildException
 346                   FPD file is not valid.
 347     **/
 348     public void parseFpdFile(File fpdFile) throws BuildException, EdkException {
 349         this.fpdFile = fpdFile;
 350         parseFpdFile();
 351
 352         //
 353         // Call Platform_build.xml prebuild firstly in stand-alone build
 354         // Prepare BUILD_DIR
 355         //
 356         isUnified = OutputManager.getInstance().prepareBuildDir(getProject());
 357
 358         String buildDir = getProject().getProperty("BUILD_DIR");
 359         //
 360         // For every Target and ToolChain
 361         //
 362         String[] targetList = GlobalData.getToolChainInfo().getTargets();
 363         for (int i = 0; i < targetList.length; i++) {
 364             String[] toolchainList = GlobalData.getToolChainInfo().getTagnames();
 365             for(int j = 0; j < toolchainList.length; j++) {
 366                 //
 367                 // Prepare FV_DIR
 368                 //
 369                 String ffsCommonDir = buildDir + File.separatorChar
 370                                 + targetList[i] + "_"
 371                                 + toolchainList[j];
 372                 File fvDir = new File(ffsCommonDir + File.separatorChar + "FV");
 373                 fvDir.mkdirs();
 374             }
 375         }
 376
 377         String platformBuildFile = buildDir + File.separatorChar + platformId.getName() + "_build.xml";
 378         PlatformBuildFileGenerator fileGenerator = new PlatformBuildFileGenerator(getProject(), outfiles, fvs, isUnified, saq, platformBuildFile);
 379         fileGenerator.genBuildFile();
 380
 381         Ant ant = new Ant();
 382         ant.setProject(getProject());
 383         ant.setAntfile(platformBuildFile);
 384         ant.setTarget("prebuild");
 385         ant.setInheritAll(true);
 386         ant.init();
 387         ant.execute();
 388     }
 389
 390     /**
 391       Parse FPD file.
 392
 393       @throws BuildException
 394                   FPD file is not valid.
 395      **/
 396     void parseFpdFile() throws BuildException {
 397         try {
 398             XmlObject doc = XmlObject.Factory.parse(fpdFile);
 399
 400             if (!doc.validate()) {
 401                 throw new BuildException("Platform Surface Area file [" + fpdFile.getPath() + "] format is invalid!");
 402             }
 403
 404             Map<String, XmlObject> map = new HashMap<String, XmlObject>();
 405             map.put("PlatformSurfaceArea", doc);
 406             saq = new SurfaceAreaQuery(map);
 407
 408             //
 409             // Initialize
 410             //
 411             platformId = saq.getFpdHeader();
 412             platformId.setFpdFile(fpdFile);
 413             getProject().setProperty("PLATFORM", platformId.getName());
 414             getProject().setProperty("PLATFORM_FILE", platformId.getRelativeFpdFile().replaceAll("(\\\\)", "/"));
 415             getProject().setProperty("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
 416             getProject().setProperty("PLATFORM_RELATIVE_DIR", platformId.getPlatformRelativeDir().replaceAll("(\\\\)", "/"));
 417
 418             if( !FrameworkBuildTask.multithread) {
 419                 FrameworkBuildTask.originalProperties.put("PLATFORM", platformId.getName());
 420                 FrameworkBuildTask.originalProperties.put("PLATFORM_FILE", platformId.getRelativeFpdFile().replaceAll("(\\\\)", "/"));
 421                 FrameworkBuildTask.originalProperties.put("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
 422                 FrameworkBuildTask.originalProperties.put("PLATFORM_RELATIVE_DIR", platformId.getPlatformRelativeDir().replaceAll("(\\\\)", "/"));
 423             }
 424
 425             //
 426             // Build mode. User-defined output dir.
 427             //
 428             String buildMode = saq.getFpdIntermediateDirectories();
 429             String userDefinedOutputDir = saq.getFpdOutputDirectory();
 430
 431             OutputManager.getInstance().setup(userDefinedOutputDir, buildMode);
 432
 433             //
 434             // TBD. Deal PCD and BuildOption related Info
 435             //
 436             GlobalData.setFpdBuildOptions(saq.getFpdBuildOptions());
 437
 438             GlobalData.setToolChainPlatformInfo(saq.getFpdToolChainInfo());
 439
 440             //
 441             // Parse all list modules SA
 442             //
 443             parseModuleSAFiles();
 444
 445             //
 446             // TBD. Deal PCD and BuildOption related Info
 447             //
 448             parseToolChainFamilyOptions();
 449             parseToolChainOptions();
 450
 451             saq.push(map);
 452
 453             //
 454             // Pcd Collection. Call CollectPCDAction to collect pcd info.
 455             //
 456             PlatformPcdPreprocessActionForBuilding ca = new PlatformPcdPreprocessActionForBuilding();
 457             ca.perform(platformId.getFpdFile().getPath(), ActionMessage.NULL_MESSAGE_LEVEL);
 458         } catch (IOException ex) {
 459             BuildException buildException = new BuildException("Parsing of the FPD file [" + fpdFile.getPath() + "] failed!\n" + ex.getMessage());
 460             buildException.setStackTrace(ex.getStackTrace());
 461             throw buildException;
 462         } catch (XmlException ex) {
 463             BuildException buildException = new BuildException("Parsing of the FPD file [" + fpdFile.getPath() + "] failed!\n" + ex.getMessage());
 464             buildException.setStackTrace(ex.getStackTrace());
 465             throw buildException;
 466         } catch (EdkException ex) {
 467             BuildException buildException = new BuildException("Parsing of the FPD file [" + fpdFile.getPath() + "] failed!\n" + ex.getMessage());
 468             buildException.setStackTrace(ex.getStackTrace());
 469             throw buildException;
 470         }
 471     }
 472
 473     /**
 474       Parse all modules listed in FPD file.
 475     **/
 476     void parseModuleSAFiles() throws EdkException{
 477         Map<FpdModuleIdentification, Map<String, XmlObject>> moduleSAs = saq.getFpdModules();
 478
 479         //
 480         // For every Module lists in FPD file.
 481         //
 482         Set<FpdModuleIdentification> keys = moduleSAs.keySet();
 483         Iterator iter = keys.iterator();
 484         while (iter.hasNext()) {
 485             FpdModuleIdentification fpdModuleId = (FpdModuleIdentification) iter.next();
 486
 487             //
 488             // Judge if Module is existed?
 489             // TBD
 490             GlobalData.registerFpdModuleSA(fpdModuleId, moduleSAs.get(fpdModuleId));
 491
 492             //
 493             // Put fpdModuleId to the corresponding FV
 494             //
 495             saq.push(GlobalData.getDoc(fpdModuleId));
 496             String fvBinding = saq.getModuleFvBindingKeyword();
 497
 498             fpdModuleId.setFvBinding(fvBinding);
 499             updateFvs(fvBinding, fpdModuleId);
 500
 501             //
 502             // Prepare for out put file name
 503             //
 504             ModuleIdentification moduleId = fpdModuleId.getModule();
 505
 506             String baseName = saq.getModuleOutputFileBasename();
 507
 508             if (baseName == null) {
 509                 baseName = moduleId.getName();
 510             }
 511             outfiles.put(fpdModuleId, fpdModuleId.getArch() + File.separatorChar
 512                          + moduleId.getGuid() + "-" + baseName
 513                          + getSuffix(moduleId.getModuleType()));
 514
 515             //
 516             // parse module build options, if any
 517             //
 518             GlobalData.addModuleToolChainOption(fpdModuleId, parseModuleBuildOptions(false));
 519             GlobalData.addModuleToolChainFamilyOption(fpdModuleId, parseModuleBuildOptions(true));
 520             saq.pop();
 521         }
 522     }
 523
 524     ToolChainMap parseModuleBuildOptions(boolean toolChainFamilyFlag) throws EdkException {
 525         String[][] options = saq.getModuleBuildOptions(toolChainFamilyFlag);
 526         if (options == null || options.length == 0) {
 527             return new ToolChainMap();
 528         }
 529         return parseOptions(options);
 530     }
 531
 532     private ToolChainMap parsePlatformBuildOptions(boolean toolChainFamilyFlag) throws EdkException {
 533         String[][] options = saq.getPlatformBuildOptions(toolChainFamilyFlag);
 534         if (options == null || options.length == 0) {
 535             return new ToolChainMap();
 536         }
 537         return parseOptions(options);
 538     }
 539
 540     private ToolChainMap parseOptions(String[][] options) throws EdkException {
 541         ToolChainMap map = new ToolChainMap();
 542         int flagIndex = ToolChainElement.ATTRIBUTE.value;
 543
 544         for (int i = 0; i < options.length; ++i) {
 545             String flagString = options[i][flagIndex];
 546             if (flagString == null) {
 547                 flagString = "";
 548             }
 549             options[i][flagIndex] = ToolChainAttribute.FLAGS + "";
 550             map.put(options[i], flagString.trim());
 551         }
 552
 553         return map;
 554     }
 555
 556     private void parseToolChainFamilyOptions() throws EdkException {
 557         GlobalData.setPlatformToolChainFamilyOption(parsePlatformBuildOptions(true));
 558     }
 559
 560     private void parseToolChainOptions() throws EdkException {
 561         GlobalData.setPlatformToolChainOption(parsePlatformBuildOptions(false));
 562     }
 563
 564     /**
 565       Add the current module to corresponding FV.
 566
 567       @param fvName current FV name
 568       @param moduleName current module identification
 569     **/
 570     void updateFvs(String fvName, FpdModuleIdentification fpdModuleId) {
 571         if (fvName == null || fvName.trim().length() == 0) {
 572             fvName = "NULL";
 573         }
 574         String[] fvNameArray = fvName.split("[, \t]+");
 575         for (int i = 0; i < fvNameArray.length; i++) {
 576             //
 577             // Put module to corresponding fvName
 578             //
 579             if (fvs.containsKey(fvNameArray[i])) {
 580                 Set<FpdModuleIdentification> set = fvs.get(fvNameArray[i]);
 581                 set.add(fpdModuleId);
 582             } else {
 583                 Set<FpdModuleIdentification> set = new LinkedHashSet<FpdModuleIdentification>();
 584                 set.add(fpdModuleId);
 585                 fvs.put(fvNameArray[i], set);
 586             }
 587         }
 588     }
 589
 590     /**
 591       Get the suffix based on module type. Current relationship are listed:
 592
 593       <pre>
 594       <b>ModuleType</b>     <b>Suffix</b>
 595       BASE                 .FFS
 596       SEC                  .SEC
 597       PEI_CORE             .PEI
 598       PEIM                 .PEI
 599       DXE_CORE             .DXE
 600       DXE_DRIVER           .DXE
 601       DXE_RUNTIME_DRIVER   .DXE
 602       DXE_SAL_DRIVER       .DXE
 603       DXE_SMM_DRIVER       .DXE
 604       TOOL                 .FFS
 605       UEFI_DRIVER          .DXE
 606       UEFI_APPLICATION     .APP
 607       USER_DEFINED         .FFS
 608       </pre>
 609
 610       @param moduleType module type
 611       @return
 612       @throws BuildException
 613       If module type is null
 614     **/
 615     public static String getSuffix(String moduleType) throws BuildException {
 616         if (moduleType == null) {
 617             throw new BuildException("Module type is not specified.");
 618         }
 619
 620         String[][] suffix = EdkDefinitions.ModuleTypeExtensions;
 621
 622         for (int i = 0; i < suffix.length; i++) {
 623             if (suffix[i][0].equalsIgnoreCase(moduleType)) {
 624                 return suffix[i][1];
 625             }
 626         }
 627         //
 628         // Default is '.FFS'
 629         //
 630         return ".FFS";
 631     }
 632     /**
 633      Add a property.
 634
 635      @param p property
 636      **/
 637     public void addProperty(Property p) {
 638         properties.addElement(p);
 639     }
 640
 641     public void setFpdFile(File fpdFile) {
 642         this.fpdFile = fpdFile;
 643     }
 644
 645     public void setType(String type) {
 646         this.type = type;
 647     }
 648
 649     public String getAllArchForModule(ModuleIdentification moduleId) {
 650         String archs = "";
 651         Iterator<FpdModuleIdentification> iter = outfiles.keySet().iterator();
 652         while (iter.hasNext()) {
 653             FpdModuleIdentification fpdModuleId = iter.next();
 654
 655             if (fpdModuleId.getModule().equals(moduleId)) {
 656                 archs += fpdModuleId.getArch() + " ";
 657             }
 658         }
 659
 660         return archs;
 661     }
 662
 663     private Set<FpdModuleIdentification> getModuleSequenceForFv(String fvName) throws EdkException {
 664         Node node = saq.getFpdModuleSequence(fvName);
 665         Set<FpdModuleIdentification> result = new LinkedHashSet<FpdModuleIdentification>();
 666
 667         if ( node == null) {
 668             EdkLog.log(this, EdkLog.EDK_WARNING, "FV[" + fvName + "] does not specify module sequence in FPD. Assuming present sequence as default sequence in FV. ");
 669             return null;
 670         } else {
 671             NodeList childNodes = node.getChildNodes();
 672             for (int i = 0; i < childNodes.getLength(); i++) {
 673                 Node childItem = childNodes.item(i);
 674                 if (childItem.getNodeType() == Node.ELEMENT_NODE) {
 675                     //
 676                     // Find child elements "IncludeModules"
 677                     //
 678                     if (childItem.getNodeName().compareTo("IncludeModules") == 0) {
 679                         //
 680                         // result will be updated
 681                         //
 682                         processNodes(childItem, result);
 683                     } else if (childItem.getNodeName().compareTo("FvName") == 0) {
 684
 685                     } else if (childItem.getNodeName().compareTo("InfFileName") == 0) {
 686
 687                     } else {
 688                         //
 689                         // Report Warning
 690                         //
 691                         EdkLog.log(this, EdkLog.EDK_WARNING, "Unrecognised element " + childItem.getNodeName() + " under FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1']");
 692                     }
 693                 }
 694             }
 695         }
 696
 697         return result;
 698     }
 699
 700     private void processNodes(Node node, Set<FpdModuleIdentification> result) throws EdkException {
 701         //
 702         // Found out all elements "Module"
 703         //
 704         NodeList childNodes = node.getChildNodes();
 705         for (int j = 0; j < childNodes.getLength(); j++) {
 706             Node childItem = childNodes.item(j);
 707             if (childItem.getNodeType() == Node.ELEMENT_NODE) {
 708                 if (childItem.getNodeName().compareTo("Module") == 0) {
 709                     String moduleGuid = null;
 710                     String moduleVersion = null;
 711                     String packageGuid = null;
 712                     String packageVersion = null;
 713                     String arch = null;
 714
 715                     NamedNodeMap attr = childItem.getAttributes();
 716                     for (int i = 0; i < attr.getLength(); i++) {
 717                         Node attrItem = attr.item(i);
 718                         if (attrItem.getNodeName().compareTo("ModuleGuid") == 0) {
 719                             moduleGuid = attrItem.getNodeValue();
 720                         } else if (attrItem.getNodeName().compareTo("ModuleVersion") == 0) {
 721                             moduleVersion = attrItem.getNodeValue();
 722                         } else if (attrItem.getNodeName().compareTo("PackageGuid") == 0) {
 723                             packageGuid = attrItem.getNodeValue();
 724                         } else if (attrItem.getNodeName().compareTo("PackageVersion") == 0) {
 725                             packageVersion = attrItem.getNodeValue();
 726                         } else if (attrItem.getNodeName().compareTo("Arch") == 0) {
 727                             arch = attrItem.getNodeValue();
 728                         } else {
 729                             //
 730                             // Report warning
 731                             //
 732                             EdkLog.log(this, EdkLog.EDK_WARNING, "Unrecognised attribute " + attrItem.getNodeName() + " under FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1'].IncludeModules.Module");
 733                         }
 734                     }
 735
 736                     PackageIdentification packageId = new PackageIdentification(packageGuid, packageVersion);
 737                     GlobalData.refreshPackageIdentification(packageId);
 738
 739                     ModuleIdentification moduleId = new ModuleIdentification(moduleGuid, moduleVersion);
 740                     moduleId.setPackage(packageId);
 741                     GlobalData.refreshModuleIdentification(moduleId);
 742
 743                     if (arch == null) {
 744                         throw new EdkException("Attribute [Arch] is required for element FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1'].IncludeModules.Module. ");
 745                     }
 746
 747                     result.add(new FpdModuleIdentification(moduleId, arch));
 748                 } else {
 749                     //
 750                     // Report Warning
 751                     //
 752                     EdkLog.log(this, EdkLog.EDK_WARNING, "Unrecognised element " + childItem.getNodeName() + " under FPD.BuildOptions.UserExtensions[UserID='IMAGES' Identifier='1'].IncludeModules");
 753                 }
 754             }
 755         }
 756     }
 757 }