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.ArrayList;
  20 import java.util.Hashtable;
  21 import java.util.Iterator;
  22 import java.util.LinkedHashSet;
  23 import java.util.List;
  24 import java.util.Map;
  25 import java.util.Set;
  26 import java.util.Stack;
  27 import java.util.Vector;
  28 import java.util.regex.Matcher;
  29 import java.util.regex.Pattern;
  30
  31 import org.apache.tools.ant.BuildException;
  32 import org.apache.tools.ant.taskdefs.Ant;
  33 import org.apache.tools.ant.taskdefs.Property;
  34 import org.apache.xmlbeans.XmlObject;
  35
  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.SurfaceAreaQuery;
  42 import org.tianocore.build.id.FpdModuleIdentification;
  43 import org.tianocore.build.id.ModuleIdentification;
  44 import org.tianocore.build.id.PackageIdentification;
  45 import org.tianocore.build.id.PlatformIdentification;
  46 import org.tianocore.build.tools.ModuleItem;
  47 import org.tianocore.exception.EdkException;
  48 import org.tianocore.logger.EdkLog;
  49
  50 /**
  51   <p>
  52   <code>GenBuildTask</code> is an ANT task that can be used in ANT build
  53   system. The main function of this task is to parse module's surface area,
  54   then generate the corresponding <em>BaseName_build.xml</em> (the real ANT
  55   build script) and call this to build the module. The whole process including:
  56   1. generate AutoGen.c and AutoGen.h; 2. build all dependent library instances;
  57   3. build all source files inlcude AutoGen.c; 4. generate sections;
  58   5. generate FFS file if it is driver module while LIB file if it is Library module.
  59   </p>
  60
  61   <p>
  62   The usage is (take module <em>HelloWorld</em> for example):
  63   </p>
  64
  65   <pre>
  66    &lt;GenBuild
  67              msaFilename=&quot;HelloWorld.msa&quot;/&gt;
  68              processTo=&quot;ALL&quot;/&gt;
  69   </pre>
  70
  71   <p><code>processTo</code> provides a way to customize the whole build process.
  72   processTo can be one value of ALL, AUTOGEN, FILES, LIBRARYINSTANCES, SECTIONS, NONE.
  73   Default is ALL, means whole
  74   </p>
  75
  76   <p>
  77   This task calls <code>AutoGen</code> to generate <em>AutoGen.c</em> and
  78   <em>AutoGen.h</em>. The task also parses the development environment
  79   configuration files, such as collecting package information, setting compiler
  80   flags and so on.
  81   </p>
  82
  83
  84   @since GenBuild 1.0
  85 **/
  86 public class GenBuildTask extends Ant {
  87
  88     ///
  89     /// Module surface area file.
  90     ///
  91     File msaFile;
  92
  93     ///
  94     ///
  95     ///
  96     private String type = "all"; // = "build";
  97
  98     ///
  99     /// Module's Identification.
 100     ///
 101     private ModuleIdentification moduleId;
 102
 103     private Vector<Property> properties = new Vector<Property>();
 104
 105     private static Stack<Hashtable> backupPropertiesStack = new Stack<Hashtable>();
 106
 107     private boolean isSingleModuleBuild = false;
 108
 109     /**
 110       Public construct method. It is necessary for ANT task.
 111     **/
 112     public GenBuildTask() {
 113     }
 114
 115     /**
 116
 117       @throws BuildException
 118               From module build, exception from module surface area invalid.
 119     **/
 120     public void execute() throws BuildException {
 121         //
 122         // set Logger
 123         //
 124         GenBuildLogger logger = new GenBuildLogger(getProject());
 125         EdkLog.setLogLevel(getProject().getProperty("env.LOGLEVEL"));
 126         EdkLog.setLogger(logger);
 127         // remove !!
 128         try {
 129         pushProperties();
 130         //
 131         // Enable all specified properties
 132         //
 133         Iterator<Property> iter = properties.iterator();
 134         while (iter.hasNext()) {
 135             Property item = iter.next();
 136             getProject().setProperty(item.getName(), item.getValue());
 137         }
 138
 139         //
 140         // GenBuild should specify either msaFile or moduleGuid & packageGuid
 141         //
 142         if (msaFile == null ) {
 143             String moduleGuid = getProject().getProperty("MODULE_GUID");
 144             String moduleVersion = getProject().getProperty("MODULE_VERSION");
 145             String packageGuid = getProject().getProperty("PACKAGE_GUID");
 146             String packageVersion = getProject().getProperty("PACKAGE_VERSION");
 147             if (moduleGuid == null || packageGuid == null) {
 148                 throw new BuildException("GenBuild parameters error. ");
 149             }
 150             PackageIdentification packageId = new PackageIdentification(packageGuid, packageVersion);
 151             moduleId = new ModuleIdentification(moduleGuid, moduleVersion);
 152             moduleId.setPackage(packageId);
 153             Map<String, XmlObject> doc = GlobalData.getNativeMsa(moduleId);
 154             SurfaceAreaQuery.setDoc(doc);
 155             moduleId = SurfaceAreaQuery.getMsaHeader();
 156         }
 157         else {
 158             Map<String, XmlObject> doc = GlobalData.getNativeMsa(msaFile);
 159             SurfaceAreaQuery.setDoc(doc);
 160             moduleId = SurfaceAreaQuery.getMsaHeader();
 161         }
 162         String[] producedLibraryClasses = SurfaceAreaQuery.getLibraryClasses("ALWAYS_PRODUCED",null);
 163         if (producedLibraryClasses.length == 0) {
 164             moduleId.setLibrary(false);
 165         }
 166         else {
 167             moduleId.setLibrary(true);
 168         }
 169
 170         //
 171         // Judge whether it is single module build or not
 172         //
 173         if (isSingleModuleBuild) {
 174             //
 175             // Single Module build
 176             //
 177             prepareSingleModuleBuild();
 178         }
 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             getProject().setProperty("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
 186             getProject().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 : intersection MSA supported ARCHs and tools def!!
 196         // else, get arch from pass down
 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         }
 216         else {
 217             archSet = archListSupByToolChain;
 218         }
 219
 220         String[] archList = archSet.toArray(new String[archSet.size()]);
 221
 222         //
 223         // Judge if arch is all supported by current module. If not, throw Exception.
 224         //
 225         List moduleSupportedArchs = SurfaceAreaQuery.getModuleSupportedArchs();
 226         if (moduleSupportedArchs != null) {
 227             for (int k = 0; k < archList.length; k++) {
 228                 if ( ! moduleSupportedArchs.contains(archList[k])) {
 229                     throw new BuildException("ARCH [" + archList[k] + "] is not supported by " + moduleId + ". " + moduleId + " only supports [" + moduleSupportedArchs + "].");
 230                 }
 231             }
 232         }
 233
 234         for (int k = 0; k < archList.length; k++) {
 235
 236             getProject().setProperty("ARCH", archList[k]);
 237
 238             FpdModuleIdentification fpdModuleId = new FpdModuleIdentification(moduleId, archList[k]);
 239
 240             //
 241             // Whether the module is built before
 242             //
 243             if ((moduleId.isLibrary() == false && GlobalData.hasFpdModuleSA(fpdModuleId) == false)
 244                 || GlobalData.isModuleBuilt(fpdModuleId)) {
 245                 return;
 246             }
 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     /**
 722       Generate the flags string with original format. The format is defined by
 723       Java Regulation Expression "[^\\\\]?(\".*?[^\\\\]\")[ \t,]+". </p>
 724
 725       <p>For example: </p>
 726
 727       <pre>
 728         "/nologo", "/W3", "/WX"
 729         "/C", "/DSTRING_DEFINES_FILE=\"BdsStrDefs.h\""
 730       </pre>
 731
 732       @param add the add flags set
 733       @param sub the sub flags set
 734       @return flags with original format
 735     **/
 736     private String getRawFlags(Set<String> add, Set<String> sub) {
 737         String result = null;
 738         add.removeAll(sub);
 739         Iterator iter = add.iterator();
 740         while (iter.hasNext()) {
 741             String str = (String) iter.next();
 742             result += "\"" + str.substring(1, str.length() - 1) + "\", ";
 743         }
 744         return result;
 745     }
 746
 747     private String parseOptionString(String optionString, Set<String> addSet, Set<String> subSet) {
 748         boolean overrideOption = false;
 749         Pattern pattern = Pattern.compile("ADD\\.\\[(.+)\\]");
 750         Matcher matcher = pattern.matcher(optionString);
 751
 752         while (matcher.find()) {
 753             overrideOption = true;
 754             String addOption = optionString.substring(matcher.start(1), matcher.end(1)).trim();
 755             putFlagsToSet(addSet, addOption);
 756
 757         }
 758
 759         pattern = Pattern.compile("SUB\\.\\[(.+)\\]");
 760         matcher = pattern.matcher(optionString);
 761
 762         while (matcher.find()) {
 763             overrideOption = true;
 764             String subOption = optionString.substring(matcher.start(1), matcher.end(1)).trim();
 765             putFlagsToSet(subSet, subOption);
 766         }
 767
 768         if (overrideOption == true) {
 769             return null;
 770         }
 771
 772         return optionString;
 773     }
 774
 775     private void pushProperties() {
 776         backupPropertiesStack.push(getProject().getProperties());
 777     }
 778
 779     private void popProperties() {
 780         Hashtable backupProperties = backupPropertiesStack.pop();
 781         Set keys = backupProperties.keySet();
 782         Iterator iter = keys.iterator();
 783         while (iter.hasNext()) {
 784             String item = (String)iter.next();
 785             getProject().setProperty(item, (String)backupProperties.get(item));
 786         }
 787     }
 788
 789     public void setSingleModuleBuild(boolean isSingleModuleBuild) {
 790         this.isSingleModuleBuild = isSingleModuleBuild;
 791     }
 792 }