Tools/Java/Source/MigrationTools/org/tianocore/migration/Database.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.apache.xmlbeans.XmlObject;
  20 import org.apache.xmlbeans.XmlObject.Factory;
  21 import org.tianocore.DbPathAndFilename;
  22 import org.tianocore.FrameworkDatabaseDocument;
  23 import org.tianocore.FrameworkDatabaseDocument.FrameworkDatabase;
  24 import org.tianocore.GuidDeclarationsDocument.GuidDeclarations;
  25 import org.tianocore.PackageListDocument.PackageList;
  26 import org.tianocore.PackageSurfaceAreaDocument;
  27 import org.tianocore.PackageSurfaceAreaDocument.PackageSurfaceArea;
  28 import org.tianocore.PpiDeclarationsDocument.PpiDeclarations;
  29 import org.tianocore.ProtocolDeclarationsDocument.ProtocolDeclarations;
  30 import org.tianocore.LibraryClassDeclarationsDocument.LibraryClassDeclarations;
  31 import org.tianocore.LibraryClassDeclarationsDocument.LibraryClassDeclarations.LibraryClass;
  32
  33 public final class Database {
  34     private static final Database INSTANCE = null;
  35
  36     Database(String path) {
  37         DatabasePath = path;
  38
  39         try {
  40             collectWorkSpaceDatabase();
  41             importPkgGuid("PkgGuid.csv");
  42             importDBLib("Library.csv");
  43             importDBGuid("Guid.csv", "Guid");
  44             importDBGuid("Ppi.csv", "Ppi");
  45             importDBGuid("Protocol.csv", "Protocol");
  46             importDBMacro("Macro.csv");
  47             importListR8Only();
  48         } catch (Exception e) {
  49             System.out.println(e.getMessage());
  50         }
  51     }
  52
  53     public String DatabasePath;
  54     public Set<String> error = new HashSet<String>();
  55     public Set<String> r8only = new HashSet<String>();
  56
  57     private Map<String,Guid> hashguid = new HashMap<String,Guid>();
  58     private Map<String,Func> hashfunc = new HashMap<String,Func>();
  59     private Map<String,Macro> hashmacro = new HashMap<String,Macro>();
  60     private Map<String,String> hashPkgGuid = new HashMap<String,String>();
  61
  62
  63     //-------------------------------------import------------------------------------------//
  64     private void importPkgGuid(String filename) throws Exception {
  65        BufferedReader rd = new BufferedReader(new FileReader(DatabasePath + File.separator + filename));
  66         String line;
  67         String[] linecontext;
  68
  69         if (rd.ready()) {
  70             System.out.println("Found " + filename + ", Importing Package Guid Database.");
  71             //
  72             // Skip the title row.
  73             //
  74             line = rd.readLine();
  75             while ((line = rd.readLine()) != null) {
  76                 if (line.length() != 0) {
  77                     linecontext = line.split(",");
  78                     hashPkgGuid.put(linecontext[0], linecontext[1]);
  79                 }
  80             }
  81         }
  82     }
  83     public Iterator<String> dumpAllPkgGuid() {
  84         return hashPkgGuid.values().iterator();
  85     }
  86     private void importDBLib(String filename) throws Exception {
  87         BufferedReader rd = new BufferedReader(new FileReader(DatabasePath + File.separator + filename));
  88         String line;
  89         String[] linecontext;
  90         Func lf;
  91
  92         if (rd.ready()) {
  93             System.out.println("Found " + filename + ", Importing Library Database.");
  94             while ((line = rd.readLine()) != null) {
  95                 if (line.length() != 0) {
  96                     linecontext = line.split(",");
  97                     lf = new Func(linecontext);
  98                     hashfunc.put(lf.r8funcname,lf);
  99                 }
 100             }
 101         }
 102     }
 103
 104     private void importDBGuid(String filename, String type) throws Exception {
 105         BufferedReader rd = new BufferedReader(new FileReader(DatabasePath + File.separator + filename));
 106         String line;
 107         String[] linecontext;
 108         Guid gu;
 109
 110         if (rd.ready()) {
 111             System.out.println("Found " + filename + ", Importing " + type + " Database.");
 112             while ((line = rd.readLine()) != null) {
 113                 if (line.length() != 0) {
 114                     linecontext = line.split(",");
 115                     gu = new Guid(linecontext, type);
 116                     hashguid.put(gu.r8name,gu);
 117                 }
 118             }
 119         }
 120     }
 121
 122     private void importDBMacro(String filename) throws Exception {
 123         BufferedReader rd = new BufferedReader(new FileReader(DatabasePath + File.separator + filename));
 124         String line;
 125         String[] linecontext;
 126         Macro mc;
 127
 128         if (rd.ready()) {
 129             System.out.println("Found " + filename + ", Importing Macro Database.");
 130             while ((line = rd.readLine()) != null) {
 131                 if (line.length() != 0) {
 132                     linecontext = line.split(",");
 133                     mc = new Macro(linecontext);
 134                     hashmacro.put(mc.r8name,mc);
 135                 }
 136             }
 137         }
 138     }
 139
 140     private void importListR8Only() throws Exception {
 141         Pattern ptnr8only = Pattern.compile("////#?(\\w*)?.*?R8_(.*?)\\s*\\(.*?////~", Pattern.DOTALL);
 142         String wholeline = Common.file2string(DatabasePath + File.separator + "R8Lib.c");
 143         System.out.println("Found " + "R8Lib.c" + ", Importing R8Lib Database.");
 144         Matcher mtrr8only = ptnr8only.matcher(wholeline);
 145         while (mtrr8only.find()) {
 146             r8only.add(mtrr8only.group(2));
 147         }
 148     }
 149
 150     //-------------------------------------import------------------------------------------//
 151
 152     //-------------------------------------get------------------------------------------//
 153
 154     public String getR9Lib(String r8funcname) {
 155         String temp = null;
 156         if (hashfunc.containsKey(r8funcname)) {
 157             temp = hashfunc.get(r8funcname).r9libname;
 158         }
 159         return temp;
 160     }
 161
 162     public String getR9Func(String r8funcname) {
 163         String temp = null;
 164         if (hashfunc.containsKey(r8funcname)) {
 165             temp = hashfunc.get(r8funcname).r9funcname;
 166         }
 167         return temp;
 168     }
 169
 170     public String getR9Macro(String r8macro) {
 171         return hashmacro.get(r8macro).r9name;            // the verification job of if the macro exists in the database is done when registering it
 172     }
 173
 174     public String getR9Guidname(String r8Guid) {
 175         String temp = null;
 176         try {
 177             temp = hashguid.get(r8Guid).r9name;
 178         } catch (NullPointerException e) {
 179             error.add("getR9Guidname :" + r8Guid);
 180         }
 181         return temp;
 182     }
 183
 184     public String getGuidType(String r8Guid) {
 185         String temp = null;
 186         try {
 187             temp =  hashguid.get(r8Guid).type;
 188         } catch (NullPointerException e) {
 189             error.add("getR9Guidname :" + r8Guid);
 190         }
 191         return temp;
 192     }
 193
 194     //-------------------------------------get------------------------------------------//
 195
 196     //-------------------------------------has------------------------------------------//
 197
 198     public boolean hasFunc(String r8lib) {
 199         return hashfunc.containsKey(r8lib);
 200     }
 201
 202     public boolean hasGuid(String r8guid) {
 203         return hashguid.containsKey(r8guid);
 204     }
 205
 206     public boolean hasMacro(String r8macro) {
 207         return hashmacro.containsKey(r8macro);
 208     }
 209
 210     //-------------------------------------has------------------------------------------//
 211
 212     //-------------------------------------init------------------------------------------//
 213
 214     private static final Database init() {
 215         if (System.getenv("WORKSPACE") == null) {
 216             return new Database("C:" + File.separator + "tianocore" + File.separator + "edk2" + File.separator + "Tools" + File.separator + "Conf" + File.separator + "Migration");
 217         } else {
 218             return new Database(System.getenv("WORKSPACE") + File.separator + "Tools" + File.separator + "Conf" + File.separator + "Migration");
 219         }
 220     }
 221
 222     public static final Database getInstance() {
 223         if (INSTANCE == null) {
 224             Database.init();
 225         }
 226         return INSTANCE;
 227     }
 228
 229
 230
 231     private static String                  workspacePath;
 232     private static HashMap<String, String> hashDbGuids        = new HashMap<String, String>();
 233     private static HashMap<String, String> hashDbPpis         = new HashMap<String, String>();
 234     private static HashMap<String, String> hashDbProtocols    = new HashMap<String, String>();
 235     private static HashMap<String, String> hashDbLibSymbols   = new HashMap<String, String>();
 236     private static HashMap<String, String> hashDbLibFunctions = new HashMap<String, String>();
 237     private static HashMap<String, String> hashDbLibExterns   = new HashMap<String, String>();
 238
 239     private static final String     regLibClassName = ".*\\W(\\w[\\w\\d]*)\\.h";
 240     private static final Pattern    ptnLibClassName = Pattern.compile(regLibClassName);
 241
 242     private static final String     regLibSymbol    = "#define\\s+(\\w[\\w\\d]*)";
 243     private static final Pattern    ptnLibSymbol    = Pattern.compile(regLibSymbol);
 244
 245     private static final String     regLibDataType  = "[A-Z][A-Z0-9_]*\\s*\\**";
 246     private static final String     regLibFunction  = regLibDataType + "\\s*(?:EFIAPI)?\\s+" +
 247                                                       "(\\w[\\w\\d]*)\\s*\\([^)]*\\)\\s*;";
 248     private static final Pattern    ptnLibFunction  = Pattern.compile(regLibFunction);
 249
 250     private static final String     regLibExtern    = "extern\\s+" + regLibDataType + "\\s*(\\w[\\w\\d]*)";
 251     private static final Pattern    ptnLibExtern    = Pattern.compile(regLibExtern);
 252
 253     private static final String convertToOsFilePath(String filePath) {
 254         return filePath.replace("/", File.separator).replace("\\", File.separator);
 255     }
 256     private static final void collectLibHeaderFileInfo(String libHeaderFile, String pkgGuid) throws Exception {
 257         String  fileContents;
 258         String  libClassName;
 259         String  libContainer;
 260         Matcher mtrLibClass;
 261         Matcher mtrLibSymbol;
 262         Matcher mtrLibFunction;
 263         Matcher mtrLibExtern;
 264
 265         System.out.println ("Parsing: " + libHeaderFile);
 266         mtrLibClass = ptnLibClassName.matcher(libHeaderFile);
 267         if (!mtrLibClass.matches()) {
 268             throw new Exception("Illegal libary header file");
 269         }
 270         libClassName = mtrLibClass.group(1);
 271         libContainer = libClassName + "@" + pkgGuid;
 272
 273         fileContents = Common.file2string(libHeaderFile);
 274         mtrLibSymbol = ptnLibSymbol.matcher(fileContents);
 275         while (mtrLibSymbol.find()) {
 276             String libSymbol;
 277             String oldLibContainer;
 278
 279             libSymbol       = mtrLibSymbol.group(1);
 280             oldLibContainer = hashDbLibSymbols.put(libSymbol, libContainer);
 281             if (oldLibContainer != null) {
 282                 String warnMessage;
 283
 284                 warnMessage = "Duplicated Lib Symbol:" + libSymbol + " Found. " +
 285                               "Later package will overide the previous one";
 286                 System.out.println(warnMessage);
 287             }
 288         }
 289
 290         mtrLibFunction = ptnLibFunction.matcher(fileContents);
 291         while (mtrLibFunction.find()) {
 292             String libFunction;
 293             String oldLibContainer;
 294
 295             libFunction     = mtrLibFunction.group(1);
 296             oldLibContainer = hashDbLibFunctions.put(libFunction, libContainer);
 297             if (oldLibContainer != null) {
 298                 String warnMessage;
 299
 300                 warnMessage = "Duplicated Lib Function:" + libFunction + " Found. " +
 301                               "Later package will overide the previous one";
 302                 System.out.println(warnMessage);
 303             }
 304         }
 305
 306         mtrLibExtern = ptnLibExtern.matcher(fileContents);
 307         while (mtrLibExtern.find()) {
 308             String libExtern;
 309             String oldLibContainer;
 310
 311             libExtern = mtrLibExtern.group(1);
 312             oldLibContainer = hashDbLibExterns.put(libExtern, libContainer);
 313             if (oldLibContainer != null) {
 314                 String warnMessage;
 315
 316                 warnMessage = "Duplicated Lib Extern:" + libExtern + " Found. " +
 317                               "Later package will overide the previous one";
 318                 System.out.println(warnMessage);
 319             }
 320         }
 321     }
 322     private static final void collectLibDataBase(PackageSurfaceArea spdDatabase, String pkgDirectory) throws Exception {
 323         String                              pkgGuid;
 324         LibraryClassDeclarations            libClassDeclarations;
 325
 326         pkgGuid = spdDatabase.getSpdHeader().getGuidValue();
 327         libClassDeclarations = spdDatabase.getLibraryClassDeclarations();
 328         if (libClassDeclarations != null) {
 329             Iterator<LibraryClass>   itLibClass;
 330
 331             itLibClass = libClassDeclarations.getLibraryClassList().iterator();
 332             while (itLibClass.hasNext()) {
 333                 String  libHeaderFile;
 334
 335                 libHeaderFile = pkgDirectory + File.separator +
 336                                 itLibClass.next().getIncludeHeader();
 337                 libHeaderFile = convertToOsFilePath (libHeaderFile);
 338                 try {
 339                     collectLibHeaderFileInfo(libHeaderFile, pkgGuid);
 340                 } catch (Exception e) {
 341                     String errorMessage;
 342
 343                     errorMessage = "Error (" + e.getMessage() + ")occurs when parsing " +
 344                                    libHeaderFile;
 345                     System.out.println(errorMessage);
 346                 }
 347             }
 348         }
 349     }
 350     private static final void collectGuidDatabase(PackageSurfaceArea spdDatabase) throws Exception {
 351         String                              pkgGuid;
 352         GuidDeclarations                    guidDeclarations;
 353
 354         pkgGuid = spdDatabase.getSpdHeader().getGuidValue();
 355         guidDeclarations = spdDatabase.getGuidDeclarations();
 356         if (guidDeclarations != null) {
 357             Iterator<GuidDeclarations.Entry>    itGuids;
 358
 359             itGuids = guidDeclarations.getEntryList().iterator();
 360             while (itGuids.hasNext()) {
 361                 hashDbGuids.put(itGuids.next().getCName(), pkgGuid);
 362             }
 363         }
 364
 365     }
 366
 367     private static final void collectPpiDatabase(PackageSurfaceArea spdDatabase) throws Exception {
 368         String                              pkgGuid;
 369         PpiDeclarations                     ppiDeclarations;
 370
 371         pkgGuid = spdDatabase.getSpdHeader().getGuidValue();
 372         ppiDeclarations = spdDatabase.getPpiDeclarations();
 373
 374         if (ppiDeclarations != null) {
 375             Iterator<PpiDeclarations.Entry>     itPpis;
 376
 377             itPpis = ppiDeclarations.getEntryList().iterator();
 378             while (itPpis.hasNext()) {
 379                 hashDbPpis.put(itPpis.next().getCName(), pkgGuid);
 380             }
 381         }
 382
 383     }
 384
 385     private static final void collectProtocolDatabase(PackageSurfaceArea spdDatabase) throws Exception {
 386         String                                  pkgGuid;
 387         ProtocolDeclarations                    protocolDeclarations;
 388
 389         pkgGuid = spdDatabase.getSpdHeader().getGuidValue();
 390         protocolDeclarations = spdDatabase.getProtocolDeclarations();
 391
 392         if (protocolDeclarations != null) {
 393             Iterator<ProtocolDeclarations.Entry>    itProtocols;
 394
 395             itProtocols = protocolDeclarations.getEntryList().iterator();
 396             while (itProtocols.hasNext()) {
 397                 hashDbGuids.put(itProtocols.next().getCName(), pkgGuid);
 398             }
 399         }
 400
 401     }
 402
 403     private static final void collectPackageDatabase(String packageFileName) throws Exception {
 404         XmlObject            xmlPackage;
 405         PackageSurfaceArea   spdDatabase;
 406         File                 pkgFile;
 407
 408         pkgFile     = new File(packageFileName);
 409         xmlPackage  = XmlObject.Factory.parse(pkgFile);
 410         spdDatabase = ((PackageSurfaceAreaDocument) xmlPackage).getPackageSurfaceArea();
 411
 412         collectGuidDatabase(spdDatabase);
 413         collectProtocolDatabase(spdDatabase);
 414         collectPpiDatabase(spdDatabase);
 415         collectLibDataBase(spdDatabase,  pkgFile.getParent());
 416
 417
 418     }
 419     public static final void collectWorkSpaceDatabase() throws Exception {
 420         String                      databaseFileName;
 421         File                        databaseFile;
 422         XmlObject                   xmlDatabase;
 423         FrameworkDatabase           frameworkDatabase;
 424         Iterator<DbPathAndFilename> packageFile;
 425
 426         workspacePath = System.getenv("WORKSPACE");
 427
 428         if (workspacePath == null) {
 429             String errorMessage = "Envivornment variable \"WORKSPACE\" is not set!";
 430             throw new Exception(errorMessage);
 431         }
 432         databaseFileName = workspacePath + File.separator +
 433                            "Tools" + File.separator +
 434                            "Conf" + File.separator +
 435                            "FrameworkDatabase.db";
 436         System.out.println("Open " + databaseFileName);
 437         databaseFile        = new File(databaseFileName);
 438         xmlDatabase         = XmlObject.Factory.parse(databaseFile);
 439         frameworkDatabase   = ((FrameworkDatabaseDocument) xmlDatabase).getFrameworkDatabase();
 440         packageFile         = frameworkDatabase.getPackageList().getFilenameList().iterator();
 441
 442         while (packageFile.hasNext()) {
 443             String packageFileName = packageFile.next().getStringValue();
 444             packageFileName = workspacePath + File.separator + packageFileName;
 445             packageFileName = convertToOsFilePath(packageFileName);
 446
 447             System.out.println("Parsing: " + packageFileName);
 448             try {
 449                 collectPackageDatabase(packageFileName);
 450             } catch (Exception e) {
 451                 System.out.println("Error occured when opening " + packageFileName + e.getMessage());
 452             }
 453         }
 454     }
 455 }