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");
 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         String[] archList = new String[0];
 198         if ( getProject().getProperty("ARCH") != null ) {
 199             archList = getProject().getProperty("ARCH").split(" ");
 200         }
 201         else {
 202             archList = GlobalData.getToolChainInfo().getArchs();
 203         }
 204
 205
 206         //
 207         // Judge if arch is all supported by current module. If not, throw Exception.
 208         //
 209         List moduleSupportedArchs = SurfaceAreaQuery.getModuleSupportedArchs();
 210         if (moduleSupportedArchs != null) {
 211             for (int k = 0; k < archList.length; k++) {
 212                 if ( ! moduleSupportedArchs.contains(archList[k])) {
 213                     throw new BuildException("ARCH [" + archList[k] + "] is not supported by " + moduleId + ". " + moduleId + " only supports [" + moduleSupportedArchs + "].");
 214                 }
 215             }
 216         }
 217
 218         for (int k = 0; k < archList.length; k++) {
 219             getProject().setProperty("ARCH", archList[k]);
 220
 221             FpdModuleIdentification fpdModuleId = new FpdModuleIdentification(moduleId, archList[k]);
 222
 223             //
 224             // Whether the module is built before
 225             //
 226             if (GlobalData.isModuleBuilt(fpdModuleId)) {
 227                 return ;
 228             }
 229             else {
 230                 GlobalData.registerBuiltModule(fpdModuleId);
 231             }
 232
 233             //
 234             // For Every TOOLCHAIN, TARGET
 235             //
 236             String[] targetList =  GlobalData.getToolChainInfo().getTargets();
 237             for (int i = 0; i < targetList.length; i ++){
 238                 //
 239                 // Prepare for target related common properties
 240                 // TARGET
 241                 //
 242                 getProject().setProperty("TARGET", targetList[i]);
 243                 String[] toolchainList = GlobalData.getToolChainInfo().getTagnames();
 244                 for(int j = 0; j < toolchainList.length; j ++){
 245                     //
 246                     // check if any tool is defined for current target + toolchain + arch
 247                     // don't do anything if no tools found
 248                     //
 249                     if (GlobalData.isCommandSet(targetList[i], toolchainList[j], archList[k]) == false) {
 250                         System.out.println("!!!Warning: No build issued. No tools found for [target=" + targetList[i] + " toolchain=" + toolchainList[j] + " arch=" + archList[k] + "]\n");
 251                         continue;
 252                     }
 253
 254                     //
 255                     // Prepare for toolchain related common properties
 256                     // TOOLCHAIN
 257                     //
 258                     getProject().setProperty("TOOLCHAIN", toolchainList[j]);
 259
 260                     System.out.println("Build " + moduleId + " start >>>");
 261                     System.out.println("Target: " + targetList[i] + " Tagname: " + toolchainList[j] + " Arch: " + archList[k]);
 262                     SurfaceAreaQuery.setDoc(GlobalData.getDoc(fpdModuleId));
 263
 264                     //
 265                     // Prepare for all other common properties
 266                     // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
 267                     // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
 268                     // MODULE_DIR, MODULE_RELATIVE_DIR
 269                     // SUBSYSTEM, ENTRYPOINT, EBC_TOOL_LIB_PATH
 270                     // LIBS, OBJECTS, SDB_FILES
 271                     //
 272                     setModuleCommonProperties(archList[k]);
 273
 274                     //
 275                     // OutputManage prepare for
 276                     // BIN_DIR, DEST_DIR_DEBUG, DEST_DIR_OUTPUT, BUILD_DIR, FV_DIR
 277                     //
 278                     OutputManager.getInstance().update(getProject());
 279
 280                     if (type.equalsIgnoreCase("all") || type.equalsIgnoreCase("build")) {
 281                         applyBuild(targetList[i], toolchainList[j], fpdModuleId);
 282                     }
 283                     else if (type.equalsIgnoreCase("clean")) {
 284                         applyClean(fpdModuleId);
 285                     }
 286                     else if (type.equalsIgnoreCase("cleanall")) {
 287                         applyCleanall(fpdModuleId);
 288                     }
 289                 }
 290             }
 291         }
 292         popProperties();
 293         }catch (Exception e){
 294             e.printStackTrace();
 295             throw new BuildException(e.getMessage());
 296         }
 297     }
 298
 299     /**
 300       This method is used to prepare Platform-related information.
 301
 302       <p>In Single Module Build mode, platform-related information is not ready.
 303       The method read the system environment variable <code>ACTIVE_PLATFORM</code>
 304       and search in the Framework Database. Note that platform name in the Framework
 305       Database must be unique. </p>
 306
 307     **/
 308     private void prepareSingleModuleBuild(){
 309         //
 310         // Find out the package which the module belongs to
 311         // TBD: Enhance it!!!!
 312         //
 313         PackageIdentification packageId = GlobalData.getPackageForModule(moduleId);
 314
 315         moduleId.setPackage(packageId);
 316
 317         //
 318         // Read ACTIVE_PLATFORM's FPD file (Call FpdParserTask's method)
 319         //
 320         String filename = getProject().getProperty("PLATFORM_FILE");
 321
 322         if (filename == null){
 323             throw new BuildException("Plese set ACTIVE_PLATFORM if you want to build a single module. ");
 324         }
 325
 326         PlatformIdentification platformId = GlobalData.getPlatform(filename);
 327
 328         //
 329         // Read FPD file
 330         //
 331         FpdParserTask fpdParser = new FpdParserTask();
 332         fpdParser.setProject(getProject());
 333         fpdParser.parseFpdFile(platformId.getFpdFile());
 334
 335         //
 336         // Prepare for Platform related common properties
 337         // PLATFORM, PLATFORM_DIR, PLATFORM_RELATIVE_DIR
 338         //
 339         getProject().setProperty("PLATFORM", platformId.getName());
 340         getProject().setProperty("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
 341         getProject().setProperty("PLATFORM_RELATIVE_DIR", platformId.getPlatformRelativeDir().replaceAll("(\\\\)", "/"));
 342     }
 343
 344
 345     /**
 346       Set Module-Related information to properties.
 347     **/
 348     private void setModuleCommonProperties(String arch) {
 349         //
 350         // Prepare for all other common properties
 351         // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
 352         //
 353         PackageIdentification packageId = moduleId.getPackage();
 354         getProject().setProperty("PACKAGE", packageId.getName());
 355         getProject().setProperty("PACKAGE_GUID", packageId.getGuid());
 356         getProject().setProperty("PACKAGE_VERSION", packageId.getVersion());
 357         getProject().setProperty("PACKAGE_DIR", packageId.getPackageDir().replaceAll("(\\\\)", "/"));
 358         getProject().setProperty("PACKAGE_RELATIVE_DIR", packageId.getPackageRelativeDir().replaceAll("(\\\\)", "/"));
 359
 360         //
 361         // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
 362         // MODULE_DIR, MODULE_RELATIVE_DIR
 363         //
 364         getProject().setProperty("MODULE", moduleId.getName());
 365         String baseName = SurfaceAreaQuery.getModuleOutputFileBasename();
 366         if (baseName == null) {
 367             getProject().setProperty("BASE_NAME", moduleId.getName());
 368         }
 369         else {
 370             getProject().setProperty("BASE_NAME", baseName);
 371         }
 372         getProject().setProperty("GUID", moduleId.getGuid());
 373         getProject().setProperty("FILE_GUID", moduleId.getGuid());
 374         getProject().setProperty("VERSION", moduleId.getVersion());
 375         getProject().setProperty("MODULE_TYPE", moduleId.getModuleType());
 376         getProject().setProperty("MODULE_DIR", moduleId.getMsaFile().getParent().replaceAll("(\\\\)", "/"));
 377         getProject().setProperty("MODULE_RELATIVE_DIR", moduleId.getModuleRelativePath().replaceAll("(\\\\)", "/"));
 378
 379         //
 380         // SUBSYSTEM
 381         //
 382         String[][] subsystemMap = { { "BASE", "EFI_BOOT_SERVICE_DRIVER"},
 383                                     { "SEC", "EFI_BOOT_SERVICE_DRIVER" },
 384                                     { "PEI_CORE", "EFI_BOOT_SERVICE_DRIVER" },
 385                                     { "PEIM", "EFI_BOOT_SERVICE_DRIVER" },
 386                                     { "DXE_CORE", "EFI_BOOT_SERVICE_DRIVER" },
 387                                     { "DXE_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 388                                     { "DXE_RUNTIME_DRIVER", "EFI_RUNTIME_DRIVER" },
 389                                     { "DXE_SAL_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 390                                     { "DXE_SMM_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 391                                     { "TOOL", "EFI_BOOT_SERVICE_DRIVER" },
 392                                     { "UEFI_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
 393                                     { "UEFI_APPLICATION", "EFI_APPLICATION" },
 394                                     { "USER_DEFINED", "EFI_BOOT_SERVICE_DRIVER"} };
 395
 396         String subsystem = "EFI_BOOT_SERVICE_DRIVER";
 397         for (int i = 0; i < subsystemMap.length; i++) {
 398             if (moduleId.getModuleType().equalsIgnoreCase(subsystemMap[i][0])) {
 399                 subsystem = subsystemMap[i][1];
 400                 break ;
 401             }
 402         }
 403         getProject().setProperty("SUBSYSTEM", subsystem);
 404
 405         //
 406         // ENTRYPOINT
 407         //
 408         if (arch.equalsIgnoreCase("EBC")) {
 409             getProject().setProperty("ENTRYPOINT", "EfiStart");
 410         }
 411         else {
 412             getProject().setProperty("ENTRYPOINT", "_ModuleEntryPoint");
 413         }
 414
 415         //
 416         // LIBS, OBJECTS, SDB_FILES
 417         //
 418         getProject().setProperty("OBJECTS", "");
 419         getProject().setProperty("SDB_FILES", "");
 420         getProject().setProperty("LIBS", "");
 421     }
 422
 423     private void getCompilerFlags(String target, String toolchain, FpdModuleIdentification fpdModuleId) throws EdkException {
 424         String[] cmd = GlobalData.getToolChainInfo().getCommands();
 425         for ( int m = 0; m < cmd.length; m++) {
 426             //
 427             // Set cmd, like CC, DLINK
 428             //
 429             String[] key = new String[]{target, toolchain, fpdModuleId.getArch(), cmd[m], null};
 430             key[4] = "PATH";
 431             String cmdPath = GlobalData.getCommandSetting(key, fpdModuleId);
 432             key[4] = "NAME";
 433             String cmdName = GlobalData.getCommandSetting(key, fpdModuleId);
 434             File cmdFile = new File(cmdPath + File.separatorChar + cmdName);
 435 //            GlobalData.log.info("PATH: " + cmdFile.getPath());
 436             getProject().setProperty(cmd[m], cmdFile.getPath().replaceAll("(\\\\)", "/"));
 437
 438             //
 439             // set CC_FLAGS
 440             //
 441             key[4] = "FLAGS";
 442             String cmdFlags = GlobalData.getCommandSetting(key, fpdModuleId);
 443 //            GlobalData.log.info("Flags: " + cmdFlags);
 444             Set<String> addset = new LinkedHashSet<String>();
 445             Set<String> subset = new LinkedHashSet<String>();
 446             putFlagsToSet(addset, cmdFlags);
 447             getProject().setProperty(cmd[m] + "_FLAGS", getProject().replaceProperties(getFlags(addset, subset)));
 448
 449             //
 450             // Set CC_EXT
 451             //
 452             key[4] = "EXT";
 453             String extName = GlobalData.getCommandSetting(key, fpdModuleId);
 454 //            GlobalData.log.info("Ext: " + extName);
 455             if ( extName != null && ! extName.equalsIgnoreCase("")) {
 456                 getProject().setProperty(cmd[m] + "_EXT", extName);
 457             }
 458             else {
 459                 getProject().setProperty(cmd[m] + "_EXT", "");
 460             }
 461
 462             //
 463             // set CC_FAMILY
 464             //
 465             key[4] = "FAMILY";
 466             String toolChainFamily = GlobalData.getCommandSetting(key, fpdModuleId);
 467 //            GlobalData.log.info("FAMILY: " + toolChainFamily);
 468             if (toolChainFamily != null) {
 469                 getProject().setProperty(cmd[m] + "_FAMILY", toolChainFamily);
 470             }
 471
 472             //
 473             // set CC_SPATH
 474             //
 475             key[4] = "SPATH";
 476             String spath = GlobalData.getCommandSetting(key, fpdModuleId);
 477 //            GlobalData.log.info("SPATH: " + spath);
 478             if (spath != null) {
 479                 getProject().setProperty(cmd[m] + "_SPATH", spath.replaceAll("(\\\\)", "/"));
 480             }
 481             else {
 482                 getProject().setProperty(cmd[m] + "_SPATH", "");
 483             }
 484
 485             //
 486             // set CC_DPATH
 487             //
 488             key[4] = "DPATH";
 489             String dpath = GlobalData.getCommandSetting(key, fpdModuleId);
 490 //            GlobalData.log.info("DPATH: " + dpath);
 491             if (dpath != null) {
 492                 getProject().setProperty(cmd[m] + "_DPATH", dpath.replaceAll("(\\\\)", "/"));
 493             }
 494             else {
 495                 getProject().setProperty(cmd[m] + "_DPATH", "");
 496             }
 497         }
 498     }
 499
 500     public void setMsaFile(File msaFile) {
 501         this.msaFile = msaFile;
 502     }
 503
 504     /**
 505       Method is for ANT to initialize MSA file.
 506
 507       @param msaFilename MSA file name
 508     **/
 509     public void setMsaFile(String msaFilename) {
 510         String moduleDir = getProject().getProperty("MODULE_DIR");
 511
 512         //
 513         // If is Single Module Build, then use the Base Dir defined in build.xml
 514         //
 515         if (moduleDir == null) {
 516             moduleDir = getProject().getBaseDir().getPath();
 517         }
 518         msaFile = new File(moduleDir + File.separatorChar + msaFilename);
 519     }
 520
 521     public void addConfiguredModuleItem(ModuleItem moduleItem) {
 522         PackageIdentification packageId = new PackageIdentification(moduleItem.getPackageGuid(), moduleItem.getPackageVersion());
 523         ModuleIdentification moduleId = new ModuleIdentification(moduleItem.getModuleGuid(), moduleItem.getModuleVersion());
 524         moduleId.setPackage(packageId);
 525         this.moduleId = moduleId;
 526     }
 527
 528     /**
 529       Add a property.
 530
 531       @param p property
 532     **/
 533     public void addProperty(Property p) {
 534         properties.addElement(p);
 535     }
 536
 537     public void setType(String type) {
 538         this.type = type;
 539     }
 540
 541     private void applyBuild(String buildTarget, String buildTagname, FpdModuleIdentification fpdModuleId) throws EdkException{
 542         //
 543         // AutoGen
 544         //
 545
 546         AutoGen autogen = new AutoGen(getProject().getProperty("DEST_DIR_DEBUG"), fpdModuleId.getModule(),fpdModuleId.getArch());
 547         autogen.genAutogen();
 548
 549
 550         //
 551         // Get compiler flags
 552         //
 553         getCompilerFlags(buildTarget, buildTagname, fpdModuleId);
 554
 555         //
 556         // Prepare LIBS
 557         //
 558         ModuleIdentification[] libinstances = SurfaceAreaQuery.getLibraryInstance(fpdModuleId.getArch());
 559         String propertyLibs = "";
 560         for (int i = 0; i < libinstances.length; i++) {
 561             propertyLibs += " " + getProject().getProperty("BIN_DIR") + File.separatorChar + libinstances[i].getName() + ".lib";
 562         }
 563         getProject().setProperty("LIBS", propertyLibs.replaceAll("(\\\\)", "/"));
 564
 565         //
 566         // if it is CUSTOM_BUILD
 567         // then call the exist BaseName_build.xml directly.
 568         //
 569         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 570             GlobalData.log.info("Call user-defined " + moduleId.getName() + "_build.xml");
 571             Ant ant = new Ant();
 572             ant.setProject(getProject());
 573             ant.setAntfile(getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml");
 574             ant.setInheritAll(true);
 575             ant.init();
 576             ant.execute();
 577             return ;
 578         }
 579
 580         //
 581         // Generate ${BASE_NAME}_build.xml
 582         // TBD
 583         //
 584         String ffsKeyword = SurfaceAreaQuery.getModuleFfsKeyword();
 585         ModuleBuildFileGenerator fileGenerator = new ModuleBuildFileGenerator(getProject(), ffsKeyword, fpdModuleId);
 586         String buildFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
 587         fileGenerator.genBuildFile(buildFilename);
 588
 589         //
 590         // Ant call ${BASE_NAME}_build.xml
 591         //
 592         Ant ant = new Ant();
 593         ant.setProject(getProject());
 594         ant.setAntfile(getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml");
 595         ant.setInheritAll(true);
 596         ant.init();
 597         ant.execute();
 598     }
 599
 600     private void applyClean(FpdModuleIdentification fpdModuleId){
 601         //
 602         // if it is CUSTOM_BUILD
 603         // then call the exist BaseName_build.xml directly.
 604         //
 605         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 606             GlobalData.log.info("Call user-defined " + moduleId.getName() + "_build.xml");
 607             Ant ant = new Ant();
 608             ant.setProject(getProject());
 609             ant.setAntfile(getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml");
 610             ant.setTarget("clean");
 611             ant.setInheritAll(true);
 612             ant.init();
 613             ant.execute();
 614             return ;
 615         }
 616
 617         Ant ant = new Ant();
 618         ant.setProject(getProject());
 619         ant.setAntfile(getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml");
 620         ant.setTarget("clean");
 621         ant.setInheritAll(true);
 622         ant.init();
 623         ant.execute();
 624
 625         //
 626         // Delete current module's DEST_DIR_OUTPUT
 627         // TBD
 628     }
 629
 630     private void applyCleanall(FpdModuleIdentification fpdModuleId){
 631         //
 632         // if it is CUSTOM_BUILD
 633         // then call the exist BaseName_build.xml directly.
 634         //
 635         if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
 636             GlobalData.log.info("Call user-defined " + moduleId.getName() + "_build.xml");
 637             Ant ant = new Ant();
 638             ant.setProject(getProject());
 639             ant.setAntfile(getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml");
 640             ant.setTarget("cleanall");
 641             ant.setInheritAll(true);
 642             ant.init();
 643             ant.execute();
 644             return ;
 645         }
 646
 647         Ant ant = new Ant();
 648         ant.setProject(getProject());
 649         ant.setAntfile(getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml");
 650         ant.setTarget("cleanall");
 651         ant.setInheritAll(true);
 652         ant.init();
 653         ant.execute();
 654
 655         //
 656         // Delete current module's DEST_DIR_OUTPUT
 657         // TBD
 658     }
 659
 660
 661
 662
 663     /**
 664       Separate the string and instore in set.
 665
 666       <p> String is separated by Java Regulation Expression
 667       "[^\\\\]?(\".*?[^\\\\]\")[ \t,]+". </p>
 668
 669       <p>For example: </p>
 670
 671       <pre>
 672         "/nologo", "/W3", "/WX"
 673         "/C", "/DSTRING_DEFINES_FILE=\"BdsStrDefs.h\""
 674       </pre>
 675
 676       @param set store the separated string
 677       @param str string to separate
 678     **/
 679     private void putFlagsToSet(Set<String> set, String str) {
 680         if (str == null || str.length() == 0) {
 681             return;
 682         }
 683
 684         Pattern myPattern = Pattern.compile("[^\\\\]?(\".*?[^\\\\]\")[ \t,]+");
 685         Matcher matcher = myPattern.matcher(str + " ");
 686         while (matcher.find()) {
 687             String item = str.substring(matcher.start(1), matcher.end(1));
 688             set.add(item);
 689         }
 690     }
 691
 692     /**
 693       Generate the final flags string will be used by compile command.
 694
 695       @param add the add flags set
 696       @param sub the sub flags set
 697       @return final flags after add set substract sub set
 698     **/
 699     private String getFlags(Set<String> add, Set<String> sub) {
 700         String result = "";
 701         add.removeAll(sub);
 702         Iterator iter = add.iterator();
 703         while (iter.hasNext()) {
 704             String str = (String) iter.next();
 705             result += str.substring(1, str.length() - 1) + " ";
 706         }
 707         return result;
 708     }
 709
 710     /**
 711       Generate the flags string with original format. The format is defined by
 712       Java Regulation Expression "[^\\\\]?(\".*?[^\\\\]\")[ \t,]+". </p>
 713
 714       <p>For example: </p>
 715
 716       <pre>
 717         "/nologo", "/W3", "/WX"
 718         "/C", "/DSTRING_DEFINES_FILE=\"BdsStrDefs.h\""
 719       </pre>
 720
 721       @param add the add flags set
 722       @param sub the sub flags set
 723       @return flags with original format
 724     **/
 725     private String getRawFlags(Set<String> add, Set<String> sub) {
 726         String result = null;
 727         add.removeAll(sub);
 728         Iterator iter = add.iterator();
 729         while (iter.hasNext()) {
 730             String str = (String) iter.next();
 731             result += "\"" + str.substring(1, str.length() - 1) + "\", ";
 732         }
 733         return result;
 734     }
 735
 736     private String parseOptionString(String optionString, Set<String> addSet, Set<String> subSet) {
 737         boolean overrideOption = false;
 738         Pattern pattern = Pattern.compile("ADD\\.\\[(.+)\\]");
 739         Matcher matcher = pattern.matcher(optionString);
 740
 741         while (matcher.find()) {
 742             overrideOption = true;
 743             String addOption = optionString.substring(matcher.start(1), matcher.end(1)).trim();
 744             putFlagsToSet(addSet, addOption);
 745
 746         }
 747
 748         pattern = Pattern.compile("SUB\\.\\[(.+)\\]");
 749         matcher = pattern.matcher(optionString);
 750
 751         while (matcher.find()) {
 752             overrideOption = true;
 753             String subOption = optionString.substring(matcher.start(1), matcher.end(1)).trim();
 754             putFlagsToSet(subSet, subOption);
 755         }
 756
 757         if (overrideOption == true) {
 758             return null;
 759         }
 760
 761         return optionString;
 762     }
 763
 764     private void pushProperties() {
 765         backupPropertiesStack.push(getProject().getProperties());
 766     }
 767
 768     private void popProperties() {
 769         Hashtable backupProperties = backupPropertiesStack.pop();
 770         Set keys = backupProperties.keySet();
 771         Iterator iter = keys.iterator();
 772         while (iter.hasNext()) {
 773             String item = (String)iter.next();
 774             getProject().setProperty(item, (String)backupProperties.get(item));
 775         }
 776     }
 777
 778     public void setSingleModuleBuild(boolean isSingleModuleBuild) {
 779         this.isSingleModuleBuild = isSingleModuleBuild;
 780     }
 781 }