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