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