Tools/Source/GenBuild/org/tianocore/build/pcd/action/PCDAutoGenAction.java

   1 /** @file
   2   PCDAutoGenAction class.
   3
   4   This class is to manage how to generate the PCD information into Autogen.c and
   5   Autogen.h.
   6
   7 Copyright (c) 2006, Intel Corporation
   8 All rights reserved. This program and the accompanying materials
   9 are licensed and made available under the terms and conditions of the BSD License
  10 which accompanies this distribution.  The full text of the license may be found at
  11 http://opensource.org/licenses/bsd-license.php
  12
  13 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  14 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  15
  16 **/
  17 package org.tianocore.build.pcd.action;
  18
  19 import java.io.File;
  20 import java.util.ArrayList;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Set;
  24 import java.util.UUID;
  25 import java.util.regex.Matcher;
  26 import java.util.regex.Pattern;
  27
  28 import org.apache.xmlbeans.XmlObject;
  29 import org.tianocore.build.global.GlobalData;
  30 import org.tianocore.build.global.SurfaceAreaQuery;
  31 import org.tianocore.build.pcd.entity.MemoryDatabaseManager;
  32 import org.tianocore.build.pcd.entity.Token;
  33 import org.tianocore.build.pcd.entity.UsageInstance;
  34 import org.tianocore.build.pcd.exception.BuildActionException;
  35 import org.tianocore.build.pcd.exception.EntityException;
  36
  37 /** This class is to manage how to generate the PCD information into Autogen.c and
  38     Autogen.h.
  39 **/
  40 public class PCDAutoGenAction extends BuildAction {
  41     ///
  42     /// The reference of DBManager in GlobalData class.
  43     ///
  44     private MemoryDatabaseManager dbManager;
  45     ///
  46     /// The name of module which is analysised currently.
  47     ///
  48     private String                moduleName;
  49     ///
  50     /// The Guid of module which is analyzed currently.
  51     ///
  52     private UUID                  moduleGuid;
  53     ///
  54     /// The name of package whose module is analysized currently.
  55     ///
  56     private String                packageName;
  57     ///
  58     /// The Guid of package whose module is analyszed curretnly.
  59     ///
  60     private UUID                  packageGuid;
  61     ///
  62     /// The arch of current module
  63     ///
  64     private String                arch;
  65     ///
  66     /// The version of current module
  67     ///
  68     private String                version;
  69     ///
  70     /// Whether current autogen is for building library used by current module.
  71     ///
  72     private boolean               isBuildUsedLibrary;
  73     ///
  74     /// The generated string for header file.
  75     ///
  76     private String                hAutoGenString;
  77     ///
  78     /// The generated string for C code file.
  79     ///
  80     private String                cAutoGenString;
  81     ///
  82     /// The name array of <PcdCoded> in a module.
  83     ///
  84     private String[]              pcdNameArray;
  85     /**
  86       Set parameter ModuleName
  87
  88       @param moduleName   the module name parameter.
  89     **/
  90     public void setModuleName(String moduleName) {
  91         this.moduleName = moduleName;
  92     }
  93
  94     /**
  95        set the moduleGuid parameter.
  96
  97        @param moduleGuid
  98     **/
  99     public void setModuleGuid(UUID moduleGuid) {
 100         this.moduleGuid = moduleGuid;
 101     }
 102
 103     /**
 104        set packageName parameter.
 105
 106        @param packageName
 107     **/
 108     public void setPackageName(String packageName) {
 109         this.packageName = packageName;
 110     }
 111
 112     /**
 113         set packageGuid parameter.
 114
 115        @param packageGuid
 116     **/
 117     public void setPackageGuid(UUID packageGuid) {
 118         this.packageGuid = packageGuid;
 119     }
 120
 121     /**
 122        set Arch parameter.
 123
 124        @param arch
 125     **/
 126     public void setArch(String arch) {
 127         this.arch = arch;
 128     }
 129
 130     /**
 131        set version parameter
 132
 133        @param version
 134      */
 135     public void setVersion(String version) {
 136         this.version = version;
 137     }
 138
 139     /**
 140        set isBuildUsedLibrary parameter.
 141
 142        @param isBuildUsedLibrary
 143      */
 144     public void setIsBuildUsedLibrary(boolean isBuildUsedLibrary) {
 145         this.isBuildUsedLibrary = isBuildUsedLibrary;
 146     }
 147     /**
 148        set pcdNameArray parameter.
 149
 150        @param pcdNameArray
 151      */
 152     public void setPcdNameArray(String[] pcdNameArray) {
 153         this.pcdNameArray = pcdNameArray;
 154     }
 155
 156     /**
 157       Get the output of generated string for header file.
 158
 159       @return the string of header file for PCD
 160     **/
 161     public String OutputH() {
 162         return hAutoGenString;
 163     }
 164
 165     /**
 166       Get the output of generated string for C Code file.
 167
 168       @return the string of C code file for PCD
 169     **/
 170     public String OutputC() {
 171         return cAutoGenString;
 172     }
 173
 174 //    /**
 175 //      Construct function
 176 //
 177 //      This function mainly initialize some member variable.
 178 //
 179 //      @param moduleName            Parameter of this action class.
 180 //      @param isEmulatedPCDDriver   Parameter of this action class.
 181 //    **/
 182 //    public PCDAutoGenAction(String   moduleName,
 183 //                            UUID     moduleGuid,
 184 //                            String   packageName,
 185 //                            UUID     packageGuid,
 186 //                            String   arch,
 187 //                            String   version,
 188 //                            boolean  isBuildUsedLibrary,
 189 //                            String[] pcdNameArray) {
 190 //        dbManager       = null;
 191 //        hAutoGenString  = "";
 192 //        cAutoGenString  = "";
 193 //
 194 //        setModuleName(moduleName);
 195 //        setModuleGuid(moduleGuid);
 196 //        setPackageName(packageName);
 197 //        setPackageGuid(packageGuid);
 198 //        setPcdNameArray(pcdNameArray);
 199 //        setArch(arch);
 200 //        setVersion(version);
 201 //        setIsBuildUsedLibrary(isBuildUsedLibrary);
 202 //    }
 203
 204
 205     /**
 206     Construct function
 207
 208     This function mainly initialize some member variable.
 209
 210     @param moduleName            Parameter of this action class.
 211     @param isEmulatedPCDDriver   Parameter of this action class.
 212   **/
 213   public PCDAutoGenAction(String   moduleName,
 214                           String   moduleGuidString,
 215                           String   packageName,
 216                           String   packageGuidString,
 217                           String   arch,
 218                           String   version,
 219                           boolean  isBuildUsedLibrary,
 220                           String[] pcdNameArray)
 221         throws BuildActionException {
 222       dbManager       = null;
 223       hAutoGenString  = "";
 224       cAutoGenString  = "";
 225       try {
 226           setModuleName(moduleName);
 227           setModuleGuid(translateSchemaStringToUUID(moduleGuidString));
 228           setPackageName(packageName);
 229           setPackageGuid(translateSchemaStringToUUID(packageGuidString));
 230           setPcdNameArray(pcdNameArray);
 231           setArch(arch);
 232           setVersion(version);
 233           setIsBuildUsedLibrary(isBuildUsedLibrary);
 234       } catch (EntityException e){
 235           throw new BuildActionException(e.getMessage());
 236       }
 237   }
 238
 239   /**
 240   Translate the schema string to UUID instance.
 241
 242   In schema, the string of UUID is defined as following two types string:
 243    1) GuidArrayType: pattern = 0x[a-fA-F0-9]{1,8},( )*0x[a-fA-F0-9]{1,4},(
 244    )*0x[a-fA-F0-9]{1,4}(,( )*\{)?(,?( )*0x[a-fA-F0-9]{1,2}){8}( )*(\})?
 245
 246    2) GuidNamingConvention: pattern =
 247    [a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}
 248
 249   This function will convert string and create uuid instance.
 250
 251   @param uuidString    UUID string in XML file
 252
 253   @return UUID         UUID instance
 254 **/
 255 private UUID translateSchemaStringToUUID(String uuidString)
 256    throws EntityException {
 257    String      temp;
 258    String[]    splitStringArray;
 259    int         index;
 260    int         chIndex;
 261    int         chLen;
 262
 263    if (uuidString == null) {
 264        return null;
 265    }
 266
 267    if (uuidString.length() == 0) {
 268        return null;
 269    }
 270
 271    if (uuidString.equals("0") ||
 272        uuidString.equalsIgnoreCase("0x0")) {
 273        return new UUID(0, 0);
 274    }
 275
 276    uuidString = uuidString.replaceAll("\\{", "");
 277    uuidString = uuidString.replaceAll("\\}", "");
 278
 279    //
 280    // If the UUID schema string is GuidArrayType type then need translate
 281    // to GuidNamingConvention type at first.
 282    //
 283    if ((uuidString.charAt(0) == '0') && ((uuidString.charAt(1) == 'x') || (uuidString.charAt(1) == 'X'))) {
 284        splitStringArray = uuidString.split("," );
 285        if (splitStringArray.length != 11) {
 286            throw new EntityException ("[FPD file error] Wrong format for UUID string: " + uuidString);
 287        }
 288
 289        //
 290        // Remove blank space from these string and remove header string "0x"
 291        //
 292        for (index = 0; index < 11; index ++) {
 293            splitStringArray[index] = splitStringArray[index].trim();
 294            splitStringArray[index] = splitStringArray[index].substring(2, splitStringArray[index].length());
 295        }
 296
 297        //
 298        // Add heading '0' to normalize the string length
 299        //
 300        for (index = 3; index < 11; index ++) {
 301            chLen = splitStringArray[index].length();
 302            for (chIndex = 0; chIndex < 2 - chLen; chIndex ++) {
 303                splitStringArray[index] = "0" + splitStringArray[index];
 304            }
 305        }
 306
 307        //
 308        // construct the final GuidNamingConvention string
 309        //
 310        temp = String.format("%s-%s-%s-%s%s-%s%s%s%s%s%s",
 311                             splitStringArray[0],
 312                             splitStringArray[1],
 313                             splitStringArray[2],
 314                             splitStringArray[3],
 315                             splitStringArray[4],
 316                             splitStringArray[5],
 317                             splitStringArray[6],
 318                             splitStringArray[7],
 319                             splitStringArray[8],
 320                             splitStringArray[9],
 321                             splitStringArray[10]);
 322        uuidString = temp;
 323    }
 324
 325    return UUID.fromString(uuidString);
 326         }
 327
 328     /**
 329       check the parameter for action class.
 330
 331       @throws BuildActionException Bad parameter.
 332     **/
 333     void checkParameter() throws BuildActionException {
 334
 335     }
 336
 337     /**
 338       Core execution function for this action class.
 339
 340       All PCD information of this module comes from memory dabase. The collection
 341       work should be done before this action execution.
 342       Currently, we should generated all PCD information(maybe all dynamic) as array
 343       in Pei emulated driver for simulating PCD runtime database.
 344
 345       @throws BuildActionException Failed to execute this aciton class.
 346     **/
 347     void performAction() throws BuildActionException {
 348         ActionMessage.debug(this,
 349                             "Starting PCDAutoGenAction to generate autogen.h and autogen.c!...");
 350         //
 351         // Check the PCD memory database manager is valid.
 352         //
 353         if(GlobalData.getPCDMemoryDBManager() == null) {
 354             throw new BuildActionException("Memory database has not been initlizated!");
 355         }
 356
 357         dbManager = GlobalData.getPCDMemoryDBManager();
 358
 359         if(dbManager.getDBSize() == 0) {
 360             return;
 361         }
 362
 363         ActionMessage.debug(this,
 364                             "PCD memory database contains " + dbManager.getDBSize() + " PCD tokens");
 365
 366
 367
 368         generateAutogenForModule();
 369     }
 370
 371     /**
 372       Generate the autogen string for a common module.
 373
 374       All PCD information of this module comes from memory dabase. The collection
 375       work should be done before this action execution.
 376     **/
 377     private void generateAutogenForModule()
 378     {
 379         int                   index, index2;
 380         List<UsageInstance>   usageInstanceArray, usageContext;
 381         String[]              guidStringArray = null;
 382         String                guidStringCName = null;
 383         String                guidString      = null;
 384         UsageInstance         usageInstance   = null;
 385
 386         if (!isBuildUsedLibrary) {
 387             usageInstanceArray  = dbManager.getUsageInstanceArrayByModuleName(moduleName,
 388                                                                               moduleGuid,
 389                                                                               packageName,
 390                                                                               packageGuid,
 391                                                                               arch,
 392                                                                               version);
 393             dbManager.UsageInstanceContext = usageInstanceArray;
 394             dbManager.CurrentModuleName    = moduleName;
 395         } else {
 396             usageContext = dbManager.UsageInstanceContext;
 397             //
 398             // For building MDE package, although all module are library, but PCD entries of
 399             // these library should be used to autogen.
 400             //
 401             if (usageContext == null) {
 402                 usageInstanceArray  = dbManager.getUsageInstanceArrayByModuleName(moduleName,
 403                                                                                   moduleGuid,
 404                                                                                   packageName,
 405                                                                                   packageGuid,
 406                                                                                   arch,
 407                                                                                   version);
 408             } else {
 409                 usageInstanceArray = new ArrayList<UsageInstance>();
 410                 //
 411                 // Remove PCD entries which are not belong to this library.
 412                 //
 413                 for (index = 0; index < usageContext.size(); index++) {
 414                     if ((pcdNameArray == null) || (pcdNameArray.length == 0)){
 415                         break;
 416                     }
 417
 418                     for (index2 = 0; index2 < pcdNameArray.length; index2 ++) {
 419                         if (pcdNameArray[index2].equalsIgnoreCase(usageContext.get(index).parentToken.cName)) {
 420                             usageInstanceArray.add(usageContext.get(index));
 421                             break;
 422                         }
 423                     }
 424                 }
 425             }
 426         }
 427
 428         //
 429         // Generate all PCD entry for a module.
 430         //
 431         for(index = 0; index < usageInstanceArray.size(); index ++) {
 432             ActionMessage.debug(this,
 433                                 "Module " + moduleName + "'s PCD [" + Integer.toHexString(index) +
 434                                 "]: " + usageInstanceArray.get(index).parentToken.cName);
 435             try {
 436                 usageInstance = usageInstanceArray.get(index);
 437                 //
 438                 // Before generate any PCD information into autogen.h/autogen.c for a module,
 439                 // generate TokenSpaceGuid array variable firstly. For every dynamicEx type
 440                 // PCD in this module the token, they are all reference to TokenSpaceGuid
 441                 // array.
 442                 //
 443                 if (usageInstanceArray.get(index).modulePcdType == Token.PCD_TYPE.DYNAMIC_EX) {
 444                     guidStringArray = usageInstance.parentToken.tokenSpaceName.toString().split("-");
 445                     guidStringCName = "_gPcd_TokenSpaceGuid_" +
 446                                       usageInstance.parentToken.tokenSpaceName.toString().replaceAll("-", "_");
 447                     guidString      = String.format("{ 0x%s, 0x%s, 0x%s, {0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s, 0x%s}}",
 448                                                     guidStringArray[0],
 449                                                     guidStringArray[1],
 450                                                     guidStringArray[2],
 451                                                     (guidStringArray[3].substring(0, 2)),
 452                                                     (guidStringArray[3].substring(2, 4)),
 453                                                     (guidStringArray[4].substring(0, 2)),
 454                                                     (guidStringArray[4].substring(2, 4)),
 455                                                     (guidStringArray[4].substring(4, 6)),
 456                                                     (guidStringArray[4].substring(6, 8)),
 457                                                     (guidStringArray[4].substring(8, 10)),
 458                                                     (guidStringArray[4].substring(10, 12)));
 459
 460                     Pattern pattern = Pattern.compile("(" + guidStringCName + ")+?");
 461                     Matcher matcher = pattern.matcher(cAutoGenString + " ");
 462                     //
 463                     // Find whether this guid array variable has been generated into autogen.c
 464                     // For different DyanmicEx pcd token who use same token space guid, the token space
 465                     // guid array should be only generated once.
 466                     //
 467                     if (!matcher.find()) {
 468                         hAutoGenString += String.format("extern EFI_GUID %s;\r\n",
 469                                                         guidStringCName);
 470                         if (!isBuildUsedLibrary) {
 471                             cAutoGenString += String.format("GLOBAL_REMOVE_IF_UNREFERENCED EFI_GUID %s = %s;\r\n",
 472                                                             guidStringCName,
 473                                                             guidString);
 474                         }
 475                     }
 476                 }
 477
 478                 usageInstance.generateAutoGen(isBuildUsedLibrary);
 479                 //
 480                 // For every PCD entry for this module(usage instance), autogen string would
 481                 // be appand.
 482                 //
 483                 hAutoGenString += usageInstance.getHAutogenStr() + "\r\n";
 484                 cAutoGenString += usageInstance.getCAutogenStr();
 485
 486             } catch(EntityException exp) {
 487                 throw new BuildActionException("[PCD Autogen Error]: " + exp.getMessage());
 488             }
 489         }
 490
 491         //
 492         // Work around code, In furture following code should be modified that get
 493         // these information from Uplevel Autogen tools.
 494         //
 495         if (moduleName.equalsIgnoreCase("PcdPeim")) {
 496             hAutoGenString += dbManager.PcdPeimHString;
 497             cAutoGenString += dbManager.PcdPeimCString;
 498         } else if (moduleName.equalsIgnoreCase("PcdDxe")) {
 499             hAutoGenString += dbManager.PcdDxeHString;
 500             cAutoGenString += dbManager.PcdDxeCString;
 501         }
 502
 503         ActionMessage.debug(this,
 504                             "Module " + moduleName + "'s PCD header file:\r\n" + hAutoGenString + "\r\n"
 505                            );
 506         ActionMessage.debug(this,
 507                              "Module " + moduleName + "'s PCD C file:\r\n" + cAutoGenString + "\r\n"
 508                             );
 509     }
 510
 511     /**
 512       Test case function
 513
 514       @param argv  paramter from command line
 515     **/
 516     public static void main(String argv[]) {
 517
 518         String WorkSpace = "X:/edk2";
 519         String logFilePath = WorkSpace  + "/EdkNt32Pkg/Nt32.fpd";
 520         String[] nameArray = null;
 521
 522         //
 523         // At first, CollectPCDAction should be invoked to collect
 524         // all PCD information from SPD, MSA, FPD.
 525         //
 526         CollectPCDAction collectionAction = new CollectPCDAction();
 527         GlobalData.initInfo("Tools" + File.separator + "Conf" + File.separator + "FrameworkDatabase.db",
 528                             WorkSpace,null);
 529
 530         try {
 531             collectionAction.perform(WorkSpace,
 532                                      logFilePath,
 533                                      ActionMessage.MAX_MESSAGE_LEVEL);
 534         } catch(Exception e) {
 535             e.printStackTrace();
 536         }
 537
 538         //
 539         // Then execute the PCDAuotoGenAction to get generated Autogen.h and Autogen.c
 540         //
 541 //        PCDAutoGenAction autogenAction = new PCDAutoGenAction("MonoStatusCode",
 542 //                                                              null,
 543 //                                                              null,
 544 //                                                              null,
 545 //                                                              "IA32",
 546 //                                                              null,
 547 //                                                              false,
 548 //                                                              nameArray);
 549 //        autogenAction.execute();
 550 //
 551 //        System.out.println(autogenAction.OutputH());
 552 //        System.out.println("WQWQWQWQWQ");
 553 //        System.out.println(autogenAction.OutputC());
 554     }
 555 }