Tools/Source/GenBuild/org/tianocore/build/FileProcess.java

   1 /** @file
   2   File is FileProcess class which is used to generate ANT script to build
   3   source files.
   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.Set;
  18
  19 import org.apache.tools.ant.BuildException;
  20 import org.apache.tools.ant.Project;
  21 import org.w3c.dom.Document;
  22 import org.w3c.dom.Element;
  23 import org.w3c.dom.Node;
  24
  25 /**
  26   <p><code>FileProcess</code> is class to generate ANT script to build source
  27   files.</p>
  28
  29   <p>If file does not specify file type, <code>FileProcess</code> will judge
  30   by its extension. Following is the current supported extensions. </p>
  31
  32   <pre>
  33  Source File Suffix     File Type       Description
  34     .h                   CHeader      C header file
  35     .c                   CCode        C source file
  36     .inc                 ASMHeader    Assembly header file
  37     .asm                 ASM          Assembly source file, usually for IA32 and X64 Arch and MSFT tool chain
  38     .S                   ASM          Assembly source file, usually for IPF Arch
  39     .s                   ASM          Assembly source file, usually for IA32 and X64 Arch and GCC tool chain
  40     .uni                 UNI          Unicode file
  41     .vfr                 VFR          Visual Forms Representation File
  42     .fv                  FV           Firmware Volume
  43     .SEC                 FFS          Firmware File System file
  44     .PEI                 FFS          Firmware File System file
  45     .DXE                 FFS          Firmware File System file
  46     .APP                 FFS          Firmware File System file
  47     .FVI                 FFS          Firmware File System file
  48     .FFS                 FFS          Firmware File System file
  49     .bmp                 BMP          Graphic File
  50     .i                   PPCode       IPF PreProcessor Code
  51   </pre>
  52
  53   @since GenBuild 1.0
  54 **/
  55 public class FileProcess {
  56     ///
  57     ///  The mapping information about source suffix, result suffix, file type.
  58     ///
  59     public final String[][] fileTypes = { {".h", "", "CHeader" },
  60                                           {".c", "", "CCode" },
  61                                           {".inc", "", "ASMHeader" },
  62                                           {".asm", "", "ASM" },
  63                                           {".S", "", "ASM" },
  64                                           {".s", "", "ASM" },
  65                                           {".uni", "", "UNI" },
  66                                           {".vfr", "", "VFR" },
  67                                           {".Vfr", "", "VFR" },
  68                                           {".dxs", "", "DPX"},
  69                                           {".fv", "", "FV" },
  70                                           {".efi", "", "EFI" },
  71                                           {".SEC", "", "FFS" },
  72                                           {".PEI", "", "FFS" },
  73                                           {".DXE", "", "FFS" },
  74                                           {".APP", "", "FFS" },
  75                                           {".FYI", "", "FFS" },
  76                                           {".FFS", "", "FFS" },
  77                                           {".bmp", "", "BMP" },
  78                                           {".i", "", "PPCode"}};
  79     ///
  80     /// Current ANT context.
  81     ///
  82     private Project project;
  83
  84     ///
  85     /// Current module's include pathes
  86     ///
  87     private Set<String> includes;
  88
  89     ///
  90     /// Xml Document.
  91     ///
  92     private Document document;
  93
  94     ///
  95     /// The flag to ensure all unicode files build before others.
  96     ///
  97     private boolean unicodeFirst = true;
  98
  99     ///
 100     /// The flag present whether current module contains Unicode files or not.
 101     ///
 102     private boolean unicodeExist = false;
 103
 104     /**
 105       Initialize the project, includes, sourceFiles, document members.
 106
 107       @param project ANT project
 108       @param includes Module include pathes
 109       @param sourceFiles Modules source files
 110       @param document XML document
 111     **/
 112     public void init(Project project, Set<String> includes, Document document) {
 113         this.document = document;
 114         this.includes = includes;
 115         this.project = project;
 116     }
 117
 118     /**
 119       Parse file without file type.
 120
 121       @param filename Source file name
 122       @param root Root node
 123       @param unicodeFirst whether build Unicode file firstly or not
 124     **/
 125     public synchronized void parseFile(String filename, Node root, boolean unicodeFirst) {
 126         this.unicodeFirst = unicodeFirst;
 127         parseFile(filename, root);
 128     }
 129
 130     /**
 131       Get whether current module contains Unicode files or not.
 132
 133       @return Whether current module contains Unicode files or not
 134     **/
 135     public boolean isUnicodeExist() {
 136         return unicodeExist;
 137     }
 138
 139     /**
 140       Parse file.
 141
 142       @param filename Source file name
 143       @param filetype Source file type
 144       @param root Root node
 145       @param unicodeFirst whether build Unicode file firstly or not
 146     **/
 147     public synchronized void parseFile(String filename, String filetype, Node root, boolean unicodeFirst) {
 148         this.unicodeFirst = unicodeFirst;
 149         parseFile(filename, filetype, root);
 150     }
 151
 152     /**
 153       Find out source file's type.
 154
 155       @param filename Source file name
 156       @param root Root node
 157     **/
 158     public synchronized void parseFile(String filename, Node root) throws BuildException {
 159         for (int i = 0; i < fileTypes.length; i++) {
 160             if (filename.endsWith(fileTypes[i][0])) {
 161                 parseFile(filename, fileTypes[i][2], root);
 162                 return ;
 163             }
 164         }
 165     }
 166
 167     /**
 168       Parse file. If flag <code>unicodeFirst</code> is true, then build all
 169       unicode files firstly.
 170
 171       <p>Note that AutoGen.c is processed specially. It's output path is always
 172       <code>${DEST_DIR_OUTPUT}</code>, others are <code>${DEST_DIR_OUTPUT}</code>
 173       and relative to module path. </p>
 174
 175       @param filename Source file name
 176       @param filetype Source file type
 177       @param root Root node
 178     **/
 179     public synchronized void parseFile(String filename, String filetype, Node root) {
 180         if (unicodeFirst) {
 181             if ( ! filetype.equalsIgnoreCase("UNI")){
 182                 return ;
 183             }
 184             unicodeExist= true;
 185         } else {
 186             if (filetype.equalsIgnoreCase("UNI")){
 187                 return ;
 188             }
 189         }
 190
 191         //
 192         // If file is C or ASM header file, skip it
 193         //
 194         if (filetype.equalsIgnoreCase("CHeader") || filetype.equalsIgnoreCase("ASMHeader")) {
 195             return;
 196         }
 197
 198         //
 199         // If file is pre-processor file, skip it
 200         //
 201         if (filetype.equalsIgnoreCase("PPCode")) {
 202             return;
 203         }
 204
 205         //
 206         // If define CC_EXT in tools_def.txt file, the source file with
 207         // different suffix is skipped
 208         //
 209         String toolsDefExtName = project.getProperty(filetype + "_EXT");
 210         if (toolsDefExtName != null) {
 211             String[] exts = toolsDefExtName.split(" ");
 212             for (int i = 0; i < exts.length; i++) {
 213                 if ( ! filename.endsWith(exts[i])) {
 214                     return ;
 215                 }
 216             }
 217         }
 218
 219         String module_path = project.getProperty("MODULE_DIR");
 220         File moduleFile = new File(module_path);
 221         File sourceFile = new File(filename);
 222
 223         //
 224         // If source file is AutoGen.c, then Filepath is .
 225         //
 226         String sourceFilepath = "";
 227         String sourceFilename = "";
 228         String sourceFileext = "";
 229         if (sourceFile.getPath().endsWith("AutoGen.c")) {
 230             sourceFilepath = ".";
 231             sourceFilename = "AutoGen";
 232             sourceFileext = ".c";
 233             filetype = "AUTOGEN";
 234         } else {
 235             // sourceFile.
 236             String str = sourceFile.getPath().substring(moduleFile.getPath().length() + 1);
 237             int index = str.lastIndexOf(File.separatorChar);
 238             sourceFilepath = ".";
 239             if (index > 0) {
 240                 sourceFilepath = str.substring(0, index);
 241                 str = str.substring(index + 1);
 242             }
 243             sourceFilename = str;
 244             index = str.lastIndexOf('.');
 245             if (index > 0) {
 246                 sourceFilename = str.substring(0, index);
 247                 sourceFileext = str.substring(index);
 248             }
 249         }
 250         // <Build_filetype FILEPATH="" FILENAME="" />
 251         Element ele = document.createElement("Build_" + filetype);
 252         ele.setAttribute("FILEPATH", sourceFilepath);
 253         ele.setAttribute("FILENAME", sourceFilename);
 254         ele.setAttribute("FILEEXT", sourceFileext.substring(1));
 255         String[] includePaths = includes.toArray(new String[includes.size()]);
 256         Element includesEle = document.createElement("EXTRA.INC");
 257         for (int i = 0; i < includePaths.length; i++) {
 258             Element includeEle = document.createElement("includepath");
 259             includeEle.setAttribute("path", project.replaceProperties(includePaths[i]));
 260             includesEle.appendChild(includeEle);
 261         }
 262         ele.appendChild(includesEle);
 263         root.appendChild(ele);
 264     }
 265 }