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