8e7ee3b941194e2a3200f3b047526aad23290785
[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.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.common.definitions.ToolDefinitions;
36 import org.tianocore.common.exception.EdkException;
37 import org.tianocore.common.logger.EdkLog;
38 import org.tianocore.build.autogen.AutoGen;
39 import org.tianocore.build.fpd.FpdParserTask;
40 import org.tianocore.build.global.GenBuildLogger;
41 import org.tianocore.build.global.GlobalData;
42 import org.tianocore.build.global.OutputManager;
43 import org.tianocore.build.global.PropertyManager;
44 import org.tianocore.build.global.SurfaceAreaQuery;
45 import org.tianocore.build.id.FpdModuleIdentification;
46 import org.tianocore.build.id.ModuleIdentification;
47 import org.tianocore.build.id.PackageIdentification;
48 import org.tianocore.build.id.PlatformIdentification;
49 import org.tianocore.build.tools.ModuleItem;
50
51 /**
52 <p>
53 <code>GenBuildTask</code> is an ANT task that can be used in ANT build
54 system.
55
56 <p>The main function of this task is to parse module's surface area (MSA),
57 then generate the corresponding <em>BaseName_build.xml</em> (the real ANT
58 build script) and call this to build the module. The whole process including:
59
60 <pre>
61 1. generate AutoGen.c and AutoGen.h;
62 2. build all dependent library instances;
63 3. build all source files inlcude AutoGen.c;
64 4. generate sections;
65 5. generate FFS file if it is driver module while LIB file if it is Library module.
66 </pre>
67
68
69 <p>
70 The usage is (take module <em>HelloWorld</em> for example):
71 </p>
72
73 <pre>
74 &lt;GenBuild
75 msaFile="${PACKAGE_DIR}/Application/HelloWorld/HelloWorld.msa"
76 type="cleanall" /&gt;
77 </pre>
78
79 <p>
80 This task calls <code>AutoGen</code> to generate <em>AutoGen.c</em> and
81 <em>AutoGen.h</em>.
82 </p>
83
84 <p>
85 This task will also set properties for current module, such as PACKAGE,
86 PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
87 (relative to Workspace), MODULE or BASE_NAME, GUID, VERSION, MODULE_DIR,
88 MODULE_RELATIVE_DIR (relative to Package), CONFIG_DIR, BIN_DIR,
89 DEST_DIR_DEBUG, DEST_DIR_OUTPUT, TARGET, ARCH, TOOLCHAIN, TOOLCHAIN_FAMILY,
90 SUBSYSTEM, ENTRYPOINT, EBC_TOOL_LIB_PATH, all compiler command related
91 properties (CC, CC_FLAGS, CC_DPATH, CC_SPATH, CC_FAMILY, CC_EXT).
92 </p>
93
94 @since GenBuild 1.0
95 **/
96 public class GenBuildTask extends Ant {
97
98 ///
99 /// Module surface area file.
100 ///
101 File msaFile;
102
103 private String type = "all";
104
105 ///
106 /// Module's Identification.
107 ///
108 private ModuleIdentification moduleId;
109
110 private Vector<Property> properties = new Vector<Property>();
111
112 private static Stack<Hashtable> backupPropertiesStack = new Stack<Hashtable>();
113
114 private boolean isSingleModuleBuild = false;
115
116 /**
117 Public construct method. It is necessary for ANT task.
118 **/
119 public GenBuildTask() {
120 }
121
122 /**
123
124 @throws BuildException
125 From module build, exception from module surface area invalid.
126 **/
127 public void execute() throws BuildException {
128 //
129 // set Logger
130 //
131 GenBuildLogger logger = new GenBuildLogger(getProject());
132 EdkLog.setLogLevel(getProject().getProperty("env.LOGLEVEL"));
133 EdkLog.setLogger(logger);
134
135 PropertyManager.setProject(getProject());
136 PropertyManager.save();
137 //
138 // Enable all specified properties
139 //
140 Iterator<Property> iter = properties.iterator();
141 while (iter.hasNext()) {
142 Property item = iter.next();
143 PropertyManager.setProperty(item.getName(), item.getValue());
144 }
145
146 //
147 // GenBuild should specify either msaFile or moduleGuid & packageGuid
148 //
149 if (msaFile == null ) {
150 String moduleGuid = getProject().getProperty("MODULE_GUID");
151 String moduleVersion = getProject().getProperty("MODULE_VERSION");
152 String packageGuid = getProject().getProperty("PACKAGE_GUID");
153 String packageVersion = getProject().getProperty("PACKAGE_VERSION");
154 if (moduleGuid == null || packageGuid == null) {
155 throw new BuildException("GenBuild parameter error.");
156 }
157 PackageIdentification packageId = new PackageIdentification(packageGuid, packageVersion);
158 moduleId = new ModuleIdentification(moduleGuid, moduleVersion);
159 moduleId.setPackage(packageId);
160 Map<String, XmlObject> doc = GlobalData.getNativeMsa(moduleId);
161 SurfaceAreaQuery.setDoc(doc);
162 moduleId = SurfaceAreaQuery.getMsaHeader();
163 } else {
164 Map<String, XmlObject> doc = GlobalData.getNativeMsa(msaFile);
165 SurfaceAreaQuery.setDoc(doc);
166 moduleId = SurfaceAreaQuery.getMsaHeader();
167 }
168 String[] producedLibraryClasses = SurfaceAreaQuery.getLibraryClasses("ALWAYS_PRODUCED",null);
169 if (producedLibraryClasses.length == 0) {
170 moduleId.setLibrary(false);
171 } else {
172 moduleId.setLibrary(true);
173 }
174
175 //
176 // Judge whether it is single module build or not
177 //
178 if (isSingleModuleBuild) {
179 //
180 // Single Module build
181 //
182 prepareSingleModuleBuild();
183 } else {
184 //
185 // Platform build. Restore the platform related info
186 //
187 String filename = getProject().getProperty("PLATFORM_FILE");
188 PlatformIdentification platformId = GlobalData.getPlatform(filename);
189 PropertyManager.setProperty("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
190 PropertyManager.setProperty("PLATFORM_RELATIVE_DIR", platformId.getPlatformRelativeDir().replaceAll("(\\\\)", "/"));
191
192 String packageGuid = getProject().getProperty("PACKAGE_GUID");
193 String packageVersion = getProject().getProperty("PACKAGE_VERSION");
194 PackageIdentification packageId = new PackageIdentification(packageGuid, packageVersion);
195 moduleId.setPackage(packageId);
196 }
197
198 //
199 // If single module : get arch from pass down, otherwise intersection MSA
200 // supported ARCHs and tools def
201 //
202 Set<String> archListSupByToolChain = new LinkedHashSet<String>();
203 String[] archs = GlobalData.getToolChainInfo().getArchs();
204
205 for (int i = 0; i < archs.length; i ++) {
206 archListSupByToolChain.add(archs[i]);
207 }
208
209 Set<String> archSet = new LinkedHashSet<String>();
210
211 if ( getProject().getProperty("ARCH") != null) {
212 String[] fpdArchList = getProject().getProperty("ARCH").split(" ");
213
214 for (int i = 0; i < fpdArchList.length; i++) {
215 if (archListSupByToolChain.contains(fpdArchList[i])) {
216 archSet.add(fpdArchList[i]);
217 }
218 }
219 } else {
220 archSet = archListSupByToolChain;
221 }
222
223 String[] archList = archSet.toArray(new String[archSet.size()]);
224
225 //
226 // Judge if arch is all supported by current module. If not, throw Exception.
227 //
228 List moduleSupportedArchs = SurfaceAreaQuery.getModuleSupportedArchs();
229 if (moduleSupportedArchs != null) {
230 for (int k = 0; k < archList.length; k++) {
231 if ( ! moduleSupportedArchs.contains(archList[k])) {
232 throw new BuildException("Specified architecture [" + archList[k] + "] is not supported by " + moduleId + ". The module " + moduleId + " only supports [" + moduleSupportedArchs + "] architectures.");
233 }
234 }
235 }
236
237 for (int k = 0; k < archList.length; k++) {
238
239 PropertyManager.setProperty("ARCH", archList[k]);
240
241 FpdModuleIdentification fpdModuleId = new FpdModuleIdentification(moduleId, archList[k]);
242
243 //
244 // Whether the module is built before
245 //
246 if (moduleId.isLibrary() == false && GlobalData.hasFpdModuleSA(fpdModuleId) == false) {
247 System.out.println("\nWARNING: " + moduleId + " for " + archList[k] + " was not found in current platform FPD file!\n");
248 continue;
249 } else if (GlobalData.isModuleBuilt(fpdModuleId)) {
250 break;
251 } else {
252 GlobalData.registerBuiltModule(fpdModuleId);
253 }
254
255 //
256 // For Every TOOLCHAIN, TARGET
257 //
258 String[] targetList = GlobalData.getToolChainInfo().getTargets();
259 for (int i = 0; i < targetList.length; i ++){
260 //
261 // Prepare for target related common properties
262 // TARGET
263 //
264 PropertyManager.setProperty("TARGET", targetList[i]);
265 String[] toolchainList = GlobalData.getToolChainInfo().getTagnames();
266 for(int j = 0; j < toolchainList.length; j ++){
267 //
268 // check if any tool is defined for current target + toolchain + arch
269 // don't do anything if no tools found
270 //
271 if (GlobalData.isCommandSet(targetList[i], toolchainList[j], archList[k]) == false) {
272 System.out.println("Warning: No build issued. No tools were found for [target=" + targetList[i] + " toolchain=" + toolchainList[j] + " arch=" + archList[k] + "]\n");
273 continue;
274 }
275
276 //
277 // Prepare for toolchain related common properties
278 // TOOLCHAIN
279 //
280 PropertyManager.setProperty("TOOLCHAIN", toolchainList[j]);
281
282 System.out.println("Build " + moduleId + " start >>>");
283 System.out.println("Target: " + targetList[i] + " Tagname: " + toolchainList[j] + " Arch: " + archList[k]);
284 SurfaceAreaQuery.setDoc(GlobalData.getDoc(fpdModuleId));
285
286 //
287 // Prepare for all other common properties
288 // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
289 // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
290 // MODULE_DIR, MODULE_RELATIVE_DIR
291 // SUBSYSTEM, ENTRYPOINT, EBC_TOOL_LIB_PATH
292 //
293 setModuleCommonProperties(archList[k]);
294
295 //
296 // OutputManage prepare for
297 // BIN_DIR, DEST_DIR_DEBUG, DEST_DIR_OUTPUT, BUILD_DIR, FV_DIR
298 //
299 OutputManager.getInstance().update(getProject());
300
301 if (type.equalsIgnoreCase("all") || type.equalsIgnoreCase("build")) {
302 applyBuild(targetList[i], toolchainList[j], fpdModuleId);
303 } else if (type.equalsIgnoreCase("clean")) {
304 applyClean(fpdModuleId);
305 } else if (type.equalsIgnoreCase("cleanall")) {
306 applyCleanall(fpdModuleId);
307 }
308 }
309 }
310 }
311
312 PropertyManager.restore();
313 }
314
315 /**
316 This method is used to prepare Platform-related information.
317
318 <p>In Single Module Build mode, platform-related information is not ready.
319 The method read the system environment variable <code>ACTIVE_PLATFORM</code>
320 and search in the Framework Database. Note that platform name in the Framework
321 Database must be unique. </p>
322
323 **/
324 private void prepareSingleModuleBuild(){
325 //
326 // Find out the package which the module belongs to
327 // TBD: Enhance it!!!!
328 //
329 PackageIdentification packageId = GlobalData.getPackageForModule(moduleId);
330
331 moduleId.setPackage(packageId);
332
333 //
334 // Read ACTIVE_PLATFORM's FPD file
335 //
336 String filename = getProject().getProperty("PLATFORM_FILE");
337
338 if (filename == null){
339 throw new BuildException("Please set ACTIVE_PLATFORM in the file: Tools/Conf/target.txt if you want to build a single module!");
340 }
341
342 PlatformIdentification platformId = GlobalData.getPlatform(filename);
343
344 //
345 // Read FPD file (Call FpdParserTask's method)
346 //
347 FpdParserTask fpdParser = new FpdParserTask();
348 fpdParser.setProject(getProject());
349 fpdParser.parseFpdFile(platformId.getFpdFile());
350
351 //
352 // Prepare for Platform related common properties
353 // PLATFORM, PLATFORM_DIR, PLATFORM_RELATIVE_DIR
354 //
355 PropertyManager.setProperty("PLATFORM", platformId.getName());
356 PropertyManager.setProperty("PLATFORM_DIR", platformId.getFpdFile().getParent().replaceAll("(\\\\)", "/"));
357 PropertyManager.setProperty("PLATFORM_RELATIVE_DIR", platformId.getPlatformRelativeDir().replaceAll("(\\\\)", "/"));
358 }
359
360
361 /**
362 Set Module-Related information to properties.
363
364 @param arch current build ARCH
365 **/
366 private void setModuleCommonProperties(String arch) {
367 //
368 // Prepare for all other common properties
369 // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
370 //
371 PackageIdentification packageId = moduleId.getPackage();
372 PropertyManager.setProperty("PACKAGE", packageId.getName());
373 PropertyManager.setProperty("PACKAGE_GUID", packageId.getGuid());
374 PropertyManager.setProperty("PACKAGE_VERSION", packageId.getVersion());
375 PropertyManager.setProperty("PACKAGE_DIR", packageId.getPackageDir().replaceAll("(\\\\)", "/"));
376 PropertyManager.setProperty("PACKAGE_RELATIVE_DIR", packageId.getPackageRelativeDir().replaceAll("(\\\\)", "/"));
377
378 //
379 // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
380 // MODULE_DIR, MODULE_RELATIVE_DIR
381 //
382 PropertyManager.setProperty("MODULE", moduleId.getName());
383 String baseName = SurfaceAreaQuery.getModuleOutputFileBasename();
384 if (baseName == null) {
385 PropertyManager.setProperty("BASE_NAME", moduleId.getName());
386 } else {
387 PropertyManager.setProperty("BASE_NAME", baseName);
388 }
389 PropertyManager.setProperty("GUID", moduleId.getGuid());
390 PropertyManager.setProperty("FILE_GUID", moduleId.getGuid());
391 PropertyManager.setProperty("VERSION", moduleId.getVersion());
392 PropertyManager.setProperty("MODULE_TYPE", moduleId.getModuleType());
393 PropertyManager.setProperty("MODULE_DIR", moduleId.getMsaFile().getParent().replaceAll("(\\\\)", "/"));
394 PropertyManager.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 PropertyManager.setProperty("SUBSYSTEM", subsystem);
421
422 //
423 // ENTRYPOINT
424 //
425 if (arch.equalsIgnoreCase("EBC")) {
426 PropertyManager.setProperty("ENTRYPOINT", "EfiStart");
427 } else {
428 PropertyManager.setProperty("ENTRYPOINT", "_ModuleEntryPoint");
429 }
430
431 PropertyManager.setProperty("OBJECTS", "");
432 }
433
434 private void getCompilerFlags(String target, String toolchain, FpdModuleIdentification fpdModuleId) throws EdkException {
435 String[] cmd = GlobalData.getToolChainInfo().getCommands();
436 for ( int m = 0; m < cmd.length; m++) {
437 //
438 // Set cmd, like CC, DLINK
439 //
440 String[] key = new String[]{target, toolchain, fpdModuleId.getArch(), cmd[m], null};
441 key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_PATH;
442 String cmdPath = GlobalData.getCommandSetting(key, fpdModuleId);
443 key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_NAME;
444 String cmdName = GlobalData.getCommandSetting(key, fpdModuleId);
445 File cmdFile = new File(cmdPath + File.separatorChar + cmdName);
446 PropertyManager.setProperty(cmd[m], cmdFile.getPath().replaceAll("(\\\\)", "/"));
447
448 //
449 // set CC_FLAGS
450 //
451 key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_FLAGS;
452 String cmdFlags = GlobalData.getCommandSetting(key, fpdModuleId);
453 Set<String> addset = new LinkedHashSet<String>();
454 Set<String> subset = new LinkedHashSet<String>();
455 putFlagsToSet(addset, cmdFlags);
456 PropertyManager.setProperty(cmd[m] + "_FLAGS", getProject().replaceProperties(getFlags(addset, subset)));
457
458 //
459 // Set CC_EXT
460 //
461 key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_EXT;
462 String extName = GlobalData.getCommandSetting(key, fpdModuleId);
463 if ( extName != null && ! extName.equalsIgnoreCase("")) {
464 PropertyManager.setProperty(cmd[m] + "_EXT", extName);
465 } else {
466 PropertyManager.setProperty(cmd[m] + "_EXT", "");
467 }
468
469 //
470 // set CC_FAMILY
471 //
472 key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_FAMILY;
473 String toolChainFamily = GlobalData.getCommandSetting(key, fpdModuleId);
474 if (toolChainFamily != null) {
475 PropertyManager.setProperty(cmd[m] + "_FAMILY", toolChainFamily);
476 }
477
478 //
479 // set CC_SPATH
480 //
481 key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_SPATH;
482 String spath = GlobalData.getCommandSetting(key, fpdModuleId);
483 if (spath != null) {
484 PropertyManager.setProperty(cmd[m] + "_SPATH", spath.replaceAll("(\\\\)", "/"));
485 } else {
486 PropertyManager.setProperty(cmd[m] + "_SPATH", "");
487 }
488
489 //
490 // set CC_DPATH
491 //
492 key[4] = ToolDefinitions.TOOLS_DEF_ATTRIBUTE_DPATH;
493 String dpath = GlobalData.getCommandSetting(key, fpdModuleId);
494 if (dpath != null) {
495 PropertyManager.setProperty(cmd[m] + "_DPATH", dpath.replaceAll("(\\\\)", "/"));
496 } else {
497 PropertyManager.setProperty(cmd[m] + "_DPATH", "");
498 }
499 }
500 }
501
502 public void setMsaFile(File msaFile) {
503 this.msaFile = msaFile;
504 }
505
506 /**
507 Method is for ANT to initialize MSA file.
508
509 @param msaFilename MSA file name
510 **/
511 public void setMsaFile(String msaFilename) {
512 String moduleDir = getProject().getProperty("MODULE_DIR");
513
514 //
515 // If is Single Module Build, then use the Base Dir defined in build.xml
516 //
517 if (moduleDir == null) {
518 moduleDir = getProject().getBaseDir().getPath();
519 }
520 msaFile = new File(moduleDir + File.separatorChar + msaFilename);
521 }
522
523 public void addConfiguredModuleItem(ModuleItem moduleItem) {
524 PackageIdentification packageId = new PackageIdentification(moduleItem.getPackageGuid(), moduleItem.getPackageVersion());
525 ModuleIdentification moduleId = new ModuleIdentification(moduleItem.getModuleGuid(), moduleItem.getModuleVersion());
526 moduleId.setPackage(packageId);
527 this.moduleId = moduleId;
528 }
529
530 /**
531 Add a property.
532
533 @param p property
534 **/
535 public void addProperty(Property p) {
536 properties.addElement(p);
537 }
538
539 public void setType(String type) {
540 this.type = type;
541 }
542
543 private void applyBuild(String buildTarget, String buildTagname, FpdModuleIdentification fpdModuleId) throws BuildException{
544 //
545 // AutoGen
546 //
547
548 AutoGen autogen = new AutoGen(getProject().getProperty("FV_DIR"), getProject().getProperty("DEST_DIR_DEBUG"), fpdModuleId.getModule(),fpdModuleId.getArch());
549 autogen.genAutogen();
550
551
552 //
553 // Get compiler flags
554 //
555 try {
556 getCompilerFlags(buildTarget, buildTagname, fpdModuleId);
557 }
558 catch (EdkException ee) {
559 throw new BuildException(ee.getMessage());
560 }
561
562 //
563 // Prepare LIBS
564 //
565 ModuleIdentification[] libinstances = SurfaceAreaQuery.getLibraryInstance(fpdModuleId.getArch());
566 String propertyLibs = "";
567 for (int i = 0; i < libinstances.length; i++) {
568 propertyLibs += " " + getProject().getProperty("BIN_DIR") + File.separatorChar + libinstances[i].getName() + ".lib";
569 }
570 PropertyManager.setProperty("LIBS", propertyLibs.replaceAll("(\\\\)", "/"));
571
572 //
573 // if it is CUSTOM_BUILD
574 // then call the exist BaseName_build.xml directly.
575 //
576 if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
577 System.out.println("Call user-defined " + moduleId.getName() + "_build.xml");
578
579 String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
580 antCall(antFilename, null);
581
582 return ;
583 }
584
585 //
586 // Generate ${BASE_NAME}_build.xml
587 // TBD
588 //
589 String ffsKeyword = SurfaceAreaQuery.getModuleFfsKeyword();
590 ModuleBuildFileGenerator fileGenerator = new ModuleBuildFileGenerator(getProject(), ffsKeyword, fpdModuleId);
591 String buildFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
592 fileGenerator.genBuildFile(buildFilename);
593
594 //
595 // Ant call ${BASE_NAME}_build.xml
596 //
597 String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
598 antCall(antFilename, null);
599 }
600
601 private void applyClean(FpdModuleIdentification fpdModuleId){
602 //
603 // if it is CUSTOM_BUILD
604 // then call the exist BaseName_build.xml directly.
605 //
606 if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
607 System.out.println("Calling user-defined " + moduleId.getName() + "_build.xml");
608
609 String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
610 antCall(antFilename, "clean");
611
612 return ;
613 }
614
615 String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
616 antCall(antFilename, "clean");
617 }
618
619 private void applyCleanall(FpdModuleIdentification fpdModuleId){
620 //
621 // if it is CUSTOM_BUILD
622 // then call the exist BaseName_build.xml directly.
623 //
624 if (moduleId.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
625 System.out.println("Calling user-defined " + moduleId.getName() + "_build.xml");
626
627 String antFilename = getProject().getProperty("MODULE_DIR") + File.separatorChar + moduleId.getName() + "_build.xml";
628 antCall(antFilename, "cleanall");
629
630 return ;
631 }
632
633 String antFilename = getProject().getProperty("DEST_DIR_OUTPUT") + File.separatorChar + moduleId.getName() + "_build.xml";
634 antCall(antFilename, "cleanall");
635 }
636
637 private void antCall(String antFilename, String target) {
638 Ant ant = new Ant();
639 ant.setProject(getProject());
640 ant.setAntfile(antFilename);
641 if (target != null) {
642 ant.setTarget(target);
643 }
644 ant.setInheritAll(true);
645 ant.init();
646 ant.execute();
647 }
648
649
650 /**
651 Separate the string and instore in set.
652
653 <p> String is separated by Java Regulation Expression
654 "[^\\\\]?(\".*?[^\\\\]\")[ \t,]+". </p>
655
656 <p>For example: </p>
657
658 <pre>
659 "/nologo", "/W3", "/WX"
660 "/C", "/DSTRING_DEFINES_FILE=\"BdsStrDefs.h\""
661 </pre>
662
663 @param set store the separated string
664 @param str string to separate
665 **/
666 private void putFlagsToSet(Set<String> set, String str) {
667 if (str == null || str.length() == 0) {
668 return;
669 }
670
671 Pattern myPattern = Pattern.compile("[^\\\\]?(\".*?[^\\\\]\")[ \t,]+");
672 Matcher matcher = myPattern.matcher(str + " ");
673 while (matcher.find()) {
674 String item = str.substring(matcher.start(1), matcher.end(1));
675 set.add(item);
676 }
677 }
678
679 /**
680 Generate the final flags string will be used by compile command.
681
682 @param add the add flags set
683 @param sub the sub flags set
684 @return final flags after add set substract sub set
685 **/
686 private String getFlags(Set<String> add, Set<String> sub) {
687 String result = "";
688 add.removeAll(sub);
689 Iterator iter = add.iterator();
690 while (iter.hasNext()) {
691 String str = (String) iter.next();
692 result += str.substring(1, str.length() - 1) + " ";
693 }
694 return result;
695 }
696
697 public void setSingleModuleBuild(boolean isSingleModuleBuild) {
698 this.isSingleModuleBuild = isSingleModuleBuild;
699 }
700 }