1f020b3cc15df0b17b2d66dd247f1901a25b8f4c
[mirror_edk2.git] / 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 continue;
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 }