Tools/Source/MigrationTools/org/tianocore/migration/ModuleReader.java

   1 /** @file
   2
   3  Copyright (c) 2006, Intel Corporation
   4  All rights reserved. This program and the accompanying materials
   5  are licensed and made available under the terms and conditions of the BSD License
   6  which accompanies this distribution.  The full text of the license may be found at
   7  http://opensource.org/licenses/bsd-license.php
   8
   9  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12  **/
  13 package org.tianocore.migration;
  14
  15 import java.io.*;
  16 import java.util.*;
  17 import java.util.regex.*;
  18
  19 import org.tianocore.*;
  20
  21 public final class ModuleReader {
  22         private static ModuleInfo mi;
  23
  24         private static final Pattern ptninfequation = Pattern.compile("([^\\s]*)\\s*=\\s*([^\\s]*)");
  25         private static final Pattern ptnsection = Pattern.compile("\\[([^\\[\\]]*)\\]([^\\[\\]]*)\\n", Pattern.MULTILINE);
  26         private static final Pattern ptnfilename = Pattern.compile("[^\\s]+");
  27
  28         public static final void ModuleScan(ModuleInfo m) throws Exception {
  29                 mi = m;
  30
  31                 Common.toDoAll(mi.modulepath, ModuleInfo.class.getMethod("enroll", String.class), mi, null, Common.FILE);
  32
  33                 String filename = null;
  34                 if (mi.msaorinf.isEmpty()) {
  35                         ModuleInfo.ui.println("No INF nor MSA file found!");
  36                         System.exit(0);
  37                 } else {
  38                         if (mi.msaorinf.size() == 1) {
  39                                 filename = (String)mi.msaorinf.toArray()[0];
  40                         } else {
  41                                 filename = ModuleInfo.ui.choose("Found .inf or .msa file for module\n" + mi.modulepath + "\nChoose one Please", mi.msaorinf.toArray());
  42                         }
  43                 }
  44                 if (filename.contains(".inf")) {
  45                         readInf(filename);
  46                 } else if (filename.contains(".msa")) {
  47                         readMsa(filename);
  48                 }
  49
  50                 CommentOutNonLocalHFile();
  51                 parsePreProcessedSourceCode();
  52
  53         }
  54
  55         private static final void readMsa(String name) throws Exception {
  56                 ModuleSurfaceAreaDocument msadoc = ModuleSurfaceAreaDocument.Factory.parse(new File(mi.modulepath + File.separator + name));
  57                 ModuleSurfaceAreaDocument.ModuleSurfaceArea msa = msadoc.getModuleSurfaceArea();
  58                 MsaHeaderDocument.MsaHeader msaheader = msa.getMsaHeader();
  59
  60                 mi.modulename = msaheader.getModuleName();
  61                 mi.guidvalue = msaheader.getGuidValue();
  62                 mi.moduletype = msaheader.getModuleType().toString();           // ???
  63
  64                 SourceFilesDocument.SourceFiles sourcefiles = msa.getSourceFiles();
  65
  66                 String temp;
  67                 Iterator<FilenameDocument.Filename> li = sourcefiles.getFilenameList().iterator();
  68                 while (li.hasNext()) {
  69                         if (!mi.localmodulesources.contains(temp = li.next().toString())) {
  70                                 System.out.println("Source File Missing! : " + temp);
  71                         }
  72                 }
  73         }
  74
  75         private static final void readInf(String name) throws Exception {
  76                 System.out.println("\nParsing INF file: " + name);
  77                 String wholeline;
  78                 Matcher mtrinfequation;
  79                 Matcher mtrsection;
  80                 Matcher mtrfilename;
  81
  82                 wholeline = Common.file2string(mi.modulepath + File.separator + name);
  83                 mtrsection = ptnsection.matcher(wholeline);
  84                 while (mtrsection.find()) {
  85                         if (mtrsection.group(1).matches("defines")) {
  86                                 mtrinfequation = ptninfequation.matcher(mtrsection.group(2));
  87                                 while (mtrinfequation.find()) {
  88                                         if (mtrinfequation.group(1).matches("BASE_NAME")) {
  89                                                 mi.modulename = mtrinfequation.group(2);
  90                                         }
  91                                         if (mtrinfequation.group(1).matches("FILE_GUID")) {
  92                                                 mi.guidvalue = mtrinfequation.group(2);
  93                                         }
  94                                         if (mtrinfequation.group(1).matches("COMPONENT_TYPE")) {
  95                                                 mi.moduletype = mtrinfequation.group(2);
  96                                         }
  97                                 }
  98                         }
  99                         if (mtrsection.group(1).matches("nmake.common")) {
 100                                 mtrinfequation = ptninfequation.matcher(mtrsection.group(2));
 101                                 while (mtrinfequation.find()) {
 102                                         if (mtrinfequation.group(1).matches("IMAGE_ENTRY_POINT")) {
 103                                                 mi.entrypoint = mtrinfequation.group(2);
 104                                         }
 105                                         if (mtrinfequation.group(1).matches("DPX_SOURCE")) {
 106                                                 if (!mi.localmodulesources.contains(mtrinfequation.group(2))) {
 107                                                         ModuleInfo.ui.println("DPX File Missing! : " + mtrinfequation.group(2));
 108                                                 }
 109                                         }
 110                                 }
 111                         }
 112                         if (mtrsection.group(1).contains("sources.")) {
 113                                 mtrfilename = ptnfilename.matcher(mtrsection.group(2));
 114                                 while (mtrfilename.find()) {
 115                                         if (!mi.localmodulesources.contains(mtrfilename.group())) {
 116                                                 ModuleInfo.ui.println("Source File Missing! : " + mtrfilename.group());
 117                                         }
 118                                 }
 119                         }
 120                 }
 121         }
 122
 123         // add '//' to all non-local include lines
 124         private static final void CommentOutNonLocalHFile() throws IOException {
 125                 BufferedReader rd;
 126                 String line;
 127                 String curFile;
 128                 PrintWriter outfile;
 129
 130                 Pattern ptninclude = Pattern.compile("[\"<](.*[.]h)[\">]");
 131                 Matcher mtrinclude;
 132
 133                 Iterator<String> ii = mi.localmodulesources.iterator();
 134                 while ( ii.hasNext() ) {
 135                         curFile = ii.next();
 136                         rd = new BufferedReader(new FileReader(mi.modulepath + File.separator + curFile));
 137                         Common.ensureDir(mi.modulepath + File.separator + "temp" + File.separator + curFile);
 138                         outfile = new PrintWriter(new BufferedWriter(new FileWriter(mi.modulepath + File.separator + "temp" + File.separator + curFile)));
 139                         while ((line = rd.readLine()) != null) {
 140                                 if (line.contains("#include")) {
 141                                         mtrinclude = ptninclude.matcher(line);
 142                                         if (mtrinclude.find() && mi.localmodulesources.contains(mtrinclude.group(1))) {
 143                                         } else {
 144                                                 line = ModuleInfo.migrationcomment + line;
 145                                         }
 146                                 }
 147                                 outfile.append(line + '\n');
 148                         }
 149                         outfile.flush();
 150                         outfile.close();
 151                 }
 152         }
 153
 154         private static final void parsePreProcessedSourceCode() throws Exception {
 155                 //Cl cl = new Cl(modulepath);
 156                 //cl.execute("Fat.c");
 157                 //cl.generateAll(preprocessedccodes);
 158                 //
 159                 //System.out.println("Note!!!! The CL is not implemented now , pls do it manually!!! RUN :");
 160                 //System.out.println("cl " + modulepath + "\\temp\\*.c" + " -P");
 161                 //String[] list = new File(modulepath + File.separator + "temp").list();        // without CL , add
 162                 BufferedReader rd = null;
 163                 String ifile = null;
 164                 String line = null;
 165                 String temp = null;
 166
 167                 Iterator<String> ii = mi.localmodulesources.iterator();
 168                 while (ii.hasNext()) {
 169                         temp = ii.next();
 170                         if (temp.contains(".c")) {
 171                                 mi.preprocessedccodes.add(temp);
 172                         }
 173                 }
 174
 175                 ii = mi.preprocessedccodes.iterator();
 176
 177                 Pattern patefifuncc = Pattern.compile("g?(BS|RT)\\s*->\\s*([a-zA-Z_]\\w*)",Pattern.MULTILINE);
 178                 Pattern patentrypoint = Pattern.compile("EFI_([A-Z]*)_ENTRY_POINT\\s*\\(([^\\(\\)]*)\\)",Pattern.MULTILINE);
 179                 Matcher matguid;
 180                 Matcher matfuncc;
 181                 Matcher matfuncd;
 182                 Matcher matenclosereplace;
 183                 Matcher matefifuncc;
 184                 Matcher matentrypoint;
 185                 Matcher matmacro;
 186
 187                 while (ii.hasNext()) {
 188                         StringBuffer wholefile = new StringBuffer();
 189                         ifile = ii.next();
 190                         rd = new BufferedReader(new FileReader(mi.modulepath + File.separator + "temp" + File.separator + ifile));
 191                         while ((line = rd.readLine()) != null) {
 192                                 wholefile.append(line + '\n');
 193                         }
 194                         line = wholefile.toString();
 195
 196                         // if this is a Pei phase module , add these library class to .msa
 197                         matentrypoint = patentrypoint.matcher(line);
 198                         if (matentrypoint.find()) {
 199                                 mi.entrypoint = matentrypoint.group(2);
 200                                 if (matentrypoint.group(1).matches("PEIM")) {
 201                                         mi.hashrequiredr9libs.add("PeimEntryPoint");
 202                                 } else {
 203                                         mi.hashrequiredr9libs.add("UefiDriverEntryPoint");
 204                                 }
 205                         }
 206
 207                         // find guid
 208                         matguid = Guid.ptnguid.matcher(line);                                                                           // several ways to implement this , which one is faster ? :
 209                         while (matguid.find()) {                                                                                                        // 1.currently , find once , then call to identify which is it
 210                                 if ((temp = Guid.register(matguid, mi, ModuleInfo.db)) != null) {                               // 2.use 3 different matchers , search 3 times to find each
 211                                         //matguid.appendReplacement(result, ModuleInfo.db.getR9Guidname(temp));         // search the database for all 3 kinds of guids , high cost
 212                                 }
 213                         }
 214                         //matguid.appendTail(result);
 215                         //line = result.toString();
 216
 217                         // find EFI call in form of '->' , many 'gUnicodeCollationInterface->' like things are not changed
 218                         // This item is not simply replaced , special operation is required.
 219                         matefifuncc = patefifuncc.matcher(line);
 220                         while (matefifuncc.find()) {
 221                                 mi.hashEFIcall.add(matefifuncc.group(2));
 222                         }
 223
 224                         // find function call
 225                         matfuncc = Func.ptnfuncc.matcher(line);
 226                         while (matfuncc.find()) {
 227                                 if ((temp = Func.register(matfuncc, mi, ModuleInfo.db)) != null) {
 228                                         //ModuleInfo.ui.println(ifile + "  dofunc  " + temp);
 229                                         //matfuncc.appendReplacement(result, ModuleInfo.db.getR9Func(temp));
 230                                 }
 231                         }
 232                         //matfuncc.appendTail(result);
 233                         //line = result.toString();
 234
 235                         // find macro
 236                         matmacro = Macro.ptntmacro.matcher(line);
 237                         while (matmacro.find()) {
 238                                 if ((temp = Macro.register(matmacro, mi, ModuleInfo.db)) != null) {
 239                                 }
 240                         }
 241
 242                         // find function definition
 243                         // replace all {} to @
 244                         while ((matenclosereplace = Func.ptnbrace.matcher(line)).find()) {
 245                                 line = matenclosereplace.replaceAll("@");
 246                         }
 247
 248                         matfuncd = Func.ptnfuncd.matcher(line);
 249                         while (matfuncd.find()) {
 250                                 if ((temp = Func.register(matfuncd, mi, ModuleInfo.db)) != null) {
 251                                 }
 252                         }
 253                 }
 254
 255                 // op on hash
 256                 Iterator<String> funcci = mi.hashfuncc.iterator();
 257                 while (funcci.hasNext()) {
 258                         if (!mi.hashfuncd.contains(temp = funcci.next()) && !mi.hashEFIcall.contains(temp)) {
 259                                 mi.hashnonlocalfunc.add(temp);                                  // this set contains both changed and not changed items
 260                         }
 261                 }
 262         }
 263 }