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         String archString = getProject().getProperty("ARCH");
 230         if (archString != null) {
 231             String[] fpdArchList = archString.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: " + "[" + archString + "] is not supported for " + moduleId + " in this build!\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         File msaFile = moduleId.getMsaFile();
 429         String msaFileName = msaFile.getName();
 430         getProject().setProperty("MODULE_DIR", msaFile.getParent().replaceAll("(\\\\)", "/"));
 431         getProject().setProperty("MODULE_RELATIVE_DIR", moduleId.getModuleRelativePath().replaceAll("(\\\\)", "/")
 432             + File.separatorChar + msaFileName.substring(0, msaFileName.lastIndexOf('.')));
 433
 434         //
 435         // SUBSYSTEM
 436         //
 437         String[][] subsystemMap = { { "BASE", "EFI_BOOT_SERVICE_DRIVER"},
 438                                     { "SEC", "EFI_BOOT_SERVICE_DRIVER" },
 439                                     { "PEI_CORE", "EFI_BOOT_SERVICE_DRIVER" },
 440                                     { "PEIM", "EFI_BOOT_SERVICE_DRIVER" },
 441                                     { "DXE_CORE", "EFI_BOOT_SERVICE_DRIVER" },
 442                                     { "DXE_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 443                                     { "DXE_RUNTIME_DRIVER", "EFI_RUNTIME_DRIVER" },
 444                                     { "DXE_SAL_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 445                                     { "DXE_SMM_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 446                                     { "TOOL", "EFI_BOOT_SERVICE_DRIVER" },
 447                                     { "UEFI_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 448                                     { "UEFI_APPLICATION", "EFI_APPLICATION" },
 449                                     { "USER_DEFINED", "EFI_BOOT_SERVICE_DRIVER"} };
 450
 451         String subsystem = "EFI_BOOT_SERVICE_DRIVER";
 452         for (int i = 0; i < subsystemMap.length; i++) {
 453             if (moduleId.getModuleType().equalsIgnoreCase(subsystemMap[i][0])) {
 454                 subsystem = subsystemMap[i][1];
 455                 break ;
 456             }
 457         }
 458         getProject().setProperty("SUBSYSTEM", subsystem);
 459
 460         //
 461         // ENTRYPOINT
 462         //
 463         if (arch.equalsIgnoreCase("EBC")) {
 464             getProject().setProperty("ENTRYPOINT", "EfiStart");
 465         } else {
 466             getProject().setProperty("ENTRYPOINT", "_ModuleEntryPoint");
 467         }
 468
 469         getProject().setProperty("OBJECTS", "");
 470     }
 471
 472     private void getCompilerFlags(String target, String toolchain, FpdModuleIdentification fpdModuleId) throws EdkException {
 473         String[] cmd = GlobalData.getToolChainInfo().getCommands();
 474         for ( int m = 0; m < cmd.length; m++) {
 475             //
 476             // Set cmd, like CC, DLINK
 477             //
 478             String[] key = new String[]{target, toolchain, fpdModuleId.getArch(), cmd[m], null};
 479             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_PATH;
 480             String cmdPath = GlobalData.getCommandSetting(key, fpdModuleId);
 481             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_NAME;
 482             String cmdName = GlobalData.getCommandSetting(key, fpdModuleId);
 483             if (cmdName.length() == 0) {
 484                 EdkLog.log(this, EdkLog.EDK_VERBOSE, "Warning: " + cmd[m] + " hasn't been defined!");
 485                 getProject().setProperty(cmd[m], "");
 486                 continue;
 487             }
 488             File cmdFile = new File(cmdPath + File.separatorChar + cmdName);
 489             getProject().setProperty(cmd[m], cmdFile.getPath().replaceAll("(\\\\)", "/"));
 490
 491             //
 492             // set CC_FLAGS
 493             //
 494             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_FLAGS;
 495             String cmdFlags = GlobalData.getCommandSetting(key, fpdModuleId);
 496             if (cmdFlags != null)
 497             {
 498               getProject().setProperty(cmd[m] + "_FLAGS", cmdFlags);
 499             }
 500             else
 501             {
 502               getProject().setProperty(cmd[m] + "_FLAGS", "");
 503             }
 504
 505             //
 506             // Set CC_EXT
 507             //
 508             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_EXT;
 509             String extName = GlobalData.getCommandSetting(key, fpdModuleId);
 510             if ( extName != null && ! extName.equalsIgnoreCase("")) {
 511                 getProject().setProperty(cmd[m] + "_EXT", extName);
 512             } else {
 513                 getProject().setProperty(cmd[m] + "_EXT", "");
 514             }
 515
 516             //
 517             // set CC_FAMILY
 518             //
 519             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_FAMILY;
 520             String toolChainFamily = GlobalData.getCommandSetting(key, fpdModuleId);
 521             if (toolChainFamily != null) {
 522                 getProject().setProperty(cmd[m] + "_FAMILY", toolChainFamily);
 523             }
 524
 525             //
 526             // set CC_SPATH
 527             //
 528             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_SPATH;
 529             String spath = GlobalData.getCommandSetting(key, fpdModuleId);
 530             if (spath != null) {
 531                 getProject().setProperty(cmd[m] + "_SPATH", spath.replaceAll("(\\\\)", "/"));
 532             } else {
 533                 getProject().setProperty(cmd[m] + "_SPATH", "");
 534             }
 535
 536             //
 537             // set CC_DPATH
 538             //
 539             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_DPATH;
 540             String dpath = GlobalData.getCommandSetting(key, fpdModuleId);
 541             if (dpath != null) {
 542                 getProject().setProperty(cmd[m] + "_DPATH", dpath.replaceAll("(\\\\)", "/"));
 543             } else {
 544                 getProject().setProperty(cmd[m] + "_DPATH", "");
 545             }
 546
 547             //
 548             // Set CC_LIBPATH
 549             //
 550             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_LIBPATH;
 551             String libpath = GlobalData.getCommandSetting(key, fpdModuleId);
 552             if (libpath != null) {
 553                 getProject().setProperty(cmd[m] + "_LIBPATH", libpath.replaceAll("(\\\\)", "/"));
 554             } else {
 555                 getProject().setProperty(cmd[m] + "_LIBPATH", "");
 556             }
 557
 558             //
 559             // Set CC_INCLUDEPATH
 560             //
 561             key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_INCLUDEPATH;
 562             String includepath = GlobalData.getCommandSetting(key, fpdModuleId);
 563             if (dpath != null) {
 564                 getProject().setProperty(cmd[m] + "_INCLUDEPATH", includepath.replaceAll("(\\\\)", "/"));
 565             } else {
 566                 getProject().setProperty(cmd[m] + "_INCLUDEPATH", "");
 567             }
 568         }
 569     }
 570
 571     public void setMsaFile(File msaFile) {
 572         this.msaFile = msaFile;
 573     }
 574
 575     /**
 576       Method is for ANT to initialize MSA file.
 577
 578       @param msaFilename MSA file name
 579     **/
 580     public void setMsaFile(String msaFilename) {
 581         String moduleDir = getProject().getProperty("MODULE_DIR");
 582
 583         //
 584         // If is Single Module Build, then use the Base Dir defined in build.xml
 585         //
 586         if (moduleDir == null) {
 587             moduleDir = getProject().getBaseDir().getPath();
 588         }
 589         msaFile = new File(moduleDir + File.separatorChar + msaFilename);
 590     }
 591
 592     public void addConfiguredModuleItem(ModuleItem moduleItem) {
 593         PackageIdentification packageId = new PackageIdentification(moduleItem.getPackageGuid(), moduleItem.getPackageVersion());
 594         ModuleIdentification moduleId = new ModuleIdentification(moduleItem.getModuleGuid(), moduleItem.getModuleVersion());
 595         moduleId.setPackage(packageId);
 596         this.moduleId = moduleId;
 597     }
 598
 599     /**
 600       Add a property.
 601
 602       @param p property
 603     **/
 604     public void addProperty(Property p) {
 605         properties.addElement(p);
 606     }
 607
 608     public void setType(String type) {
 609         this.type = type;
 610     }
 611
 612     private void applyBuild(String buildTarget, String buildTagname, FpdModuleIdentification fpdModuleId) throws EdkException {
 613         //
 614         // Call AutoGen to generate AutoGen.c and AutoGen.h
 615         //
 616         AutoGen autogen = new AutoGen(getProject().getProperty("FV_DIR"), getProject().getProperty("DEST_DIR_DEBUG"), fpdModuleId.getModule(),fpdModuleId.getArch(), saq, parentId);
 617         autogen.genAutogen();
 618
 619         //
 620         // Get compiler flags
 621         //
 622         try {
 623             getCompilerFlags(buildTarget, buildTagname, fpdModuleId);
 624         }
 625         catch (EdkException ee) {
 626             throw new BuildException(ee.getMessage());
 627         }
 628
 629         //
 630         // Prepare LIBS
 631         //
 632         ModuleIdentification[] libinstances = saq.getLibraryInstance(fpdModuleId.getArch());
 633         String propertyLibs = "";
 634         for (int i = 0; i < libinstances.length; i++) {
 635             propertyLibs += getProject().getProperty("BIN_DIR") + File.separatorChar + libinstances[i].getName() + ".lib" + " ";
 636         }
 637         getProject().setProperty("LIBS", propertyLibs.replaceAll("(\\\\)", "/"));
 638
 639         //
 640         // Get all includepath and set to INCLUDE_PATHS
 641         //
 642         String[] includes = prepareIncludePaths(fpdModuleId);
 643
 644         //
 645         // if it is CUSTOM_BUILD
 646         // then call the exist BaseName_build.xml directly.
 647         //
 648         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 649             EdkLog.log(this, "Call user-defined " + moduleId.getName() + "_build.xml");
 650
 651             String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
 652             antCall(antFilename, null);
 653
 654             return ;
 655         }
 656
 657         //
 658         // Generate ${BASE_NAME}_build.xml
 659         // TBD
 660         //
 661         String ffsKeyword = saq.getModuleFfsKeyword();
 662         ModuleBuildFileGenerator fileGenerator = new ModuleBuildFileGenerator(getProject(), ffsKeyword, fpdModuleId, includes, saq);
 663         String buildFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 664         fileGenerator.genBuildFile(buildFilename);
 665
 666         //
 667         // Ant call ${BASE_NAME}_build.xml
 668         //
 669         String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 670         antCall(antFilename, null);
 671     }
 672
 673     private void applyClean(FpdModuleIdentification fpdModuleId){
 674         //
 675         // if it is CUSTOM_BUILD
 676         // then call the exist BaseName_build.xml directly.
 677         //
 678         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 679             EdkLog.log(this, "Calling user-defined " + moduleId.getName() + "_build.xml");
 680
 681             String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
 682             antCall(antFilename, "clean");
 683
 684             return ;
 685         }
 686
 687         String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 688         antCall(antFilename, "clean");
 689     }
 690
 691     private void applyCleanall(FpdModuleIdentification fpdModuleId){
 692         //
 693         // if it is CUSTOM_BUILD
 694         // then call the exist BaseName_build.xml directly.
 695         //
 696         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 697             EdkLog.log(this, "Calling user-defined " + moduleId.getName() + "_build.xml");
 698
 699             String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
 700             antCall(antFilename, "cleanall");
 701
 702             return ;
 703         }
 704
 705         String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 706         antCall(antFilename, "cleanall");
 707     }
 708
 709     private void antCall(String antFilename, String target) {
 710         Ant ant = new Ant();
 711         ant.setProject(getProject());
 712         ant.setAntfile(antFilename);
 713         if (target != null) {
 714             ant.setTarget(target);
 715         }
 716         ant.setInheritAll(true);
 717         ant.init();
 718         ant.execute();
 719     }
 720
 721     public void setSingleModuleBuild(boolean isSingleModuleBuild) {
 722         this.isSingleModuleBuild = isSingleModuleBuild;
 723     }
 724
 725     private String[] prepareIncludePaths(FpdModuleIdentification fpdModuleId) throws EdkException{
 726         //
 727         // Prepare the includes: PackageDependencies and Output debug direactory
 728         //
 729         Set<String> includes = new LinkedHashSet<String>();
 730         String arch = fpdModuleId.getArch();
 731
 732         //
 733         // WORKSPACE
 734         //
 735         includes.add("${WORKSPACE_DIR}" + File.separatorChar);
 736
 737         //
 738         // Module iteself
 739         //
 740         includes.add("${MODULE_DIR}");
 741         includes.add("${MODULE_DIR}" + File.separatorChar + archDir(arch));
 742
 743         //
 744         // Packages in PackageDenpendencies
 745         //
 746         PackageIdentification[] packageDependencies = saq.getDependencePkg(fpdModuleId.getArch());
 747         for (int i = 0; i < packageDependencies.length; i++) {
 748             GlobalData.refreshPackageIdentification(packageDependencies[i]);
 749             File packageFile = packageDependencies[i].getSpdFile();
 750             includes.add(packageFile.getParent() + File.separatorChar + "Include");
 751             includes.add(packageFile.getParent() + File.separatorChar + "Include" + File.separatorChar + archDir(arch));
 752         }
 753
 754         //
 755         // All Dependency Library Instance's PackageDependencies
 756         //
 757         ModuleIdentification[] libinstances = saq.getLibraryInstance(fpdModuleId.getArch());
 758         for (int i = 0; i < libinstances.length; i++) {
 759             saq.push(GlobalData.getDoc(libinstances[i], fpdModuleId.getArch()));
 760             PackageIdentification[] libraryPackageDependencies = saq.getDependencePkg(fpdModuleId.getArch());
 761             for (int j = 0; j < libraryPackageDependencies.length; j++) {
 762                 GlobalData.refreshPackageIdentification(libraryPackageDependencies[j]);
 763                 File packageFile = libraryPackageDependencies[j].getSpdFile();
 764                 includes.add(packageFile.getParent() + File.separatorChar + "Include");
 765                 includes.add(packageFile.getParent() + File.separatorChar + "Include" + File.separatorChar + archDir(arch));
 766             }
 767             saq.pop();
 768         }
 769
 770
 771         //
 772         // The package which the module belongs to
 773         // TBD
 774         includes.add(fpdModuleId.getModule().getPackage().getPackageDir() + File.separatorChar + "Include");
 775         includes.add(fpdModuleId.getModule().getPackage().getPackageDir() + File.separatorChar + "Include" + File.separatorChar + archDir(arch));
 776
 777         //
 778         // Debug files output directory
 779         //
 780         includes.add("${DEST_DIR_DEBUG}");
 781
 782         //
 783         // set to INCLUDE_PATHS property
 784         //
 785         Iterator<String> iter = includes.iterator();
 786         StringBuffer includePaths = new StringBuffer();
 787         while (iter.hasNext()) {
 788             includePaths.append(iter.next());
 789             includePaths.append("; ");
 790         }
 791         getProject().setProperty("INCLUDE_PATHS", getProject().replaceProperties(includePaths.toString()).replaceAll("(\\\\)", "/"));
 792
 793         return includes.toArray(new String[includes.size()]);
 794     }
 795
 796     /**
 797      Return the name of the directory that corresponds to the architecture.
 798      This is a translation from the XML Schema tag to a directory that
 799      corresponds to our directory name coding convention.
 800
 801      **/
 802    private String archDir(String arch) {
 803        return arch.replaceFirst("X64", "x64")
 804                   .replaceFirst("IPF", "Ipf")
 805                   .replaceFirst("IA32", "Ia32")
 806                   .replaceFirst("ARM", "Arm")
 807                   .replaceFirst("EBC", "Ebc");
 808    }
 809
 810
 811    public void setExternalProperties(Vector<Property> v) {
 812        this.properties = v;
 813    }
 814 }