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         boolean flag = false;
 160         for (int i = 0; i < fileTypes.length; i++) {
 161             if (filename.endsWith(fileTypes[i][0])) {
 162                 flag = true;
 163                 parseFile(filename, fileTypes[i][2], root);
 164             }
 165         }
 166         if (!flag) {
 167             throw new BuildException("File [" + filename + "] is not known from its suffix.");
 168         }
 169     }
 170
 171     /**
 172       Parse file. If flag <code>unicodeFirst</code> is true, then build all
 173       unicode files firstly.
 174
 175       <p>Note that AutoGen.c is processed specially. It's output path is always
 176       <code>${DEST_DIR_OUTPUT}</code>, others are <code>${DEST_DIR_OUTPUT}</code>
 177       and relative to module path. </p>
 178
 179       @param filename Source file name
 180       @param filetype Source file type
 181       @param root Root node
 182     **/
 183     public synchronized void parseFile(String filename, String filetype, Node root) {
 184         if (unicodeFirst) {
 185             if ( ! filetype.equalsIgnoreCase("UNI")){
 186                 return ;
 187             }
 188             unicodeExist= true;
 189         } else {
 190             if (filetype.equalsIgnoreCase("UNI")){
 191                 return ;
 192             }
 193         }
 194
 195         //
 196         // If file is C or ASM header file, skip it
 197         //
 198         if (filetype.equalsIgnoreCase("CHeader") || filetype.equalsIgnoreCase("ASMHeader")) {
 199             return;
 200         }
 201
 202         //
 203         // If file is pre-processor file, skip it
 204         //
 205         if (filetype.equalsIgnoreCase("PPCode")) {
 206             return;
 207         }
 208
 209         //
 210         // If define CC_EXT in tools_def.txt file, the source file with
 211         // different suffix is skipped
 212         //
 213         String toolsDefExtName = project.getProperty(filetype + "_EXT");
 214         if (toolsDefExtName != null) {
 215             String[] exts = toolsDefExtName.split(" ");
 216             for (int i = 0; i < exts.length; i++) {
 217                 if ( ! filename.endsWith(exts[i])) {
 218                     return ;
 219                 }
 220             }
 221         }
 222
 223         String module_path = project.getProperty("MODULE_DIR");
 224         File moduleFile = new File(module_path);
 225         File sourceFile = new File(filename);
 226
 227         //
 228         // If source file is AutoGen.c, then Filepath is .
 229         //
 230         String sourceFilepath = "";
 231         String sourceFilename = "";
 232         String sourceFileext = "";
 233         if (sourceFile.getPath().endsWith("AutoGen.c")) {
 234             sourceFilepath = ".";
 235             sourceFilename = "AutoGen";
 236             sourceFileext = ".c";
 237             filetype = "AUTOGEN";
 238         } else {
 239             // sourceFile.
 240             String str = sourceFile.getPath().substring(moduleFile.getPath().length() + 1);
 241             int index = str.lastIndexOf(File.separatorChar);
 242             sourceFilepath = ".";
 243             if (index > 0) {
 244                 sourceFilepath = str.substring(0, index);
 245                 str = str.substring(index + 1);
 246             }
 247             sourceFilename = str;
 248             index = str.lastIndexOf('.');
 249             if (index > 0) {
 250                 sourceFilename = str.substring(0, index);
 251                 sourceFileext = str.substring(index);
 252             }
 253         }
 254         // <Build_filetype FILEPATH="" FILENAME="" />
 255         Element ele = document.createElement("Build_" + filetype);
 256         ele.setAttribute("FILEPATH", sourceFilepath);
 257         ele.setAttribute("FILENAME", sourceFilename);
 258         ele.setAttribute("FILEEXT", sourceFileext.substring(1));
 259         String[] includePaths = includes.toArray(new String[includes.size()]);
 260         Element includesEle = document.createElement("EXTRA.INC");
 261         for (int i = 0; i < includePaths.length; i++) {
 262             Element includeEle = document.createElement("includepath");
 263             includeEle.setAttribute("path", includePaths[i]);
 264             includesEle.appendChild(includeEle);
 265         }
 266         ele.appendChild(includesEle);
 267         root.appendChild(ele);
 268     }
 269 }