Tools/Java/Source/GenBuild/org/tianocore/build/GenBuildTask.java

   1 /** @file
   2   This file is ANT task GenBuild.
   3
   4   The file is used to parse a specified Module, and generate its build time
   5   ANT script build.xml, then call the the ANT script to build the module.
   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;
  17
  18 import java.io.File;
  19 import java.util.Hashtable;
  20 import java.util.Iterator;
  21 import java.util.LinkedHashSet;
  22 import java.util.List;
  23 import java.util.Map;
  24 import java.util.Set;
  25 import java.util.Vector;
  26
  27 import org.apache.tools.ant.BuildException;
  28 import org.apache.tools.ant.BuildListener;
  29 import org.apache.tools.ant.Project;
  30 import org.apache.tools.ant.taskdefs.Ant;
  31 import org.apache.tools.ant.taskdefs.Property;
  32 import org.apache.xmlbeans.XmlObject;
  33
  34 import org.tianocore.common.definitions.ToolDefinitions;
  35 import org.tianocore.common.exception.EdkException;
  36 import org.tianocore.common.logger.EdkLog;
  37 import org.tianocore.build.autogen.AutoGen;
  38 import org.tianocore.build.exception.AutoGenException;
  39 import org.tianocore.build.exception.GenBuildException;
  40 import org.tianocore.build.exception.PcdAutogenException;
  41 import org.tianocore.build.exception.PlatformPcdPreprocessBuildException;
  42 import org.tianocore.build.fpd.FpdParserTask;
  43 import org.tianocore.build.global.GlobalData;
  44 import org.tianocore.build.global.OutputManager;
  45 import org.tianocore.build.global.SurfaceAreaQuery;
  46 import org.tianocore.build.id.FpdModuleIdentification;
  47 import org.tianocore.build.id.ModuleIdentification;
  48 import org.tianocore.build.id.PackageIdentification;
  49 import org.tianocore.build.id.PlatformIdentification;
  50 import org.tianocore.build.tools.ModuleItem;
  51
  52 /**
  53   <p>
  54   <code>GenBuildTask</code> is an ANT task that can be used in ANT build
  55   system.
  56
  57   <p>The main function of this task is to parse module's surface area (MSA),
  58   then generate the corresponding <em>BaseName_build.xml</em> (the real ANT
  59   build script) and call this to build the module. The whole process including:
  60
  61   <pre>
  62   1. generate AutoGen.c and AutoGen.h;
  63   2. build all dependent library instances;
  64   3. build all source files inlcude AutoGen.c;
  65   4. generate sections;
  66   5. generate FFS file if it is driver module while LIB file if it is Library module.
  67   </pre>
  68
  69
  70   <p>
  71   The usage is (take module <em>HelloWorld</em> for example):
  72   </p>
  73
  74   <pre>
  75     &lt;GenBuild
  76        msaFile="${PACKAGE_DIR}/Application/HelloWorld/HelloWorld.msa"
  77        type="cleanall" /&gt;
  78   </pre>
  79
  80   <p>
  81   This task calls <code>AutoGen</code> to generate <em>AutoGen.c</em> and
  82   <em>AutoGen.h</em>.
  83   </p>
  84
  85   <p>
  86   This task will also set properties for current module, such as PACKAGE,
  87   PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
  88   (relative to Workspace), MODULE or BASE_NAME, GUID, VERSION, MODULE_DIR,
  89   MODULE_RELATIVE_DIR (relative to Package), CONFIG_DIR, BIN_DIR,
  90   DEST_DIR_DEBUG, DEST_DIR_OUTPUT, TARGET, ARCH, TOOLCHAIN, TOOLCHAIN_FAMILY,
  91   SUBSYSTEM, ENTRYPOINT, EBC_TOOL_LIB_PATH, all compiler command related
  92   properties (CC, CC_FLAGS, CC_DPATH, CC_SPATH, CC_FAMILY, CC_EXT).
  93   </p>
  94
  95   @since GenBuild 1.0
  96 **/
  97 public class GenBuildTask extends Ant {
  98
  99     ///
 100     /// Module surface area file.
 101     ///
 102     File msaFile;
 103
 104     public ModuleIdentification parentId;
 105
 106     private String type = "all";
 107
 108     ///
 109     /// Module's Identification.
 110     ///
 111     private ModuleIdentification moduleId;
 112
 113     private Vector<Property> properties = new Vector<Property>();
 114
 115     private boolean isSingleModuleBuild = false;
 116
 117     private SurfaceAreaQuery saq = null;
 118
 119     /**
 120       Public construct method. It is necessary for ANT task.
 121     **/
 122     public GenBuildTask() {
 123     }
 124
 125     /**
 126
 127       @throws BuildException
 128               From module build, exception from module surface area invalid.
 129     **/
 130     public void execute() throws BuildException {
 131         this.setTaskName("GenBuild");
 132         try {
 133             processGenBuild();
 134         } catch (PcdAutogenException e) {
 135             BuildException buildException = new BuildException(e.getMessage());
 136             buildException.setStackTrace(e.getStackTrace());
 137             throw buildException;
 138         } catch (AutoGenException e) {
 139             BuildException buildException = new BuildException(e.getMessage());
 140             buildException.setStackTrace(e.getStackTrace());
 141             throw buildException;
 142         } catch (PlatformPcdPreprocessBuildException e) {
 143             BuildException buildException = new BuildException(e.getMessage());
 144             buildException.setStackTrace(e.getStackTrace());
 145             throw buildException;
 146         } catch (GenBuildException e) {
 147             BuildException buildException = new BuildException(e.getMessage());
 148             buildException.setStackTrace(e.getStackTrace());
 149             throw buildException;
 150         } catch (EdkException e) {
 151             BuildException buildException = new BuildException(e.getMessage());
 152             buildException.setStackTrace(e.getStackTrace());
 153             throw buildException;
 154         }
 155     }
 156
 157     private void processGenBuild() throws EdkException, BuildException, GenBuildException, AutoGenException, PcdAutogenException, PlatformPcdPreprocessBuildException {
 158         if (!FrameworkBuildTask.multithread) {
 159             cleanupProperties();
 160         }
 161
 162         //
 163         // Enable all specified properties
 164         //
 165         Iterator<Property> iter = properties.iterator();
 166         while (iter.hasNext()) {
 167             Property item = iter.next();
 168             getProject().setProperty(item.getName(), item.getValue());
 169         }
 170
 171         //
 172         // GenBuild should specify either msaFile or moduleGuid & packageGuid
 173         //
 174         if (msaFile == null ) {
 175             String moduleGuid = getProject().getProperty("MODULE_GUID");
 176             String moduleVersion = getProject().getProperty("MODULE_VERSION");
 177             String packageGuid = getProject().getProperty("PACKAGE_GUID");
 178             String packageVersion = getProject().getProperty("PACKAGE_VERSION");
 179             //
 180             // If one of module Guid or package Guid is not specified, report error
 181             //
 182             if (moduleGuid == null || packageGuid == null) {
 183                 throw new BuildException("GenBuild parameter error.");
 184             }
 185
 186             PackageIdentification packageId = new PackageIdentification(packageGuid, packageVersion);
 187             GlobalData.refreshPackageIdentification(packageId);
 188             moduleId = new ModuleIdentification(moduleGuid, moduleVersion);
 189             moduleId.setPackage(packageId);
 190             GlobalData.refreshModuleIdentification(moduleId);
 191             Map<String, XmlObject> doc = GlobalData.getNativeMsa(moduleId);
 192             saq = new SurfaceAreaQuery(doc);
 193         } else {
 194             Map<String, XmlObject> doc = GlobalData.getNativeMsa(msaFile);
 195             saq = new SurfaceAreaQuery(doc);
 196             moduleId = saq.getMsaHeader();
 197             moduleId.setMsaFile(msaFile);
 198         }
 199
 200         String[] producedLibraryClasses = saq.getLibraryClasses("ALWAYS_PRODUCED",null);
 201         if (producedLibraryClasses.length == 0) {
 202             moduleId.setLibrary(false);
 203         } else {
 204             moduleId.setLibrary(true);
 205         }
 206
 207         //
 208         // Judge whether it is single module build or not
 209         //
 210         if (isSingleModuleBuild) {
 211             //
 212             // Single Module build
 213             //
 214             prepareSingleModuleBuild();
 215         }
 216
 217         //
 218         // If single module : get arch from pass down, otherwise intersection MSA
 219         // supported ARCHs and tools def
 220         //
 221         Set<String> archListSupByToolChain = new LinkedHashSet<String>();
 222         String[] archs = GlobalData.getToolChainInfo().getArchs();
 223
 224         for (int i = 0; i < archs.length; i ++) {
 225             archListSupByToolChain.add(archs[i]);
 226         }
 227
 228         Set<String> archSet = new LinkedHashSet<String>();
 229
 230         if ( getProject().getProperty("ARCH") != null) {
 231             String[] fpdArchList = getProject().getProperty("ARCH").split(" ");
 232
 233             for (int i = 0; i < fpdArchList.length; i++) {
 234                 if (archListSupByToolChain.contains(fpdArchList[i])) {
 235                     archSet.add(fpdArchList[i]);
 236                 }
 237             }
 238         } else {
 239             archSet = archListSupByToolChain;
 240         }
 241
 242         String[] archList = archSet.toArray(new String[archSet.size()]);
 243
 244         //
 245         // Judge if arch is all supported by current module. If not, throw Exception.
 246         //
 247         List moduleSupportedArchs = saq.getModuleSupportedArchs();
 248         if (moduleSupportedArchs != null) {
 249             for (int k = 0; k < archList.length; k++) {
 250                 if ( ! moduleSupportedArchs.contains(archList[k])) {
 251                     throw new BuildException("Specified architecture [" + archList[k] + "] is not supported by " + moduleId + ". The module " + moduleId + " only supports [" + moduleSupportedArchs + "] architectures.");
 252                 }
 253             }
 254         }
 255
 256         if (archList.length == 0) {
 257             EdkLog.log(this, EdkLog.EDK_WARNING, "Warning: " + moduleId + " was not found in current platform FPD file!\n");
 258         }
 259
 260         for (int k = 0; k < archList.length; k++) {
 261
 262             getProject().setProperty("ARCH", archList[k]);
 263
 264             FpdModuleIdentification fpdModuleId = new FpdModuleIdentification(moduleId, archList[k]);
 265
 266             //
 267             // Whether the module is built before
 268             //
 269             if (moduleId.isLibrary() == false && GlobalData.hasFpdModuleSA(fpdModuleId) == false) {
 270                 EdkLog.log(this, EdkLog.EDK_WARNING, "Warning: " + moduleId + " for " + archList[k] + " was not found in current platform FPD file!\n");
 271                 continue;
 272             } else if (GlobalData.isModuleBuilt(fpdModuleId)) {
 273                 break;
 274             } else {
 275                 GlobalData.registerBuiltModule(fpdModuleId);
 276             }
 277
 278             //
 279             // For Every TOOLCHAIN, TARGET
 280             //
 281             String[] targetList =  GlobalData.getToolChainInfo().getTargets();
 282             for (int i = 0; i < targetList.length; i ++){
 283                 //
 284                 // Prepare for target related common properties
 285                 // TARGET
 286                 //
 287                 getProject().setProperty("TARGET", targetList[i]);
 288                 String[] toolchainList = GlobalData.getToolChainInfo().getTagnames();
 289                 for(int j = 0; j < toolchainList.length; j ++){
 290                     //
 291                     // check if any tool is defined for current target + toolchain + arch
 292                     // don't do anything if no tools found
 293                     //
 294                     if (GlobalData.isCommandSet(targetList[i], toolchainList[j], archList[k]) == false) {
 295                         EdkLog.log(this, EdkLog.EDK_WARNING, "Warning: No build issued.  No tools found for [target=" + targetList[i] + " toolchain=" + toolchainList[j] + " arch=" + archList[k] + "]\n");
 296                         continue;
 297                     }
 298
 299                     //
 300                     // Prepare for toolchain related common properties
 301                     // TOOLCHAIN
 302                     //
 303                     getProject().setProperty("TOOLCHAIN", toolchainList[j]);
 304
 305                     EdkLog.log(this, "Build " + moduleId + " start >>>");
 306                     EdkLog.log(this, "Target: " + targetList[i] + " Tagname: " + toolchainList[j] + " Arch: " + archList[k]);
 307                     saq.push(GlobalData.getDoc(fpdModuleId));
 308
 309                     //
 310                     // Prepare for all other common properties
 311                     // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
 312                     // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
 313                     // MODULE_DIR, MODULE_RELATIVE_DIR
 314                     // SUBSYSTEM, ENTRYPOINT, EBC_TOOL_LIB_PATH
 315                     //
 316                     setModuleCommonProperties(archList[k]);
 317
 318                     //
 319                     // OutputManage prepare for
 320                     // BIN_DIR, DEST_DIR_DEBUG, DEST_DIR_OUTPUT, BUILD_DIR, FV_DIR
 321                     //
 322                     OutputManager.getInstance().update(getProject());
 323
 324                     if (type.equalsIgnoreCase("all") || type.equalsIgnoreCase("build")) {
 325                         applyBuild(targetList[i], toolchainList[j], fpdModuleId);
 326                     } else if (type.equalsIgnoreCase("clean")) {
 327                         applyClean(fpdModuleId);
 328                     } else if (type.equalsIgnoreCase("cleanall")) {
 329                         applyCleanall(fpdModuleId);
 330                     }
 331                 }
 332             }
 333         }
 334     }
 335
 336     /**
 337       This method is used to prepare Platform-related information.
 338
 339       <p>In Single Module Build mode, platform-related information is not ready.
 340       The method read the system environment variable <code>ACTIVE_PLATFORM</code>
 341       and search in the Framework Database. Note that platform name in the Framework
 342       Database must be unique. </p>
 343
 344     **/
 345     private void prepareSingleModuleBuild() throws EdkException {
 346         //
 347         // Find out the package which the module belongs to
 348         //
 349         PackageIdentification packageId = GlobalData.getPackageForModule(moduleId);
 350         GlobalData.refreshPackageIdentification(packageId);
 351         moduleId.setPackage(packageId);
 352         GlobalData.refreshModuleIdentification(moduleId);
 353
 354         //
 355         // Read ACTIVE_PLATFORM's FPD file
 356         //
 357         String filename = getProject().getProperty("PLATFORM_FILE");
 358
 359         if (filename == null){
 360             throw new BuildException("Please set ACTIVE_PLATFORM in the file: Tools/Conf/target.txt if you want to build a single module!");
 361         }
 362
 363         PlatformIdentification platformId = GlobalData.getPlatform(filename);
 364
 365         //
 366         // Read FPD file (Call FpdParserTask's method)
 367         //
 368         FpdParserTask fpdParser = new FpdParserTask();
 369         fpdParser.setProject(getProject());
 370         fpdParser.parseFpdFile(platformId.getFpdFile());
 371         getProject().setProperty("ARCH", fpdParser.getAllArchForModule(moduleId));
 372     }
 373
 374     private void cleanupProperties() {
 375         Project newProject = new Project();
 376
 377         Hashtable<String, String> passdownProperties = FrameworkBuildTask.originalProperties;
 378         Iterator<String> iter = passdownProperties.keySet().iterator();
 379         while (iter.hasNext()) {
 380             String item = iter.next();
 381             newProject.setProperty(item, passdownProperties.get(item));
 382         }
 383
 384         newProject.setInputHandler(getProject().getInputHandler());
 385
 386         Iterator listenerIter = getProject().getBuildListeners().iterator();
 387         while (listenerIter.hasNext()) {
 388             newProject.addBuildListener((BuildListener) listenerIter.next());
 389         }
 390
 391         getProject().initSubProject(newProject);
 392
 393         setProject(newProject);
 394     }
 395
 396     /**
 397       Set Module-Related information to properties.
 398
 399       @param arch current build ARCH
 400     **/
 401     private void setModuleCommonProperties(String arch) {
 402         //
 403         // Prepare for all other common properties
 404         // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
 405         //
 406         PackageIdentification packageId = moduleId.getPackage();
 407         getProject().setProperty("PACKAGE", packageId.getName());
 408         getProject().setProperty("PACKAGE_GUID", packageId.getGuid());
 409         getProject().setProperty("PACKAGE_VERSION", packageId.getVersion());
 410         getProject().setProperty("PACKAGE_DIR", packageId.getPackageDir().replaceAll("(\\\\)", "/"));
 411         getProject().setProperty("PACKAGE_RELATIVE_DIR", packageId.getPackageRelativeDir().replaceAll("(\\\\)", "/"));
 412
 413         //
 414         // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
 415         // MODULE_DIR, MODULE_RELATIVE_DIR
 416         //
 417         getProject().setProperty("MODULE", moduleId.getName());
 418         String baseName = saq.getModuleOutputFileBasename();
 419         if (baseName == null) {
 420             getProject().setProperty("BASE_NAME", moduleId.getName());
 421         } else {
 422             getProject().setProperty("BASE_NAME", baseName);
 423         }
 424         getProject().setProperty("GUID", moduleId.getGuid());
 425         getProject().setProperty("FILE_GUID", moduleId.getGuid());
 426         getProject().setProperty("VERSION", moduleId.getVersion());
 427         getProject().setProperty("MODULE_TYPE", moduleId.getModuleType());
 428         getProject().setProperty("MODULE_DIR", moduleId.getMsaFile().getParent().replaceAll("(\\\\)", "/"));
 429         getProject().setProperty("MODULE_RELATIVE_DIR", moduleId.getModuleRelativePath().replaceAll("(\\\\)", "/") + File.separatorChar + moduleId.getName());
 430
 431         //
 432         // SUBSYSTEM
 433         //
 434         String[][] subsystemMap = { { "BASE", "EFI_BOOT_SERVICE_DRIVER"},
 435                                     { "SEC", "EFI_BOOT_SERVICE_DRIVER" },
 436                                     { "PEI_CORE", "EFI_BOOT_SERVICE_DRIVER" },
 437                                     { "PEIM", "EFI_BOOT_SERVICE_DRIVER" },
 438                                     { "DXE_CORE", "EFI_BOOT_SERVICE_DRIVER" },
 439                                     { "DXE_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 440                                     { "DXE_RUNTIME_DRIVER", "EFI_RUNTIME_DRIVER" },
 441                                     { "DXE_SAL_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 442                                     { "DXE_SMM_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 443                                     { "TOOL", "EFI_BOOT_SERVICE_DRIVER" },
 444                                     { "UEFI_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 445                                     { "UEFI_APPLICATION", "EFI_APPLICATION" },
 446                                     { "USER_DEFINED", "EFI_BOOT_SERVICE_DRIVER"} };
 447
 448         String subsystem = "EFI_BOOT_SERVICE_DRIVER";
 449         for (int i = 0; i < subsystemMap.length; i++) {
 450             if (moduleId.getModuleType().equalsIgnoreCase(subsystemMap[i][0])) {
 451                 subsystem = subsystemMap[i][1];
 452                 break ;
 453             }
 454         }
 455         getProject().setProperty("SUBSYSTEM", subsystem);
 456
 457         //
 458         // ENTRYPOINT
 459         //
 460         if (arch.equalsIgnoreCase("EBC")) {
 461             getProject().setProperty("ENTRYPOINT", "EfiStart");
 462         } else {
 463             getProject().setProperty("ENTRYPOINT", "_ModuleEntryPoint");
 464         }
 465
 466         getProject().setProperty("OBJECTS", "");
 467     }
 468
 469     private void getCompilerFlags(String target, String toolchain, FpdModuleIdentification fpdModuleId) throws EdkException {
 470         String[] cmd = GlobalData.getToolChainInfo().getCommands();
 471         for ( int m = 0; m < cmd.length; m++) {
 472             //
 473             // Set cmd, like CC, DLINK
 474             //
 475             String[] key = new String[]{target, toolchain, fpdModuleId.getArch(), cmd[m], null};
 476             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_PATH;
 477             String cmdPath = GlobalData.getCommandSetting(key, fpdModuleId);
 478             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_NAME;
 479             String cmdName = GlobalData.getCommandSetting(key, fpdModuleId);
 480             if (cmdName.length() == 0) {
 481                 EdkLog.log(this, EdkLog.EDK_VERBOSE, "Warning: " + cmd[m] + " hasn't been defined!");
 482                 getProject().setProperty(cmd[m], "");
 483                 continue;
 484             }
 485             File cmdFile = new File(cmdPath + File.separatorChar + cmdName);
 486             getProject().setProperty(cmd[m], cmdFile.getPath().replaceAll("(\\\\)", "/"));
 487
 488             //
 489             // set CC_FLAGS
 490             //
 491             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_FLAGS;
 492             String cmdFlags = GlobalData.getCommandSetting(key, fpdModuleId);
 493             if (cmdFlags != null)
 494             {
 495               getProject().setProperty(cmd[m] + "_FLAGS", cmdFlags);
 496             }
 497             else
 498             {
 499               getProject().setProperty(cmd[m] + "_FLAGS", "");
 500             }
 501
 502             //
 503             // Set CC_EXT
 504             //
 505             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_EXT;
 506             String extName = GlobalData.getCommandSetting(key, fpdModuleId);
 507             if ( extName != null && ! extName.equalsIgnoreCase("")) {
 508                 getProject().setProperty(cmd[m] + "_EXT", extName);
 509             } else {
 510                 getProject().setProperty(cmd[m] + "_EXT", "");
 511             }
 512
 513             //
 514             // set CC_FAMILY
 515             //
 516             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_FAMILY;
 517             String toolChainFamily = GlobalData.getCommandSetting(key, fpdModuleId);
 518             if (toolChainFamily != null) {
 519                 getProject().setProperty(cmd[m] + "_FAMILY", toolChainFamily);
 520             }
 521
 522             //
 523             // set CC_SPATH
 524             //
 525             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_SPATH;
 526             String spath = GlobalData.getCommandSetting(key, fpdModuleId);
 527             if (spath != null) {
 528                 getProject().setProperty(cmd[m] + "_SPATH", spath.replaceAll("(\\\\)", "/"));
 529             } else {
 530                 getProject().setProperty(cmd[m] + "_SPATH", "");
 531             }
 532
 533             //
 534             // set CC_DPATH
 535             //
 536             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_DPATH;
 537             String dpath = GlobalData.getCommandSetting(key, fpdModuleId);
 538             if (dpath != null) {
 539                 getProject().setProperty(cmd[m] + "_DPATH", dpath.replaceAll("(\\\\)", "/"));
 540             } else {
 541                 getProject().setProperty(cmd[m] + "_DPATH", "");
 542             }
 543
 544             //
 545             // Set CC_LIBPATH
 546             //
 547             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_LIBPATH;
 548             String libpath = GlobalData.getCommandSetting(key, fpdModuleId);
 549             if (libpath != null) {
 550                 getProject().setProperty(cmd[m] + "_LIBPATH", libpath.replaceAll("(\\\\)", "/"));
 551             } else {
 552                 getProject().setProperty(cmd[m] + "_LIBPATH", "");
 553             }
 554
 555             //
 556             // Set CC_INCLUDEPATH
 557             //
 558             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_INCLUDEPATH;
 559             String includepath = GlobalData.getCommandSetting(key, fpdModuleId);
 560             if (dpath != null) {
 561                 getProject().setProperty(cmd[m] + "_INCLUDEPATH", includepath.replaceAll("(\\\\)", "/"));
 562             } else {
 563                 getProject().setProperty(cmd[m] + "_INCLUDEPATH", "");
 564             }
 565         }
 566     }
 567
 568     public void setMsaFile(File msaFile) {
 569         this.msaFile = msaFile;
 570     }
 571
 572     /**
 573       Method is for ANT to initialize MSA file.
 574
 575       @param msaFilename MSA file name
 576     **/
 577     public void setMsaFile(String msaFilename) {
 578         String moduleDir = getProject().getProperty("MODULE_DIR");
 579
 580         //
 581         // If is Single Module Build, then use the Base Dir defined in build.xml
 582         //
 583         if (moduleDir == null) {
 584             moduleDir = getProject().getBaseDir().getPath();
 585         }
 586         msaFile = new File(moduleDir + File.separatorChar + msaFilename);
 587     }
 588
 589     public void addConfiguredModuleItem(ModuleItem moduleItem) {
 590         PackageIdentification packageId = new PackageIdentification(moduleItem.getPackageGuid(), moduleItem.getPackageVersion());
 591         ModuleIdentification moduleId = new ModuleIdentification(moduleItem.getModuleGuid(), moduleItem.getModuleVersion());
 592         moduleId.setPackage(packageId);
 593         this.moduleId = moduleId;
 594     }
 595
 596     /**
 597       Add a property.
 598
 599       @param p property
 600     **/
 601     public void addProperty(Property p) {
 602         properties.addElement(p);
 603     }
 604
 605     public void setType(String type) {
 606         this.type = type;
 607     }
 608
 609     private void applyBuild(String buildTarget, String buildTagname, FpdModuleIdentification fpdModuleId) throws EdkException {
 610         //
 611         // Call AutoGen to generate AutoGen.c and AutoGen.h
 612         //
 613         AutoGen autogen = new AutoGen(getProject().getProperty("FV_DIR"), getProject().getProperty("DEST_DIR_DEBUG"), fpdModuleId.getModule(),fpdModuleId.getArch(), saq, parentId);
 614         autogen.genAutogen();
 615
 616         //
 617         // Get compiler flags
 618         //
 619         try {
 620             getCompilerFlags(buildTarget, buildTagname, fpdModuleId);
 621         }
 622         catch (EdkException ee) {
 623             throw new BuildException(ee.getMessage());
 624         }
 625
 626         //
 627         // Prepare LIBS
 628         //
 629         ModuleIdentification[] libinstances = saq.getLibraryInstance(fpdModuleId.getArch());
 630         String propertyLibs = "";
 631         for (int i = 0; i < libinstances.length; i++) {
 632             propertyLibs += getProject().getProperty("BIN_DIR") + File.separatorChar + libinstances[i].getName() + ".lib" + " ";
 633         }
 634         getProject().setProperty("LIBS", propertyLibs.replaceAll("(\\\\)", "/"));
 635
 636         //
 637         // Get all includepath and set to INCLUDE_PATHS
 638         //
 639         String[] includes = prepareIncludePaths(fpdModuleId);
 640
 641         //
 642         // if it is CUSTOM_BUILD
 643         // then call the exist BaseName_build.xml directly.
 644         //
 645         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 646             EdkLog.log(this, "Call user-defined " + moduleId.getName() + "_build.xml");
 647
 648             String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
 649             antCall(antFilename, null);
 650
 651             return ;
 652         }
 653
 654         //
 655         // Generate ${BASE_NAME}_build.xml
 656         // TBD
 657         //
 658         String ffsKeyword = saq.getModuleFfsKeyword();
 659         ModuleBuildFileGenerator fileGenerator = new ModuleBuildFileGenerator(getProject(), ffsKeyword, fpdModuleId, includes, saq);
 660         String buildFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 661         fileGenerator.genBuildFile(buildFilename);
 662
 663         //
 664         // Ant call ${BASE_NAME}_build.xml
 665         //
 666         String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 667         antCall(antFilename, null);
 668     }
 669
 670     private void applyClean(FpdModuleIdentification fpdModuleId){
 671         //
 672         // if it is CUSTOM_BUILD
 673         // then call the exist BaseName_build.xml directly.
 674         //
 675         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 676             EdkLog.log(this, "Calling user-defined " + moduleId.getName() + "_build.xml");
 677
 678             String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
 679             antCall(antFilename, "clean");
 680
 681             return ;
 682         }
 683
 684         String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 685         antCall(antFilename, "clean");
 686     }
 687
 688     private void applyCleanall(FpdModuleIdentification fpdModuleId){
 689         //
 690         // if it is CUSTOM_BUILD
 691         // then call the exist BaseName_build.xml directly.
 692         //
 693         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 694             EdkLog.log(this, "Calling user-defined " + moduleId.getName() + "_build.xml");
 695
 696             String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
 697             antCall(antFilename, "cleanall");
 698
 699             return ;
 700         }
 701
 702         String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 703         antCall(antFilename, "cleanall");
 704     }
 705
 706     private void antCall(String antFilename, String target) {
 707         Ant ant = new Ant();
 708         ant.setProject(getProject());
 709         ant.setAntfile(antFilename);
 710         if (target != null) {
 711             ant.setTarget(target);
 712         }
 713         ant.setInheritAll(true);
 714         ant.init();
 715         ant.execute();
 716     }
 717
 718     public void setSingleModuleBuild(boolean isSingleModuleBuild) {
 719         this.isSingleModuleBuild = isSingleModuleBuild;
 720     }
 721
 722     private String[] prepareIncludePaths(FpdModuleIdentification fpdModuleId) throws EdkException{
 723         //
 724         // Prepare the includes: PackageDependencies and Output debug direactory
 725         //
 726         Set<String> includes = new LinkedHashSet<String>();
 727         String arch = fpdModuleId.getArch();
 728
 729         //
 730         // WORKSPACE
 731         //
 732         includes.add("${WORKSPACE_DIR}" + File.separatorChar);
 733
 734         //
 735         // Module iteself
 736         //
 737         includes.add("${MODULE_DIR}");
 738         includes.add("${MODULE_DIR}" + File.separatorChar + archDir(arch));
 739
 740         //
 741         // Packages in PackageDenpendencies
 742         //
 743         PackageIdentification[] packageDependencies = saq.getDependencePkg(fpdModuleId.getArch());
 744         for (int i = 0; i < packageDependencies.length; i++) {
 745             GlobalData.refreshPackageIdentification(packageDependencies[i]);
 746             File packageFile = packageDependencies[i].getSpdFile();
 747             includes.add(packageFile.getParent() + File.separatorChar + "Include");
 748             includes.add(packageFile.getParent() + File.separatorChar + "Include" + File.separatorChar + archDir(arch));
 749         }
 750
 751         //
 752         // All Dependency Library Instance's PackageDependencies
 753         //
 754         ModuleIdentification[] libinstances = saq.getLibraryInstance(fpdModuleId.getArch());
 755         for (int i = 0; i < libinstances.length; i++) {
 756             saq.push(GlobalData.getDoc(libinstances[i], fpdModuleId.getArch()));
 757             PackageIdentification[] libraryPackageDependencies = saq.getDependencePkg(fpdModuleId.getArch());
 758             for (int j = 0; j < libraryPackageDependencies.length; j++) {
 759                 GlobalData.refreshPackageIdentification(libraryPackageDependencies[j]);
 760                 File packageFile = libraryPackageDependencies[j].getSpdFile();
 761                 includes.add(packageFile.getParent() + File.separatorChar + "Include");
 762                 includes.add(packageFile.getParent() + File.separatorChar + "Include" + File.separatorChar + archDir(arch));
 763             }
 764             saq.pop();
 765         }
 766
 767
 768         //
 769         // The package which the module belongs to
 770         // TBD
 771         includes.add(fpdModuleId.getModule().getPackage().getPackageDir() + File.separatorChar + "Include");
 772         includes.add(fpdModuleId.getModule().getPackage().getPackageDir() + File.separatorChar + "Include" + File.separatorChar + archDir(arch));
 773
 774         //
 775         // Debug files output directory
 776         //
 777         includes.add("${DEST_DIR_DEBUG}");
 778
 779         //
 780         // set to INCLUDE_PATHS property
 781         //
 782         Iterator<String> iter = includes.iterator();
 783         StringBuffer includePaths = new StringBuffer();
 784         while (iter.hasNext()) {
 785             includePaths.append(iter.next());
 786             includePaths.append("; ");
 787         }
 788         getProject().setProperty("INCLUDE_PATHS", getProject().replaceProperties(includePaths.toString()).replaceAll("(\\\\)", "/"));
 789
 790         return includes.toArray(new String[includes.size()]);
 791     }
 792
 793     /**
 794      Return the name of the directory that corresponds to the architecture.
 795      This is a translation from the XML Schema tag to a directory that
 796      corresponds to our directory name coding convention.
 797
 798      **/
 799    private String archDir(String arch) {
 800        return arch.replaceFirst("X64", "x64")
 801                   .replaceFirst("IPF", "Ipf")
 802                   .replaceFirst("IA32", "Ia32")
 803                   .replaceFirst("ARM", "Arm")
 804                   .replaceFirst("EBC", "Ebc");
 805    }
 806
 807
 808    public void setExternalProperties(Vector<Property> v) {
 809        this.properties = v;
 810    }
 811 }