2 This file is ANT task GenBuild.
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.
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
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.
16 package org
.tianocore
.build
;
19 import java
.util
.Hashtable
;
20 import java
.util
.Iterator
;
21 import java
.util
.LinkedHashSet
;
22 import java
.util
.List
;
25 import java
.util
.Vector
;
27 import org
.apache
.tools
.ant
.BuildException
;
28 import org
.apache
.tools
.ant
.BuildListener
;
29 import org
.apache
.tools
.ant
.Project
;
30 import org
.apache
.tools
.ant
.taskdefs
.Ant
;
31 import org
.apache
.tools
.ant
.taskdefs
.Property
;
32 import org
.apache
.xmlbeans
.XmlObject
;
34 import org
.tianocore
.common
.definitions
.ToolDefinitions
;
35 import org
.tianocore
.common
.exception
.EdkException
;
36 import org
.tianocore
.common
.logger
.EdkLog
;
37 import org
.tianocore
.build
.autogen
.AutoGen
;
38 import org
.tianocore
.build
.exception
.AutoGenException
;
39 import org
.tianocore
.build
.exception
.GenBuildException
;
40 import org
.tianocore
.build
.exception
.PcdAutogenException
;
41 import org
.tianocore
.build
.exception
.PlatformPcdPreprocessBuildException
;
42 import org
.tianocore
.build
.fpd
.FpdParserTask
;
43 import org
.tianocore
.build
.global
.GlobalData
;
44 import org
.tianocore
.build
.global
.OutputManager
;
45 import org
.tianocore
.build
.global
.SurfaceAreaQuery
;
46 import org
.tianocore
.build
.id
.FpdModuleIdentification
;
47 import org
.tianocore
.build
.id
.ModuleIdentification
;
48 import org
.tianocore
.build
.id
.PackageIdentification
;
49 import org
.tianocore
.build
.id
.PlatformIdentification
;
50 import org
.tianocore
.build
.tools
.ModuleItem
;
54 <code>GenBuildTask</code> is an ANT task that can be used in ANT build
57 <p>The main function of this task is to parse module's surface area (MSA),
58 then generate the corresponding <em>BaseName_build.xml</em> (the real ANT
59 build script) and call this to build the module. The whole process including:
62 1. generate AutoGen.c and AutoGen.h;
63 2. build all dependent library instances;
64 3. build all source files inlcude AutoGen.c;
66 5. generate FFS file if it is driver module while LIB file if it is Library module.
71 The usage is (take module <em>HelloWorld</em> for example):
76 msaFile="${PACKAGE_DIR}/Application/HelloWorld/HelloWorld.msa"
81 This task calls <code>AutoGen</code> to generate <em>AutoGen.c</em> and
86 This task will also set properties for current module, such as PACKAGE,
87 PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
88 (relative to Workspace), MODULE or BASE_NAME, GUID, VERSION, MODULE_DIR,
89 MODULE_RELATIVE_DIR (relative to Package), CONFIG_DIR, BIN_DIR,
90 DEST_DIR_DEBUG, DEST_DIR_OUTPUT, TARGET, ARCH, TOOLCHAIN, TOOLCHAIN_FAMILY,
91 SUBSYSTEM, ENTRYPOINT, EBC_TOOL_LIB_PATH, all compiler command related
92 properties (CC, CC_FLAGS, CC_DPATH, CC_SPATH, CC_FAMILY, CC_EXT).
97 public class GenBuildTask
extends Ant
{
100 /// Module surface area file.
104 public ModuleIdentification parentId
;
106 private String type
= "all";
109 /// Module's Identification.
111 private ModuleIdentification moduleId
;
113 private Vector
<Property
> properties
= new Vector
<Property
>();
115 private boolean isSingleModuleBuild
= false;
117 private SurfaceAreaQuery saq
= null;
120 Public construct method. It is necessary for ANT task.
122 public GenBuildTask() {
127 @throws BuildException
128 From module build, exception from module surface area invalid.
130 public void execute() throws BuildException
{
131 this.setTaskName("GenBuild");
134 } catch (PcdAutogenException e
) {
135 BuildException buildException
= new BuildException(e
.getMessage());
136 buildException
.setStackTrace(e
.getStackTrace());
137 throw buildException
;
138 } catch (AutoGenException e
) {
139 BuildException buildException
= new BuildException(e
.getMessage());
140 buildException
.setStackTrace(e
.getStackTrace());
141 throw buildException
;
142 } catch (PlatformPcdPreprocessBuildException e
) {
143 BuildException buildException
= new BuildException(e
.getMessage());
144 buildException
.setStackTrace(e
.getStackTrace());
145 throw buildException
;
146 } catch (GenBuildException e
) {
147 BuildException buildException
= new BuildException(e
.getMessage());
148 buildException
.setStackTrace(e
.getStackTrace());
149 throw buildException
;
150 } catch (EdkException e
) {
151 BuildException buildException
= new BuildException(e
.getMessage());
152 buildException
.setStackTrace(e
.getStackTrace());
153 throw buildException
;
157 private void processGenBuild() throws EdkException
, BuildException
, GenBuildException
, AutoGenException
, PcdAutogenException
, PlatformPcdPreprocessBuildException
{
158 if (!FrameworkBuildTask
.multithread
) {
163 // Enable all specified properties
165 Iterator
<Property
> iter
= properties
.iterator();
166 while (iter
.hasNext()) {
167 Property item
= iter
.next();
168 getProject().setProperty(item
.getName(), item
.getValue());
172 // GenBuild should specify either msaFile or moduleGuid & packageGuid
174 if (msaFile
== null ) {
175 String moduleGuid
= getProject().getProperty("MODULE_GUID");
176 String moduleVersion
= getProject().getProperty("MODULE_VERSION");
177 String packageGuid
= getProject().getProperty("PACKAGE_GUID");
178 String packageVersion
= getProject().getProperty("PACKAGE_VERSION");
180 // If one of module Guid or package Guid is not specified, report error
182 if (moduleGuid
== null || packageGuid
== null) {
183 throw new BuildException("GenBuild parameter error.");
186 PackageIdentification packageId
= new PackageIdentification(packageGuid
, packageVersion
);
187 GlobalData
.refreshPackageIdentification(packageId
);
188 moduleId
= new ModuleIdentification(moduleGuid
, moduleVersion
);
189 moduleId
.setPackage(packageId
);
190 GlobalData
.refreshModuleIdentification(moduleId
);
191 Map
<String
, XmlObject
> doc
= GlobalData
.getNativeMsa(moduleId
);
192 saq
= new SurfaceAreaQuery(doc
);
194 Map
<String
, XmlObject
> doc
= GlobalData
.getNativeMsa(msaFile
);
195 saq
= new SurfaceAreaQuery(doc
);
196 moduleId
= saq
.getMsaHeader();
197 moduleId
.setMsaFile(msaFile
);
200 String
[] producedLibraryClasses
= saq
.getLibraryClasses("ALWAYS_PRODUCED",null);
201 if (producedLibraryClasses
.length
== 0) {
202 moduleId
.setLibrary(false);
204 moduleId
.setLibrary(true);
208 // Judge whether it is single module build or not
210 if (isSingleModuleBuild
) {
212 // Single Module build
214 prepareSingleModuleBuild();
218 // If single module : get arch from pass down, otherwise intersection MSA
219 // supported ARCHs and tools def
221 Set
<String
> archListSupByToolChain
= new LinkedHashSet
<String
>();
222 String
[] archs
= GlobalData
.getToolChainInfo().getArchs();
224 for (int i
= 0; i
< archs
.length
; i
++) {
225 archListSupByToolChain
.add(archs
[i
]);
228 Set
<String
> archSet
= new LinkedHashSet
<String
>();
230 if ( getProject().getProperty("ARCH") != null) {
231 String
[] fpdArchList
= getProject().getProperty("ARCH").split(" ");
233 for (int i
= 0; i
< fpdArchList
.length
; i
++) {
234 if (archListSupByToolChain
.contains(fpdArchList
[i
])) {
235 archSet
.add(fpdArchList
[i
]);
239 archSet
= archListSupByToolChain
;
242 String
[] archList
= archSet
.toArray(new String
[archSet
.size()]);
245 // Judge if arch is all supported by current module. If not, throw Exception.
247 List moduleSupportedArchs
= saq
.getModuleSupportedArchs();
248 if (moduleSupportedArchs
!= null) {
249 for (int k
= 0; k
< archList
.length
; k
++) {
250 if ( ! moduleSupportedArchs
.contains(archList
[k
])) {
251 throw new BuildException("Specified architecture [" + archList
[k
] + "] is not supported by " + moduleId
+ ". The module " + moduleId
+ " only supports [" + moduleSupportedArchs
+ "] architectures.");
256 for (int k
= 0; k
< archList
.length
; k
++) {
258 getProject().setProperty("ARCH", archList
[k
]);
260 FpdModuleIdentification fpdModuleId
= new FpdModuleIdentification(moduleId
, archList
[k
]);
263 // Whether the module is built before
265 if (moduleId
.isLibrary() == false && GlobalData
.hasFpdModuleSA(fpdModuleId
) == false) {
266 EdkLog
.log(this, EdkLog
.EDK_WARNING
, "Warning: " + moduleId
+ " for " + archList
[k
] + " was not found in current platform FPD file!\n");
268 } else if (GlobalData
.isModuleBuilt(fpdModuleId
)) {
271 GlobalData
.registerBuiltModule(fpdModuleId
);
275 // For Every TOOLCHAIN, TARGET
277 String
[] targetList
= GlobalData
.getToolChainInfo().getTargets();
278 for (int i
= 0; i
< targetList
.length
; i
++){
280 // Prepare for target related common properties
283 getProject().setProperty("TARGET", targetList
[i
]);
284 String
[] toolchainList
= GlobalData
.getToolChainInfo().getTagnames();
285 for(int j
= 0; j
< toolchainList
.length
; j
++){
287 // check if any tool is defined for current target + toolchain + arch
288 // don't do anything if no tools found
290 if (GlobalData
.isCommandSet(targetList
[i
], toolchainList
[j
], archList
[k
]) == false) {
291 EdkLog
.log(this, EdkLog
.EDK_WARNING
, "Warning: No build issued. No tools found for [target=" + targetList
[i
] + " toolchain=" + toolchainList
[j
] + " arch=" + archList
[k
] + "]\n");
296 // Prepare for toolchain related common properties
299 getProject().setProperty("TOOLCHAIN", toolchainList
[j
]);
301 EdkLog
.log(this, "Build " + moduleId
+ " start >>>");
302 EdkLog
.log(this, "Target: " + targetList
[i
] + " Tagname: " + toolchainList
[j
] + " Arch: " + archList
[k
]);
303 saq
.push(GlobalData
.getDoc(fpdModuleId
));
306 // Prepare for all other common properties
307 // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
308 // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
309 // MODULE_DIR, MODULE_RELATIVE_DIR
310 // SUBSYSTEM, ENTRYPOINT, EBC_TOOL_LIB_PATH
312 setModuleCommonProperties(archList
[k
]);
315 // OutputManage prepare for
316 // BIN_DIR, DEST_DIR_DEBUG, DEST_DIR_OUTPUT, BUILD_DIR, FV_DIR
318 OutputManager
.getInstance().update(getProject());
320 if (type
.equalsIgnoreCase("all") || type
.equalsIgnoreCase("build")) {
321 applyBuild(targetList
[i
], toolchainList
[j
], fpdModuleId
);
322 } else if (type
.equalsIgnoreCase("clean")) {
323 applyClean(fpdModuleId
);
324 } else if (type
.equalsIgnoreCase("cleanall")) {
325 applyCleanall(fpdModuleId
);
333 This method is used to prepare Platform-related information.
335 <p>In Single Module Build mode, platform-related information is not ready.
336 The method read the system environment variable <code>ACTIVE_PLATFORM</code>
337 and search in the Framework Database. Note that platform name in the Framework
338 Database must be unique. </p>
341 private void prepareSingleModuleBuild() throws EdkException
{
343 // Find out the package which the module belongs to
345 PackageIdentification packageId
= GlobalData
.getPackageForModule(moduleId
);
346 GlobalData
.refreshPackageIdentification(packageId
);
347 moduleId
.setPackage(packageId
);
348 GlobalData
.refreshModuleIdentification(moduleId
);
351 // Read ACTIVE_PLATFORM's FPD file
353 String filename
= getProject().getProperty("PLATFORM_FILE");
355 if (filename
== null){
356 throw new BuildException("Please set ACTIVE_PLATFORM in the file: Tools/Conf/target.txt if you want to build a single module!");
359 PlatformIdentification platformId
= GlobalData
.getPlatform(filename
);
362 // Read FPD file (Call FpdParserTask's method)
364 FpdParserTask fpdParser
= new FpdParserTask();
365 fpdParser
.setProject(getProject());
366 fpdParser
.parseFpdFile(platformId
.getFpdFile());
367 getProject().setProperty("ARCH", fpdParser
.getAllArchForModule(moduleId
));
370 private void cleanupProperties() {
371 Project newProject
= new Project();
373 Hashtable
<String
, String
> passdownProperties
= FrameworkBuildTask
.originalProperties
;
374 Iterator
<String
> iter
= passdownProperties
.keySet().iterator();
375 while (iter
.hasNext()) {
376 String item
= iter
.next();
377 newProject
.setProperty(item
, passdownProperties
.get(item
));
380 newProject
.setInputHandler(getProject().getInputHandler());
382 Iterator listenerIter
= getProject().getBuildListeners().iterator();
383 while (listenerIter
.hasNext()) {
384 newProject
.addBuildListener((BuildListener
) listenerIter
.next());
387 getProject().initSubProject(newProject
);
389 setProject(newProject
);
393 Set Module-Related information to properties.
395 @param arch current build ARCH
397 private void setModuleCommonProperties(String arch
) {
399 // Prepare for all other common properties
400 // PACKAGE, PACKAGE_GUID, PACKAGE_VERSION, PACKAGE_DIR, PACKAGE_RELATIVE_DIR
402 PackageIdentification packageId
= moduleId
.getPackage();
403 getProject().setProperty("PACKAGE", packageId
.getName());
404 getProject().setProperty("PACKAGE_GUID", packageId
.getGuid());
405 getProject().setProperty("PACKAGE_VERSION", packageId
.getVersion());
406 getProject().setProperty("PACKAGE_DIR", packageId
.getPackageDir().replaceAll("(\\\\)", "/"));
407 getProject().setProperty("PACKAGE_RELATIVE_DIR", packageId
.getPackageRelativeDir().replaceAll("(\\\\)", "/"));
410 // MODULE or BASE_NAME, GUID or FILE_GUID, VERSION, MODULE_TYPE
411 // MODULE_DIR, MODULE_RELATIVE_DIR
413 getProject().setProperty("MODULE", moduleId
.getName());
414 String baseName
= saq
.getModuleOutputFileBasename();
415 if (baseName
== null) {
416 getProject().setProperty("BASE_NAME", moduleId
.getName());
418 getProject().setProperty("BASE_NAME", baseName
);
420 getProject().setProperty("GUID", moduleId
.getGuid());
421 getProject().setProperty("FILE_GUID", moduleId
.getGuid());
422 getProject().setProperty("VERSION", moduleId
.getVersion());
423 getProject().setProperty("MODULE_TYPE", moduleId
.getModuleType());
424 getProject().setProperty("MODULE_DIR", moduleId
.getMsaFile().getParent().replaceAll("(\\\\)", "/"));
425 getProject().setProperty("MODULE_RELATIVE_DIR", moduleId
.getModuleRelativePath().replaceAll("(\\\\)", "/"));
430 String
[][] subsystemMap
= { { "BASE", "EFI_BOOT_SERVICE_DRIVER"},
431 { "SEC", "EFI_BOOT_SERVICE_DRIVER" },
432 { "PEI_CORE", "EFI_BOOT_SERVICE_DRIVER" },
433 { "PEIM", "EFI_BOOT_SERVICE_DRIVER" },
434 { "DXE_CORE", "EFI_BOOT_SERVICE_DRIVER" },
435 { "DXE_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
436 { "DXE_RUNTIME_DRIVER", "EFI_RUNTIME_DRIVER" },
437 { "DXE_SAL_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
438 { "DXE_SMM_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
439 { "TOOL", "EFI_BOOT_SERVICE_DRIVER" },
440 { "UEFI_DRIVER", "EFI_BOOT_SERVICE_DRIVER" },
441 { "UEFI_APPLICATION", "EFI_APPLICATION" },
442 { "USER_DEFINED", "EFI_BOOT_SERVICE_DRIVER"} };
444 String subsystem
= "EFI_BOOT_SERVICE_DRIVER";
445 for (int i
= 0; i
< subsystemMap
.length
; i
++) {
446 if (moduleId
.getModuleType().equalsIgnoreCase(subsystemMap
[i
][0])) {
447 subsystem
= subsystemMap
[i
][1];
451 getProject().setProperty("SUBSYSTEM", subsystem
);
456 if (arch
.equalsIgnoreCase("EBC")) {
457 getProject().setProperty("ENTRYPOINT", "EfiStart");
459 getProject().setProperty("ENTRYPOINT", "_ModuleEntryPoint");
462 getProject().setProperty("OBJECTS", "");
465 private void getCompilerFlags(String target
, String toolchain
, FpdModuleIdentification fpdModuleId
) throws EdkException
{
466 String
[] cmd
= GlobalData
.getToolChainInfo().getCommands();
467 for ( int m
= 0; m
< cmd
.length
; m
++) {
469 // Set cmd, like CC, DLINK
471 String
[] key
= new String
[]{target
, toolchain
, fpdModuleId
.getArch(), cmd
[m
], null};
472 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_PATH
;
473 String cmdPath
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
474 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_NAME
;
475 String cmdName
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
476 if (cmdName
.length() == 0) {
477 EdkLog
.log(this, EdkLog
.EDK_VERBOSE
, "Warning: " + cmd
[m
] + " hasn't been defined!");
478 getProject().setProperty(cmd
[m
], "");
481 File cmdFile
= new File(cmdPath
+ File
.separatorChar
+ cmdName
);
482 getProject().setProperty(cmd
[m
], cmdFile
.getPath().replaceAll("(\\\\)", "/"));
487 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_FLAGS
;
488 String cmdFlags
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
489 if (cmdFlags
!= null)
491 getProject().setProperty(cmd
[m
] + "_FLAGS", cmdFlags
);
495 getProject().setProperty(cmd
[m
] + "_FLAGS", "");
501 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_EXT
;
502 String extName
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
503 if ( extName
!= null && ! extName
.equalsIgnoreCase("")) {
504 getProject().setProperty(cmd
[m
] + "_EXT", extName
);
506 getProject().setProperty(cmd
[m
] + "_EXT", "");
512 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_FAMILY
;
513 String toolChainFamily
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
514 if (toolChainFamily
!= null) {
515 getProject().setProperty(cmd
[m
] + "_FAMILY", toolChainFamily
);
521 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_SPATH
;
522 String spath
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
524 getProject().setProperty(cmd
[m
] + "_SPATH", spath
.replaceAll("(\\\\)", "/"));
526 getProject().setProperty(cmd
[m
] + "_SPATH", "");
532 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_DPATH
;
533 String dpath
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
535 getProject().setProperty(cmd
[m
] + "_DPATH", dpath
.replaceAll("(\\\\)", "/"));
537 getProject().setProperty(cmd
[m
] + "_DPATH", "");
543 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_LIBPATH
;
544 String libpath
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
545 if (libpath
!= null) {
546 getProject().setProperty(cmd
[m
] + "_LIBPATH", libpath
.replaceAll("(\\\\)", "/"));
548 getProject().setProperty(cmd
[m
] + "_LIBPATH", "");
552 // Set CC_INCLUDEPATH
554 key
[4] = ToolDefinitions
.TOOLS_DEF_ATTRIBUTE_INCLUDEPATH
;
555 String includepath
= GlobalData
.getCommandSetting(key
, fpdModuleId
);
557 getProject().setProperty(cmd
[m
] + "_INCLUDEPATH", includepath
.replaceAll("(\\\\)", "/"));
559 getProject().setProperty(cmd
[m
] + "_INCLUDEPATH", "");
564 public void setMsaFile(File msaFile
) {
565 this.msaFile
= msaFile
;
569 Method is for ANT to initialize MSA file.
571 @param msaFilename MSA file name
573 public void setMsaFile(String msaFilename
) {
574 String moduleDir
= getProject().getProperty("MODULE_DIR");
577 // If is Single Module Build, then use the Base Dir defined in build.xml
579 if (moduleDir
== null) {
580 moduleDir
= getProject().getBaseDir().getPath();
582 msaFile
= new File(moduleDir
+ File
.separatorChar
+ msaFilename
);
585 public void addConfiguredModuleItem(ModuleItem moduleItem
) {
586 PackageIdentification packageId
= new PackageIdentification(moduleItem
.getPackageGuid(), moduleItem
.getPackageVersion());
587 ModuleIdentification moduleId
= new ModuleIdentification(moduleItem
.getModuleGuid(), moduleItem
.getModuleVersion());
588 moduleId
.setPackage(packageId
);
589 this.moduleId
= moduleId
;
597 public void addProperty(Property p
) {
598 properties
.addElement(p
);
601 public void setType(String type
) {
605 private void applyBuild(String buildTarget
, String buildTagname
, FpdModuleIdentification fpdModuleId
) throws EdkException
{
607 // Call AutoGen to generate AutoGen.c and AutoGen.h
609 AutoGen autogen
= new AutoGen(getProject().getProperty("FV_DIR"), getProject().getProperty("DEST_DIR_DEBUG"), fpdModuleId
.getModule(),fpdModuleId
.getArch(), saq
, parentId
);
610 autogen
.genAutogen();
613 // Get compiler flags
616 getCompilerFlags(buildTarget
, buildTagname
, fpdModuleId
);
618 catch (EdkException ee
) {
619 throw new BuildException(ee
.getMessage());
625 ModuleIdentification
[] libinstances
= saq
.getLibraryInstance(fpdModuleId
.getArch());
626 String propertyLibs
= "";
627 for (int i
= 0; i
< libinstances
.length
; i
++) {
628 propertyLibs
+= getProject().getProperty("BIN_DIR") + File
.separatorChar
+ libinstances
[i
].getName() + ".lib" + " ";
630 getProject().setProperty("LIBS", propertyLibs
.replaceAll("(\\\\)", "/"));
633 // Get all includepath and set to INCLUDE_PATHS
635 String
[] includes
= prepareIncludePaths(fpdModuleId
);
638 // if it is CUSTOM_BUILD
639 // then call the exist BaseName_build.xml directly.
641 if (moduleId
.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
642 EdkLog
.log(this, "Call user-defined " + moduleId
.getName() + "_build.xml");
644 String antFilename
= getProject().getProperty("MODULE_DIR") + File
.separatorChar
+ moduleId
.getName() + "_build.xml";
645 antCall(antFilename
, null);
651 // Generate ${BASE_NAME}_build.xml
654 String ffsKeyword
= saq
.getModuleFfsKeyword();
655 ModuleBuildFileGenerator fileGenerator
= new ModuleBuildFileGenerator(getProject(), ffsKeyword
, fpdModuleId
, includes
, saq
);
656 String buildFilename
= getProject().getProperty("DEST_DIR_OUTPUT") + File
.separatorChar
+ moduleId
.getName() + "_build.xml";
657 fileGenerator
.genBuildFile(buildFilename
);
660 // Ant call ${BASE_NAME}_build.xml
662 String antFilename
= getProject().getProperty("DEST_DIR_OUTPUT") + File
.separatorChar
+ moduleId
.getName() + "_build.xml";
663 antCall(antFilename
, null);
666 private void applyClean(FpdModuleIdentification fpdModuleId
){
668 // if it is CUSTOM_BUILD
669 // then call the exist BaseName_build.xml directly.
671 if (moduleId
.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
672 EdkLog
.log(this, "Calling user-defined " + moduleId
.getName() + "_build.xml");
674 String antFilename
= getProject().getProperty("MODULE_DIR") + File
.separatorChar
+ moduleId
.getName() + "_build.xml";
675 antCall(antFilename
, "clean");
680 String antFilename
= getProject().getProperty("DEST_DIR_OUTPUT") + File
.separatorChar
+ moduleId
.getName() + "_build.xml";
681 antCall(antFilename
, "clean");
684 private void applyCleanall(FpdModuleIdentification fpdModuleId
){
686 // if it is CUSTOM_BUILD
687 // then call the exist BaseName_build.xml directly.
689 if (moduleId
.getModuleType().equalsIgnoreCase("USER_DEFINED")) {
690 EdkLog
.log(this, "Calling user-defined " + moduleId
.getName() + "_build.xml");
692 String antFilename
= getProject().getProperty("MODULE_DIR") + File
.separatorChar
+ moduleId
.getName() + "_build.xml";
693 antCall(antFilename
, "cleanall");
698 String antFilename
= getProject().getProperty("DEST_DIR_OUTPUT") + File
.separatorChar
+ moduleId
.getName() + "_build.xml";
699 antCall(antFilename
, "cleanall");
702 private void antCall(String antFilename
, String target
) {
704 ant
.setProject(getProject());
705 ant
.setAntfile(antFilename
);
706 if (target
!= null) {
707 ant
.setTarget(target
);
709 ant
.setInheritAll(true);
714 public void setSingleModuleBuild(boolean isSingleModuleBuild
) {
715 this.isSingleModuleBuild
= isSingleModuleBuild
;
718 private String
[] prepareIncludePaths(FpdModuleIdentification fpdModuleId
) throws EdkException
{
720 // Prepare the includes: PackageDependencies and Output debug direactory
722 Set
<String
> includes
= new LinkedHashSet
<String
>();
723 String arch
= fpdModuleId
.getArch();
728 includes
.add("${WORKSPACE_DIR}" + File
.separatorChar
);
733 includes
.add("${MODULE_DIR}");
734 includes
.add("${MODULE_DIR}" + File
.separatorChar
+ archDir(arch
));
737 // Packages in PackageDenpendencies
739 PackageIdentification
[] packageDependencies
= saq
.getDependencePkg(fpdModuleId
.getArch());
740 for (int i
= 0; i
< packageDependencies
.length
; i
++) {
741 GlobalData
.refreshPackageIdentification(packageDependencies
[i
]);
742 File packageFile
= packageDependencies
[i
].getSpdFile();
743 includes
.add(packageFile
.getParent() + File
.separatorChar
+ "Include");
744 includes
.add(packageFile
.getParent() + File
.separatorChar
+ "Include" + File
.separatorChar
+ archDir(arch
));
748 // All Dependency Library Instance's PackageDependencies
750 ModuleIdentification
[] libinstances
= saq
.getLibraryInstance(fpdModuleId
.getArch());
751 for (int i
= 0; i
< libinstances
.length
; i
++) {
752 saq
.push(GlobalData
.getDoc(libinstances
[i
], fpdModuleId
.getArch()));
753 PackageIdentification
[] libraryPackageDependencies
= saq
.getDependencePkg(fpdModuleId
.getArch());
754 for (int j
= 0; j
< libraryPackageDependencies
.length
; j
++) {
755 GlobalData
.refreshPackageIdentification(libraryPackageDependencies
[j
]);
756 File packageFile
= libraryPackageDependencies
[j
].getSpdFile();
757 includes
.add(packageFile
.getParent() + File
.separatorChar
+ "Include");
758 includes
.add(packageFile
.getParent() + File
.separatorChar
+ "Include" + File
.separatorChar
+ archDir(arch
));
765 // The package which the module belongs to
767 includes
.add(fpdModuleId
.getModule().getPackage().getPackageDir() + File
.separatorChar
+ "Include");
768 includes
.add(fpdModuleId
.getModule().getPackage().getPackageDir() + File
.separatorChar
+ "Include" + File
.separatorChar
+ archDir(arch
));
771 // Debug files output directory
773 includes
.add("${DEST_DIR_DEBUG}");
776 // set to INCLUDE_PATHS property
778 Iterator
<String
> iter
= includes
.iterator();
779 StringBuffer includePaths
= new StringBuffer();
780 while (iter
.hasNext()) {
781 includePaths
.append(iter
.next());
782 includePaths
.append("; ");
784 getProject().setProperty("INCLUDE_PATHS", getProject().replaceProperties(includePaths
.toString()).replaceAll("(\\\\)", "/"));
786 return includes
.toArray(new String
[includes
.size()]);
790 Return the name of the directory that corresponds to the architecture.
791 This is a translation from the XML Schema tag to a directory that
792 corresponds to our directory name coding convention.
795 private String
archDir(String arch
) {
796 return arch
.replaceFirst("X64", "x64")
797 .replaceFirst("IPF", "Ipf")
798 .replaceFirst("IA32", "Ia32")
799 .replaceFirst("ARM", "Arm")
800 .replaceFirst("EBC", "Ebc");
804 public void setExternalProperties(Vector
<Property
> v
) {