Tools/Java/Source/GenBuild/org/tianocore/build/FfsProcess.java

   1 /** @file
   2   File is FfsProcess class which is used to get the corresponding FFS layout
   3   information for driver module.
   4
   5 Copyright (c) 2006, Intel Corporation
   6 All rights reserved. This program and the accompanying materials
   7 are licensed and made available under the terms and conditions of the BSD License
   8 which accompanies this distribution.  The full text of the license may be found at
   9 http://opensource.org/licenses/bsd-license.php
  10
  11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13 **/
  14 package org.tianocore.build;
  15
  16 import java.io.File;
  17 import java.util.Vector;
  18
  19 import javax.xml.namespace.QName;
  20
  21 import org.apache.tools.ant.BuildException;
  22 import org.apache.tools.ant.Project;
  23 import org.apache.xmlbeans.XmlCursor;
  24 import org.tianocore.BuildOptionsDocument;
  25 import org.tianocore.build.global.GlobalData;
  26 import org.tianocore.build.global.SurfaceAreaQuery;
  27 import org.tianocore.build.id.FpdModuleIdentification;
  28 import org.tianocore.common.definitions.EdkDefinitions;
  29 import org.tianocore.common.logger.EdkLog;
  30 import org.w3c.dom.Document;
  31 import org.w3c.dom.Element;
  32
  33 /**
  34   <p><code>FfsProcess</code> is a class to find the corresponding FFS layout. </p>
  35
  36   <p>The FFS Layout is like following: </p>
  37
  38   <pre>
  39     &lt;Ffs type="APPLICATION"&gt;
  40       &lt;Attribute Name="FFS_FILETYPE" Value="EFI_FV_FILETYPE_APPLICATION" /&gt;
  41       &lt;Attribute Name="FFS_ATTRIB_CHECKSUM" Value="TRUE" /&gt;
  42       &lt;Sections EncapsulationType="Compress"&gt;
  43         &lt;Sections EncapsulationType="Guid-Defined"&gt;
  44           &lt;Section SectionType="EFI_SECTION_PE32" /&gt;
  45           &lt;Section SectionType="EFI_SECTION_USER_INTERFACE" /&gt;
  46           &lt;Section SectionType="EFI_SECTION_VERSION" /&gt;
  47         &lt;/Sections&gt;
  48       &lt;/Sections&gt;
  49     &lt;/Ffs&gt;
  50   </pre>
  51
  52   @since GenBuild 1.0
  53 **/
  54 public class FfsProcess {
  55
  56     private BuildOptionsDocument.BuildOptions.Ffs ffsXmlObject;
  57
  58     ///
  59     /// ANT script to call GenFfs
  60     ///
  61     private Element ffsNode = null;
  62
  63     ///
  64     /// Module base name
  65     ///
  66     private String basename;
  67
  68     ///
  69     /// Sections type: normal
  70     ///
  71     private static int MODE_NONE = 0;
  72
  73     ///
  74     /// Sections type: compress
  75     ///
  76     private static int MODE_COMPRESS = 1;
  77
  78     ///
  79     /// Sections type: guid-define
  80     ///
  81     private static int MODE_GUID_DEFINED = 2;
  82
  83     ///
  84     /// mapping from section type to section output file extension
  85     ///
  86     public static final String[][] sectionExt = EdkDefinitions.SectionTypeExtensions;
  87
  88     /**
  89       search in the type, if componentType is listed in type, return true;
  90       otherwise return false.
  91
  92       @param type a list supported component type separated by comma
  93       @param componentType current module component type
  94       @return whether componentType is one of type
  95     **/
  96     private boolean isMatch(String type, String componentType) {
  97         String[] items = type.split("[ \t]*,[ \t]*");
  98         for (int i = 0; i < items.length; i++) {
  99             if (items[i].equalsIgnoreCase(componentType)) {
 100                 return true;
 101             }
 102         }
 103         return false;
 104     }
 105
 106     /**
 107       Find the corresponding FFS layout in <code>FPD</code>.
 108
 109       @param buildType Current module's component type
 110       @param project Ant project
 111       @return whether find the corresponding FFS layout
 112       @throws BuildException
 113               If can't find FFS Layout in FPD.
 114     **/
 115     public boolean initSections(String buildType, Project project, FpdModuleIdentification fpdModuleId) throws BuildException {
 116         //
 117         // Try to find Ffs layout from FPD file
 118         //
 119         SurfaceAreaQuery saq = new SurfaceAreaQuery(GlobalData.getFpdBuildOptionsMap());
 120         BuildOptionsDocument.BuildOptions.Ffs[] ffsArray = saq.getFpdFfs();
 121         for (int i = 0; i < ffsArray.length; i++) {
 122             if (isMatch(ffsArray[i].getFfsKey(), buildType)) {
 123                 ffsXmlObject = ffsArray[i];
 124                 return true;
 125             }
 126         }
 127
 128         //
 129         // If FfsFormatKey is not null, report exception and fail build
 130         // Otherwise report warning message
 131         //
 132         if (buildType == null) {
 133             EdkLog.log(EdkLog.EDK_WARNING, "Warning: this module doesn't specify a FfsFormatKey. ");
 134         } else {
 135             throw new BuildException("Can't find the FfsFormatKey [" + buildType + "] attribute in the FPD file!");
 136         }
 137
 138         return false;
 139     }
 140
 141     /**
 142       Recursive parse the FFS layout. Find out all section type here used.
 143
 144       @param document BaseName_build.xml Xml document
 145       @param basename Module's base name
 146       @param guid Module's GUID
 147       @param targetFilename Module's final file name (GUID-BaseName.APP)
 148       @return List of section type
 149     **/
 150     public String[] getGenSectionElements(Document document, String basename, String guid, String targetFilename) {
 151         this.basename = basename;
 152         if (ffsXmlObject == null) {
 153             return new String[0];
 154         }
 155         Vector<String> sectionList = new Vector<String>();
 156         XmlCursor cursor = null;
 157
 158         cursor = ffsXmlObject.newCursor();
 159
 160         int mode = MODE_NONE;
 161         Element genffsfileEle = document.createElement("genffsfile");
 162         genffsfileEle.setAttribute("outputDir", "${BIN_DIR}");
 163         genffsfileEle.setAttribute("moduleType", "${MODULE_TYPE}");
 164         genffsfileEle.setAttribute("BaseName", basename);
 165         genffsfileEle.setAttribute("fileGuid", guid);
 166
 167         if (cursor.toFirstChild()) {
 168             do {
 169                 if (cursor.getName().getLocalPart().equalsIgnoreCase("Attribute")) {
 170                     String name = cursor.getAttributeText(new QName("Name"));
 171                     String value = cursor.getAttributeText(new QName("Value"));
 172                     genffsfileEle.setAttribute(changeAttributeName(name), value);
 173                 } else if (cursor.getName().getLocalPart().equalsIgnoreCase("Section")) {
 174                     cursor.push();
 175                     dealSection(mode, document, genffsfileEle, cursor, sectionList);
 176                     cursor.pop();
 177                 } else if (cursor.getName().getLocalPart().equalsIgnoreCase("Sections")) {
 178                     cursor.push();
 179                     dealSections(mode, document, genffsfileEle, cursor, sectionList);
 180                     cursor.pop();
 181                 }
 182             } while (cursor.toNextSibling());
 183         }
 184         //
 185         // Check dependency
 186         //
 187         Element outofdateEle = document.createElement("OnDependency");
 188         Element sourceEle = document.createElement("sourcefiles");
 189         Vector<String> sections = new Vector<String>();
 190         for (int i = 0; i < sectionList.size(); i++) {
 191             String section = (String) sectionList.get(i);
 192             if (isSectionType(section)) {
 193                 sections.addElement(section);
 194             }
 195             Element pathEle = document.createElement("file");
 196             pathEle.setAttribute("name", getSectionFile(basename, section));
 197             sourceEle.appendChild(pathEle);
 198         }
 199         String[] result = sections.toArray(new String[sections.size()]);
 200
 201         outofdateEle.appendChild(sourceEle);
 202         Element targetEle = document.createElement("targetfiles");
 203         Element fileEle = document.createElement("file");
 204         fileEle.setAttribute("name", "${BIN_DIR}" + File.separatorChar + targetFilename);
 205         targetEle.appendChild(fileEle);
 206         outofdateEle.appendChild(targetEle);
 207         Element sequentialEle = document.createElement("sequential");
 208         sequentialEle.appendChild(genffsfileEle);
 209         outofdateEle.appendChild(sequentialEle);
 210         ffsNode = outofdateEle;
 211         return result;
 212     }
 213
 214     /**
 215       Change the attribute name. For example:
 216
 217       <pre>
 218           Before change: FFS_ATTRIB_CHECKSUM
 219           After  change: ffsATTRIBCHECKSUM
 220       </pre>
 221
 222       @param name Original attribute name
 223       @return Changed attribute name
 224     **/
 225     private String changeAttributeName(String name) {
 226         String[] strs = name.split("_");
 227         String str = strs[0].toLowerCase();
 228         for (int j = 1; j < strs.length; j++) {
 229             str += strs[j];
 230         }
 231         return str;
 232     }
 233
 234     /**
 235       Recursively deal with Sections. If sections does not specify a type, then omit it.
 236
 237       @param mode Current node mode (MODE_NONE | MODE_COMPREE | MODE_GUID_DEFINED)
 238       @param doc Xml Document
 239       @param root Root Node
 240       @param cursor Current FFS layout cursor
 241       @param list List of section type here used
 242     **/
 243     private void dealSections(int mode, Document doc, Element root, XmlCursor cursor, Vector<String> list) {
 244         String type = cursor.getAttributeText(new QName("EncapsulationType"));
 245         String toolName = cursor.getAttributeText(new QName("ToolName"));
 246         String sectType = cursor.getAttributeText(new QName("SectionType"));
 247         if (type == null && sectType == null) {
 248             if (cursor.toFirstChild()) {
 249                 do {
 250                     if (cursor.getName().getLocalPart().equalsIgnoreCase("Section")) {
 251                         cursor.push();
 252                         dealSection(mode, doc, root, cursor, list);
 253                         cursor.pop();
 254                     } else if (cursor.getName().getLocalPart().equalsIgnoreCase("Sections")) {
 255                         cursor.push();
 256                         dealSections(mode, doc, root, cursor, list);
 257                         cursor.pop();
 258                     }
 259                 } while (cursor.toNextSibling());
 260             }
 261             return;
 262         }
 263         Element ele;
 264         Element toolEle = null;
 265         if (type.equalsIgnoreCase("COMPRESS") && (toolName == null || toolName.equalsIgnoreCase(""))) {
 266             mode = MODE_COMPRESS;
 267             //
 268             // <gensection sectiontype="EFI_SECTION_COMPRESSION">
 269             //
 270             ele = doc.createElement("gensection");
 271             ele.setAttribute("sectionType", "EFI_SECTION_COMPRESSION");
 272
 273         } else {
 274             mode = MODE_GUID_DEFINED;
 275             //
 276             // <gensection sectiontype="EFI_SECTION_GUID_DEFINED">
 277             //
 278             ele = doc.createElement("gensection");
 279             if (type != null) {
 280                 if (type.equalsIgnoreCase("COMPRESS")) {
 281                     ele.setAttribute("sectionType", "EFI_SECTION_COMPRESSION");
 282                 }else {
 283                     ele.setAttribute("sectiontype", "EFI_SECTION_GUID_DEFINED");
 284                 }
 285
 286             } else {
 287                 ele.setAttribute("sectiontype", sectType);
 288             }
 289             //
 290             // <tool toolName="${OEMTOOLPATH}\toolname"
 291             // outputPath = "${DEST_DIR_OUTPUT}">
 292             //
 293             toolEle = doc.createElement("tool");
 294             if (toolName == null || toolName.equalsIgnoreCase("")) {
 295                 toolEle.setAttribute("toolName", "${WORKSPACE_DIR}" + File.separatorChar + "Tools" + File.separatorChar + "bin"
 296                                          + File.separatorChar + "GenCRC32Section");
 297             }else{
 298                 File toolExe = new File(toolName);
 299                 //
 300                 //  If <Tool> element exist, add sub element under <tool> .
 301                 //
 302                 if (toolExe.isAbsolute()) {
 303                     toolEle.setAttribute("toolName", toolName);
 304                 } else {
 305                     toolEle.setAttribute("toolName", "${WORKSPACE_DIR}" + File.separatorChar + "Tools" + File.separatorChar + "bin"
 306                                          + File.separatorChar + toolName);
 307                 }
 308             }
 309
 310             toolEle.setAttribute("outputPath", "${DEST_DIR_OUTPUT}");
 311             ele.appendChild(toolEle);
 312         }
 313         if (cursor.toFirstChild()) {
 314             do {
 315                 if (cursor.getName().getLocalPart().equalsIgnoreCase("Section")) {
 316                     cursor.push();
 317                     if (toolEle == null) {
 318                         dealSection(mode, doc, ele, cursor, list);
 319                     } else {
 320                         dealSection(mode, doc, toolEle, cursor, list);
 321                     }
 322
 323                     cursor.pop();
 324                 } else if (cursor.getName().getLocalPart().equalsIgnoreCase("Sections")) {
 325                     cursor.push();
 326                     if (toolEle == null) {
 327                         dealSections(mode, doc, ele, cursor, list);
 328                     } else {
 329                         dealSections(mode, doc, toolEle, cursor, list);
 330                     }
 331
 332                     cursor.pop();
 333                 }
 334             } while (cursor.toNextSibling());
 335         }
 336         root.appendChild(ele);
 337     }
 338
 339     /**
 340       Recursively deal with section.
 341
 342       @param mode Current node mode (MODE_NONE | MODE_COMPREE | MODE_GUID_DEFINED)
 343       @param doc Xml Document
 344       @param root Root Node
 345       @param cursor Current FFS layout cursor
 346       @param list List of section type here used
 347     **/
 348     private void dealSection(int mode, Document doc, Element root, XmlCursor cursor, Vector<String> list) {
 349         String type = cursor.getAttributeText(new QName("SectionType"));
 350         String alignment = cursor.getAttributeText(new QName("Alignment"));
 351
 352         //
 353         // Judge if file is specified? Yes, just use the file, else call Build Macro
 354         // If fileName is null, means without FileNames specify in FPD file
 355         //
 356         String fileName = null;
 357         cursor.push();
 358         if (cursor.toFirstChild()) {
 359             do {
 360                 if (cursor.getName().getLocalPart().equalsIgnoreCase("Filenames")) {
 361                     cursor.push();
 362                     if (cursor.toFirstChild()) {
 363                         do {
 364                             if (cursor.getName().getLocalPart().equalsIgnoreCase("Filename")) {
 365                                 fileName = cursor.getTextValue();
 366                             }
 367                         } while (cursor.toNextSibling());
 368                     }
 369                     cursor.pop();
 370                 }
 371             } while (cursor.toNextSibling());
 372         }
 373
 374         cursor.pop();
 375
 376         if (fileName == null) {
 377             list.addElement(type);
 378         } else {
 379             list.addElement(fileName);
 380         }
 381
 382         if (mode == MODE_GUID_DEFINED) {
 383             //
 384             // <input file="${DEST_DIR_OUTPUT}\Bds.pe32"/>
 385             //
 386             Element ele = doc.createElement("input");
 387             if (fileName == null) {
 388                 ele.setAttribute("file", getSectionFile(basename, type));
 389             } else {
 390                 ele.setAttribute("file", fileName);
 391             }
 392             root.appendChild(ele);
 393         } else {
 394             //
 395             // <sectFile fileName= "..."/>
 396             //
 397             Element ele = doc.createElement("sectFile");
 398             if (fileName == null) {
 399                 ele.setAttribute("fileName", getSectionFile(basename, type));
 400             } else {
 401                 ele.setAttribute("fileName", fileName);
 402             }
 403             if (alignment != null) {
 404                 ele.setAttribute("Alignment", alignment);
 405             }
 406             root.appendChild(ele);
 407         }
 408     }
 409
 410     /**
 411       Get the corresponding section file suffix.
 412
 413       @param type Section type
 414       @return Corresponding section file extension
 415     **/
 416     private String getSectionFile(String basename, String type) {
 417         for (int i = 0; i < sectionExt.length; i++) {
 418             if (sectionExt[i][0].equalsIgnoreCase(type)) {
 419                 return "${DEST_DIR_OUTPUT}" + File.separatorChar + basename + sectionExt[i][1];
 420             }
 421         }
 422         return type;
 423     }
 424
 425     private boolean isSectionType(String type) {
 426         for (int i = 0; i < sectionExt.length; i++) {
 427             if (sectionExt[i][0].equalsIgnoreCase(type)) {
 428                 return true;
 429             }
 430         }
 431         return false;
 432     }
 433
 434     /**
 435       Return the ANT script to call GenFfs Tool.
 436
 437       @return ANT script to call GenFfs Tool
 438     **/
 439     public Element getFfsNode() {
 440         return ffsNode;
 441     }
 442 }