+class LocalTokenNumberTable {\r
+ private ArrayList<String> al;\r
+ private ArrayList<String> alComment;\r
+ private String phase;\r
+ private int len;\r
+\r
+ public LocalTokenNumberTable (String phase) {\r
+ this.phase = phase;\r
+ al = new ArrayList<String>();\r
+ alComment = new ArrayList<String>();\r
+\r
+ len = 0;\r
+ }\r
+\r
+ public String getSizeMacro () {\r
+ return String.format(PcdDatabase.LocalTokenNumberTableSizeMacro, phase, getSize())\r
+ + String.format(PcdDatabase.LocalTokenNumberSizeMacro, phase, al.size());\r
+ }\r
+\r
+ public int getSize () {\r
+ return (al.size() == 0)? 1 : al.size();\r
+ }\r
+\r
+ public String getExistanceMacro () {\r
+ return String.format(PcdDatabase.DatabaseExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");\r
+ }\r
+\r
+ public void genCode (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) {\r
+ final String name = "LocalTokenNumberTable";\r
+ \r
+ CStructTypeDeclaration decl;\r
+ String cCode = "";\r
+\r
+ cCode += String.format(PcdDatabase.LocalTokenNumberTableDeclaration, phase); \r
+ decl = new CStructTypeDeclaration (\r
+ name,\r
+ 4,\r
+ cCode,\r
+ true\r
+ ); \r
+ declaList.add(decl);\r
+\r
+ cCode = PcdDatabase.genInstantiationStr(getInstantiation());\r
+ instTable.put(name, cCode);\r
+ }\r
+\r
+ private ArrayList<String> getInstantiation () {\r
+ ArrayList<String> output = new ArrayList<String>();\r
+\r
+ output.add("/* LocalTokenNumberTable */");\r
+ output.add("{");\r
+\r
+ if (al.size() == 0) {\r
+ output.add("\t0");\r
+ }\r
+ \r
+ for (int index = 0; index < al.size(); index++) {\r
+ String str;\r
+\r
+ str = "\t" + (String)al.get(index);\r
+\r
+ str += " /* " + alComment.get(index) + " */ ";\r
+\r
+\r
+ if (index != (al.size() - 1)) {\r
+ str += ",";\r
+ }\r
+\r
+ output.add(str);\r
+\r
+ }\r
+\r
+ output.add("}");\r
+\r
+ return output;\r
+ }\r
+\r
+ public int add (Token token) {\r
+ int index = len;\r
+ String str;\r
+\r
+ len++; \r
+\r
+ str = String.format(PcdDatabase.offsetOfStrTemplate, phase, token.hasDefaultValue() ? "Init" : "Uninit", token.getPrimaryKeyString());\r
+\r
+ if (token.isUnicodeStringType()) {\r
+ str += " | PCD_TYPE_STRING";\r
+ }\r
+\r
+ if (token.isSkuEnable()) {\r
+ str += " | PCD_TYPE_SKU_ENABLED";\r
+ }\r
+\r
+ if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {\r
+ str += " | PCD_TYPE_HII";\r
+ }\r
+\r
+ if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {\r
+ str += " | PCD_TYPE_VPD";\r
+ }\r
+ \r
+ switch (token.datumType) {\r
+ case UINT8:\r
+ case BOOLEAN:\r
+ str += " | PCD_DATUM_TYPE_UINT8";\r
+ break;\r
+ case UINT16:\r
+ str += " | PCD_DATUM_TYPE_UINT16";\r
+ break;\r
+ case UINT32:\r
+ str += " | PCD_DATUM_TYPE_UINT32";\r
+ break;\r
+ case UINT64:\r
+ str += " | PCD_DATUM_TYPE_UINT64";\r
+ break;\r
+ case POINTER:\r
+ str += " | PCD_DATUM_TYPE_POINTER";\r
+ break;\r
+ }\r
+ \r
+ al.add(str);\r
+ alComment.add(token.getPrimaryKeyString());\r
+\r
+ return index;\r
+ }\r
+}\r
+\r
+/**\r
+ ExMapTable \r
+ \r
+ This class is used to store the table of mapping information\r
+ between DynamicEX ID pair(Guid, TokenNumber) and\r
+ the local token number assigned by PcdDatabase class.\r
+**/\r
+class ExMapTable {\r
+\r
+ /**\r
+ ExTriplet \r
+ \r
+ This class is used to store the mapping information\r
+ between DynamicEX ID pair(Guid, TokenNumber) and\r
+ the local token number assigned by PcdDatabase class.\r
+ **/\r
+ class ExTriplet {\r
+ public Integer guidTableIdx;\r
+ public Long exTokenNumber;\r
+ public Long localTokenIdx;\r
+ \r
+ public ExTriplet (int guidTableIdx, long exTokenNumber, long localTokenIdx) {\r
+ this.guidTableIdx = new Integer(guidTableIdx);\r
+ this.exTokenNumber = new Long(exTokenNumber);\r
+ this.localTokenIdx = new Long(localTokenIdx);\r
+ }\r
+ }\r
+\r
+ private ArrayList<ExTriplet> al;\r
+ private Map<ExTriplet, String> alComment;\r
+ private String phase;\r
+ private int len;\r
+ private int bodyLineNum;\r
+ \r
+ public ExMapTable (String phase) {\r
+ this.phase = phase;\r
+ al = new ArrayList<ExTriplet>();\r
+ alComment = new HashMap<ExTriplet, String>();\r
+ bodyLineNum = 0;\r
+ len = 0;\r
+ }\r
+\r
+ public String getSizeMacro () {\r
+ return String.format(PcdDatabase.ExMapTableSizeMacro, phase, getTableLen())\r
+ + String.format(PcdDatabase.ExTokenNumber, phase, al.size());\r
+ }\r
+\r
+ public String getExistanceMacro () {\r
+ return String.format(PcdDatabase.ExMapTableExistenceMacro, phase, (al.size() == 0)? "TRUE":"FALSE");\r
+ }\r
+\r
+ public void genCode (ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) {\r
+ final String exMapTableName = "ExMapTable";\r
+ \r
+ sortTable();\r
+ \r
+ CStructTypeDeclaration decl;\r
+ String cCode = "";\r
+\r
+ cCode += String.format(PcdDatabase.ExMapTableDeclaration, phase); \r
+ decl = new CStructTypeDeclaration (\r
+ exMapTableName,\r
+ 4,\r
+ cCode,\r
+ true\r
+ ); \r
+ declaList.add(decl);\r
+\r
+\r
+ cCode = PcdDatabase.genInstantiationStr(getInstantiation());\r
+ instTable.put(exMapTableName, cCode);\r
+ }\r
+ \r
+ private ArrayList<String> getInstantiation () {\r
+ ArrayList<String> Output = new ArrayList<String>();\r
+\r
+ Output.add("/* ExMapTable */");\r
+ Output.add("{");\r
+ if (al.size() == 0) {\r
+ Output.add("\t{0, 0, 0}");\r
+ }\r
+ \r
+ int index;\r
+ for (index = 0; index < al.size(); index++) {\r
+ String str;\r
+\r
+ ExTriplet e = (ExTriplet)al.get(index);\r
+\r
+ str = "\t" + "{ " + String.format("0x%08X", e.exTokenNumber) + ", ";\r
+ str += e.localTokenIdx.toString() + ", ";\r
+ str += e.guidTableIdx.toString();\r
+\r
+ str += "}" + " /* " + alComment.get(e) + " */" ;\r
+\r
+ if (index != al.size() - 1) {\r
+ str += ",";\r
+ }\r
+\r
+ Output.add(str);\r
+ bodyLineNum++;\r
+\r
+ }\r
+\r
+ Output.add("}");\r
+\r
+ return Output;\r
+ }\r
+\r
+ public int add (int localTokenIdx, long exTokenNum, int guidTableIdx, String name) {\r
+ int index = len;\r
+\r
+ len++;\r
+ ExTriplet et = new ExTriplet(guidTableIdx, exTokenNum, localTokenIdx); \r
+\r
+ al.add(et);\r
+ alComment.put(et, name);\r
+\r
+ return index;\r
+ }\r
+\r
+ private int getTableLen () {\r
+ return al.size() == 0 ? 1 : al.size();\r
+ }\r
+\r
+ //\r
+ // To simplify the algorithm for GetNextToken and GetNextTokenSpace in\r
+ // PCD PEIM/Driver, we need to sort the ExMapTable according to the\r
+ // following order:\r
+ // 1) ExGuid\r
+ // 2) ExTokenNumber\r
+ // \r
+ class ExTripletComp implements Comparator<ExTriplet> {\r
+ public int compare (ExTriplet a, ExTriplet b) {\r
+ if (a.guidTableIdx == b.guidTableIdx ) {\r
+ //\r
+ // exTokenNumber is long, we can't use simple substraction.\r
+ //\r
+ if (a.exTokenNumber > b.exTokenNumber) {\r
+ return 1;\r
+ } else if (a.exTokenNumber == b.exTokenNumber) {\r
+ return 0;\r
+ } else {\r
+ return -1;\r
+ }\r
+ }\r
+ \r
+ return a.guidTableIdx - b.guidTableIdx;\r
+ }\r
+ }\r
+\r
+ private void sortTable () {\r
+ java.util.Comparator<ExTriplet> comparator = new ExTripletComp();\r
+ java.util.Collections.sort(al, comparator);\r
+ }\r
+}\r
+\r
+/**\r
+ PcdDatabase \r
+ \r
+ This class is used to generate C code for Autogen.h and Autogen.c of\r
+ a PCD service DXE driver and PCD service PEIM.\r
+**/\r
+class PcdDatabase {\r
+\r
+ private final static int SkuHeadAlignmentSize = 4;\r
+ private final String newLine = "\r\n";\r
+ private final String commaNewLine = ",\r\n";\r
+ private final String tab = "\t";\r
+ public final static String ExMapTableDeclaration = "DYNAMICEX_MAPPING ExMapTable[%s_EXMAPPING_TABLE_SIZE];\r\n";\r
+ public final static String GuidTableDeclaration = "EFI_GUID GuidTable[%s_GUID_TABLE_SIZE];\r\n";\r
+ public final static String LocalTokenNumberTableDeclaration = "UINT32 LocalTokenNumberTable[%s_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r\n";\r
+ public final static String StringTableDeclaration = "UINT16 StringTable[%s_STRING_TABLE_SIZE];\r\n";\r
+ public final static String SizeTableDeclaration = "SIZE_INFO SizeTable[%s_SIZE_TABLE_SIZE];\r\n";\r
+ public final static String SkuIdTableDeclaration = "UINT8 SkuIdTable[%s_SKUID_TABLE_SIZE];\r\n";\r
+\r
+\r
+ public final static String ExMapTableSizeMacro = "#define %s_EXMAPPING_TABLE_SIZE %d\r\n";\r
+ public final static String ExTokenNumber = "#define %s_EX_TOKEN_NUMBER %d\r\n";\r
+ public final static String GuidTableSizeMacro = "#define %s_GUID_TABLE_SIZE %d\r\n"; \r
+ public final static String LocalTokenNumberTableSizeMacro = "#define %s_LOCAL_TOKEN_NUMBER_TABLE_SIZE %d\r\n";\r
+ public final static String LocalTokenNumberSizeMacro = "#define %s_LOCAL_TOKEN_NUMBER %d\r\n";\r
+ public final static String SizeTableSizeMacro = "#define %s_SIZE_TABLE_SIZE %d\r\n";\r
+ public final static String StringTableSizeMacro = "#define %s_STRING_TABLE_SIZE %d\r\n";\r
+ public final static String SkuIdTableSizeMacro = "#define %s_SKUID_TABLE_SIZE %d\r\n";\r
+\r
+\r
+ public final static String ExMapTableExistenceMacro = "#define %s_EXMAP_TABLE_EMPTY %s\r\n"; \r
+ public final static String GuidTableExistenceMacro = "#define %s_GUID_TABLE_EMPTY %s\r\n";\r
+ public final static String DatabaseExistenceMacro = "#define %s_DATABASE_EMPTY %s\r\n";\r
+ public final static String StringTableExistenceMacro = "#define %s_STRING_TABLE_EMPTY %s\r\n";\r
+ public final static String SkuTableExistenceMacro = "#define %s_SKUID_TABLE_EMPTY %s\r\n";\r
+\r
+ public final static String offsetOfSkuHeadStrTemplate = "offsetof(%s_PCD_DATABASE, %s.%s_SkuDataTable)";\r
+ public final static String offsetOfVariableEnabledDefault = "offsetof(%s_PCD_DATABASE, %s.%s_VariableDefault_%d)";\r
+ public final static String offsetOfStrTemplate = "offsetof(%s_PCD_DATABASE, %s.%s)";\r
+ \r
+ private final static String skuDataTableTemplate = "SkuDataTable";\r
+\r
+\r
+ private StringTable stringTable;\r
+ private GuidTable guidTable;\r
+ private LocalTokenNumberTable localTokenNumberTable;\r
+ private SkuIdTable skuIdTable;\r
+ private SizeTable sizeTable;\r
+ private ExMapTable exMapTable;\r
+\r
+ private ArrayList<Token> alTokens;\r
+ private String phase;\r
+ private int assignedTokenNumber;\r
+ \r
+ //\r
+ // Use two class global variable to store\r
+ // temperary \r
+ //\r
+ private String privateGlobalName;\r
+ private String privateGlobalCCode;\r
+ //\r
+ // After Major changes done to the PCD\r
+ // database generation class PcdDatabase\r
+ // Please increment the version and please\r
+ // also update the version number in PCD\r
+ // service PEIM and DXE driver accordingly.\r
+ //\r
+ private final int version = 2;\r
+\r
+ private String hString;\r
+ private String cString;\r
+\r
+ /**\r
+ Constructor for PcdDatabase class. \r
+ \r
+ <p>We have two PCD dynamic(ex) database for the Framework implementation. One\r
+ for PEI phase and the other for DXE phase. </p>\r
+ \r
+ @param alTokens A ArrayList of Dynamic(EX) PCD entry.\r
+ @param exePhase The phase to generate PCD database for: valid input\r
+ is "PEI" or "DXE".\r
+ @param startLen The starting Local Token Number for the PCD database. For\r
+ PEI phase, the starting Local Token Number starts from 0.\r
+ For DXE phase, the starting Local Token Number starts\r
+ from the total number of PCD entry of PEI phase.\r
+ @return void\r
+ **/\r
+ public PcdDatabase (ArrayList<Token> alTokens, String exePhase, int startLen) {\r
+ phase = exePhase;\r
+\r
+ stringTable = new StringTable(phase);\r
+ guidTable = new GuidTable(phase);\r
+ localTokenNumberTable = new LocalTokenNumberTable(phase);\r
+ skuIdTable = new SkuIdTable(phase);\r
+ sizeTable = new SizeTable(phase);\r
+ exMapTable = new ExMapTable(phase); \r
+\r
+ //\r
+ // Local token number 0 is reserved for INVALID_TOKEN_NUMBER.\r
+ // So we will increment 1 for the startLen passed from the \r
+ // constructor.\r
+ //\r
+ assignedTokenNumber = startLen + 1;\r
+ this.alTokens = alTokens;\r
+ }\r
+\r
+ private void getNonExAndExTokens (ArrayList<Token> alTokens, List<Token> nexTokens, List<Token> exTokens) {\r
+ for (int i = 0; i < alTokens.size(); i++) {\r
+ Token t = (Token)alTokens.get(i);\r
+ if (t.isDynamicEx()) {\r
+ exTokens.add(t);\r
+ } else {\r
+ nexTokens.add(t);\r
+ }\r
+ }\r
+\r
+ return;\r
+ }\r
+\r
+ private int getDataTypeAlignmentSize (Token token) {\r
+ switch (token.datumType) {\r
+ case UINT8:\r
+ return 1;\r
+ case UINT16:\r
+ return 2;\r
+ case UINT32:\r
+ return 4;\r
+ case UINT64:\r
+ return 8;\r
+ case POINTER:\r
+ return 1;\r
+ case BOOLEAN:\r
+ return 1;\r
+ default:\r
+ return 1;\r
+ }\r
+ }\r
+ \r
+ private int getHiiPtrTypeAlignmentSize(Token token) {\r
+ switch (token.datumType) {\r
+ case UINT8:\r
+ return 1;\r
+ case UINT16:\r
+ return 2;\r
+ case UINT32:\r
+ return 4;\r
+ case UINT64:\r
+ return 8;\r
+ case POINTER:\r
+ if (token.isHiiEnable()) {\r
+ if (token.isHiiDefaultValueUnicodeStringType()) {\r
+ return 2;\r
+ }\r
+ }\r
+ return 1;\r
+ case BOOLEAN:\r
+ return 1;\r
+ default:\r
+ return 1;\r
+ }\r
+ }\r
+ \r
+ private int getAlignmentSize (Token token) {\r
+ if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.HII_TYPE) {\r
+ return 2;\r
+ }\r
+\r
+ if (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.VPD_TYPE) {\r
+ return 4;\r
+ }\r
+\r
+ if (token.isUnicodeStringType()) {\r
+ return 2;\r
+ }\r
+ \r
+ return getDataTypeAlignmentSize(token);\r
+ }\r
+\r
+ public String getCString () {\r
+ return cString;\r
+ }\r
+\r
+ public String getHString () {\r
+ return hString;\r
+ }\r
+ \r
+ private void genCodeWorker(Token t,\r
+ ArrayList<CStructTypeDeclaration> declaList,\r
+ HashMap<String, String> instTable, String phase)\r
+ throws EntityException {\r
+\r
+ CStructTypeDeclaration decl;\r
+\r
+ //\r
+ // Insert SKU_HEAD if isSkuEnable is true\r
+ //\r
+ if (t.isSkuEnable()) {\r
+ int tableIdx;\r
+ tableIdx = skuIdTable.add(t);\r
+ decl = new CStructTypeDeclaration(t.getPrimaryKeyString(),\r
+ SkuHeadAlignmentSize, getSkuEnabledTypeDeclaration(t), true);\r
+ declaList.add(decl);\r
+ instTable.put(t.getPrimaryKeyString(),\r
+ getSkuEnabledTypeInstantiaion(t, tableIdx));\r
+ }\r
+\r
+ //\r
+ // Insert PCD_ENTRY declaration and instantiation\r
+ //\r
+ getCDeclarationString(t);\r
+\r
+ decl = new CStructTypeDeclaration(privateGlobalName,\r
+ getAlignmentSize(t), privateGlobalCCode, t.hasDefaultValue());\r
+ declaList.add(decl);\r
+\r
+ if (t.hasDefaultValue()) {\r
+ instTable.put(privateGlobalName, \r
+ getTypeInstantiation(t, declaList, instTable, phase)\r
+ );\r
+ }\r
+\r
+ }\r
+\r
+ private void ProcessTokens (List<Token> tokens, \r
+ ArrayList<CStructTypeDeclaration> cStructDeclList,\r
+ HashMap<String, String> cStructInstTable,\r
+ String phase\r
+ ) \r
+ throws EntityException {\r
+ \r
+ for (int idx = 0; idx < tokens.size(); idx++) {\r
+ Token t = tokens.get(idx);\r
+ \r
+ genCodeWorker (t, cStructDeclList, cStructInstTable, phase);\r
+ \r
+ sizeTable.add(t);\r
+ localTokenNumberTable.add(t);\r
+ t.tokenNumber = assignedTokenNumber++;\r
+ \r
+ //\r
+ // Add a mapping if this dynamic PCD entry is a EX type\r
+ //\r
+ if (t.isDynamicEx()) {\r
+ exMapTable.add((int)t.tokenNumber, \r
+ t.dynamicExTokenNumber, \r
+ guidTable.add(translateSchemaStringToUUID(t.tokenSpaceName), t.getPrimaryKeyString()), \r
+ t.getPrimaryKeyString()\r
+ );\r
+ }\r
+ }\r
+\r
+ }\r
+ \r
+ public void genCode () throws EntityException {\r
+ \r
+ ArrayList<CStructTypeDeclaration> cStructDeclList = new ArrayList<CStructTypeDeclaration>();\r
+ HashMap<String, String> cStructInstTable = new HashMap<String, String>();\r
+ \r
+ List<Token> nexTokens = new ArrayList<Token> ();\r
+ List<Token> exTokens = new ArrayList<Token> ();\r
+\r
+ getNonExAndExTokens (alTokens, nexTokens, exTokens);\r
+\r
+ //\r
+ // We have to process Non-Ex type PCD entry first. The reason is\r
+ // that our optimization assumes that the Token Number of Non-Ex \r
+ // PCD entry start from 1 (for PEI phase) and grows continously upwards.\r
+ // \r
+ // EX type token number starts from the last Non-EX PCD entry and\r
+ // grows continously upwards.\r
+ //\r
+ ProcessTokens (nexTokens, cStructDeclList, cStructInstTable, phase);\r
+ ProcessTokens (exTokens, cStructDeclList, cStructInstTable, phase);\r
+ \r
+ stringTable.genCode(cStructDeclList, cStructInstTable);\r
+ skuIdTable.genCode(cStructDeclList, cStructInstTable, phase);\r
+ exMapTable.genCode(cStructDeclList, cStructInstTable, phase);\r
+ localTokenNumberTable.genCode(cStructDeclList, cStructInstTable, phase);\r
+ sizeTable.genCode(cStructDeclList, cStructInstTable, phase);\r
+ guidTable.genCode(cStructDeclList, cStructInstTable, phase);\r
+ \r
+ hString = genCMacroCode ();\r
+ \r
+ HashMap <String, String> result;\r
+ \r
+ result = genCStructCode(cStructDeclList, \r
+ cStructInstTable, \r
+ phase\r
+ );\r
+ \r
+ hString += result.get("initDeclStr");\r
+ hString += result.get("uninitDeclStr");\r
+ \r
+ hString += String.format("#define PCD_%s_SERVICE_DRIVER_VERSION %d", phase, version);\r
+ \r
+ cString = newLine + newLine + result.get("initInstStr");\r
+ \r
+ }\r
+ \r
+ private String genCMacroCode () {\r
+ String macroStr = "";\r
+\r
+ //\r
+ // Generate size info Macro for all Tables\r
+ //\r
+ macroStr += guidTable.getSizeMacro();\r
+ macroStr += stringTable.getSizeMacro();\r
+ macroStr += skuIdTable.getSizeMacro();\r
+ macroStr += localTokenNumberTable.getSizeMacro();\r
+ macroStr += exMapTable.getSizeMacro();\r
+ macroStr += sizeTable.getSizeMacro();\r
+\r
+ //\r
+ // Generate existance info Macro for all Tables\r
+ //\r
+ macroStr += guidTable.getExistanceMacro();\r
+ macroStr += stringTable.getExistanceMacro();\r
+ macroStr += skuIdTable.getExistanceMacro();\r
+ macroStr += localTokenNumberTable.getExistanceMacro();\r
+ macroStr += exMapTable.getExistanceMacro();\r
+\r
+ macroStr += newLine;\r
+ \r
+ return macroStr;\r
+ }\r
+ \r
+ private HashMap <String, String> genCStructCode(\r
+ ArrayList<CStructTypeDeclaration> declaList, \r
+ HashMap<String, String> instTable, \r
+ String phase\r
+ ) {\r
+ \r
+ int i;\r
+ HashMap <String, String> result = new HashMap<String, String>();\r
+ HashMap <Integer, ArrayList<String>> alignmentInitDecl = new HashMap<Integer, ArrayList<String>>();\r
+ HashMap <Integer, ArrayList<String>> alignmentUninitDecl = new HashMap<Integer, ArrayList<String>>();\r
+ HashMap <Integer, ArrayList<String>> alignmentInitInst = new HashMap<Integer, ArrayList<String>>();\r
+ \r
+ //\r
+ // Initialize the storage for each alignment\r
+ //\r
+ for (i = 8; i > 0; i>>=1) {\r
+ alignmentInitDecl.put(new Integer(i), new ArrayList<String>());\r
+ alignmentInitInst.put(new Integer(i), new ArrayList<String>());\r
+ alignmentUninitDecl.put(new Integer(i), new ArrayList<String>());\r
+ }\r
+ \r
+ String initDeclStr = "typedef struct {" + newLine;\r
+ String initInstStr = String.format("%s_PCD_DATABASE_INIT g%sPcdDbInit = { ", phase.toUpperCase(), phase.toUpperCase()) + newLine;\r
+ String uninitDeclStr = "typedef struct {" + newLine;\r
+\r
+ //\r
+ // Sort all C declaration and instantiation base on Alignment Size \r
+ //\r
+ for (Object d : declaList) {\r
+ CStructTypeDeclaration decl = (CStructTypeDeclaration) d;\r
+ \r
+ if (decl.initTable) {\r
+ alignmentInitDecl.get(new Integer(decl.alignmentSize)).add(decl.cCode);\r
+ alignmentInitInst.get(new Integer(decl.alignmentSize)).add(instTable.get(decl.key));\r
+ } else {\r
+ alignmentUninitDecl.get(new Integer(decl.alignmentSize)).add(decl.cCode);\r
+ }\r
+ }\r
+\r
+ //\r
+ // Generate code for every alignment size\r
+ //\r
+ boolean uinitDatabaseEmpty = true;\r
+ for (int align = 8; align > 0; align >>= 1) {\r
+ ArrayList<String> declaListBasedOnAlignment = alignmentInitDecl.get(new Integer(align));\r
+ ArrayList<String> instListBasedOnAlignment = alignmentInitInst.get(new Integer(align));\r
+ for (i = 0; i < declaListBasedOnAlignment.size(); i++) {\r
+ initDeclStr += tab + declaListBasedOnAlignment.get(i);\r
+ initInstStr += tab + instListBasedOnAlignment.get(i);\r
+ \r
+ //\r
+ // We made a assumption that both PEI_PCD_DATABASE and DXE_PCD_DATABASE\r
+ // has a least one data memember with alignment size of 1. So we can\r
+ // remove the last "," in the C structure instantiation string. Luckily,\r
+ // this is true as both data structure has SKUID_TABLE anyway.\r
+ //\r
+ if ((align == 1) && (i == declaListBasedOnAlignment.size() - 1)) {\r
+ initInstStr += newLine;\r
+ } else {\r
+ initInstStr += commaNewLine;\r
+ }\r
+ }\r
+ \r
+ declaListBasedOnAlignment = alignmentUninitDecl.get(new Integer(align));\r
+ \r
+ if (declaListBasedOnAlignment.size() != 0) {\r
+ uinitDatabaseEmpty = false;\r
+ }\r
+ \r
+ for (Object d : declaListBasedOnAlignment) {\r
+ String s = (String)d;\r
+ uninitDeclStr += tab + s;\r
+ }\r
+ }\r
+ \r
+ if (uinitDatabaseEmpty) {\r
+ uninitDeclStr += tab + String.format("%-20sdummy; /* PCD_DATABASE_UNINIT is emptry */\r\n", "UINT8");\r
+ }\r
+ \r
+ initDeclStr += String.format("} %s_PCD_DATABASE_INIT;", phase) + newLine + newLine;\r
+ initInstStr += "};" + newLine;\r
+ uninitDeclStr += String.format("} %s_PCD_DATABASE_UNINIT;", phase) + newLine + newLine;\r
+ \r
+ result.put("initDeclStr", initDeclStr);\r
+ result.put("initInstStr", initInstStr);\r
+ result.put("uninitDeclStr", uninitDeclStr);\r
+\r
+ return result;\r
+ }\r
+\r
+ public static String genInstantiationStr (ArrayList<String> alStr) {\r
+ String str = "";\r
+ for (int i = 0; i< alStr.size(); i++) {\r
+ if (i != 0) {\r
+ str += "\t";\r
+ }\r
+ str += alStr.get(i);\r
+ if (i != alStr.size() - 1) {\r
+ str += "\r\n";\r
+ }\r
+ }\r
+\r
+ return str;\r
+ }\r
+\r
+ private String getSkuEnabledTypeDeclaration (Token token) {\r
+ return String.format("%-20s%s;\r\n", "SKU_HEAD", token.getPrimaryKeyString());\r
+ }\r
+\r
+ private String getSkuEnabledTypeInstantiaion (Token token, int SkuTableIdx) {\r
+\r
+ String offsetof = String.format(PcdDatabase.offsetOfSkuHeadStrTemplate, phase, token.hasDefaultValue()? "Init" : "Uninit", token.getPrimaryKeyString());\r
+ return String.format("{ %s, %d } /* SKU_ENABLED: %s */", offsetof, SkuTableIdx, token.getPrimaryKeyString());\r
+ }\r
+\r
+ private String getDataTypeInstantiationForVariableDefault (Token token, String cName, int skuId) {\r
+ return String.format("%s /* %s */", token.skuData.get(skuId).value.hiiDefaultValue, cName);\r
+ }\r
+\r
+ private String getCType (Token t) \r
+ throws EntityException {\r
+ \r
+ if (t.isHiiEnable()) {\r
+ return "VARIABLE_HEAD";\r
+ }\r
+ \r
+ if (t.isVpdEnable()) {\r
+ return "VPD_HEAD";\r
+ }\r
+ \r
+ if (t.isUnicodeStringType()) {\r
+ return "STRING_HEAD";\r
+ }\r
+ \r
+ switch (t.datumType) {\r
+ case UINT64:\r
+ return "UINT64";\r
+ case UINT32:\r
+ return "UINT32";\r
+ case UINT16:\r
+ return "UINT16";\r
+ case UINT8:\r
+ return "UINT8";\r
+ case BOOLEAN:\r
+ return "BOOLEAN";\r
+ case POINTER:\r
+ return "UINT8";\r
+ default:\r
+ throw new EntityException("Unknown type in getDataTypeCDeclaration");\r
+ }\r
+ }\r
+ \r
+ //\r
+ // privateGlobalName and privateGlobalCCode is used to pass output to caller of getCDeclarationString\r
+ //\r
+ private void getCDeclarationString(Token t) \r
+ throws EntityException {\r
+ \r
+ if (t.isSkuEnable()) {\r
+ privateGlobalName = String.format("%s_%s", t.getPrimaryKeyString(), skuDataTableTemplate);\r
+ } else {\r
+ privateGlobalName = t.getPrimaryKeyString();\r
+ }\r
+\r
+ String type = getCType(t);\r
+ if ((t.datumType == Token.DATUM_TYPE.POINTER) && (!t.isHiiEnable()) && (!t.isUnicodeStringType())) {\r
+ int bufferSize;\r
+ if (t.isASCIIStringType()) {\r
+ //\r
+ // Build tool will add a NULL string at the end of the ASCII string\r
+ //\r
+ bufferSize = t.datumSize + 1;\r
+ } else {\r
+ bufferSize = t.datumSize;\r
+ }\r
+ privateGlobalCCode = String.format("%-20s%s[%d][%d];\r\n", type, privateGlobalName, t.getSkuIdCount(), bufferSize);\r
+ } else {\r
+ privateGlobalCCode = String.format("%-20s%s[%d];\r\n", type, privateGlobalName, t.getSkuIdCount());\r
+ }\r
+ }\r
+ \r
+ private String getDataTypeDeclarationForVariableDefault (Token token, String cName, int skuId) \r
+ throws EntityException {\r
+\r
+ String typeStr;\r
+\r
+ if (token.datumType == Token.DATUM_TYPE.UINT8) {\r
+ typeStr = "UINT8";\r
+ } else if (token.datumType == Token.DATUM_TYPE.UINT16) {\r
+ typeStr = "UINT16";\r
+ } else if (token.datumType == Token.DATUM_TYPE.UINT32) {\r
+ typeStr = "UINT32";\r
+ } else if (token.datumType == Token.DATUM_TYPE.UINT64) {\r
+ typeStr = "UINT64";\r
+ } else if (token.datumType == Token.DATUM_TYPE.BOOLEAN) {\r
+ typeStr = "BOOLEAN";\r
+ } else if (token.datumType == Token.DATUM_TYPE.POINTER) {\r
+ int size;\r
+ if (token.isHiiDefaultValueUnicodeStringType()) {\r
+ typeStr = "UINT16";\r
+ //\r
+ // Include the NULL charactor\r
+ //\r
+ size = token.datumSize / 2 + 1;\r
+ } else {\r
+ typeStr = "UINT8";\r
+ if (token.isHiiDefaultValueASCIIStringType()) {\r
+ //\r
+ // Include the NULL charactor\r
+ //\r
+ size = token.datumSize + 1;\r
+ } else {\r
+ size = token.datumSize;\r
+ }\r
+ }\r
+ return String.format("%-20s%s[%d];\r\n", typeStr, cName, size);\r
+ } else {\r
+ throw new EntityException("Unknown DATUM_TYPE type in when generating code for VARIABLE_ENABLED PCD entry");\r
+ }\r
+\r
+ return String.format("%-20s%s;\r\n", typeStr, cName);\r
+ }\r
+ \r
+ private String getTypeInstantiation (Token t, ArrayList<CStructTypeDeclaration> declaList, HashMap<String, String> instTable, String phase) throws EntityException {\r
+ \r
+ int i;\r
+\r
+ String s;\r
+ s = String.format("/* %s */", t.getPrimaryKeyString()) + newLine;\r
+ s += tab + "{" + newLine;\r
+\r
+ for (i = 0; i < t.skuData.size(); i++) {\r
+ if (t.isUnicodeStringType()) {\r
+ s += tab + tab + String.format("{ %d }", stringTable.add(t.skuData.get(i).value.value, t));\r
+ } else if (t.isHiiEnable()) {\r
+ /* VPD_HEAD definition\r
+ typedef struct {\r
+ UINT16 GuidTableIndex; // Offset in Guid Table in units of GUID.\r
+ UINT16 StringIndex; // Offset in String Table in units of UINT16.\r
+ UINT16 Offset; // Offset in Variable\r
+ UINT16 DefaultValueOffset; // Offset of the Default Value\r
+ } VARIABLE_HEAD ;\r
+ */\r
+ String variableDefaultName = String.format("%s_VariableDefault_%d", t.getPrimaryKeyString(), i); \r
+ \r
+ s += tab + tab + String.format("{ %d, %d, %s, %s }", guidTable.add(t.skuData.get(i).value.variableGuid, t.getPrimaryKeyString()),\r
+ stringTable.add(t.skuData.get(i).value.getStringOfVariableName(), t),\r
+ t.skuData.get(i).value.variableOffset,\r
+ String.format("offsetof(%s_PCD_DATABASE, Init.%s)", phase, variableDefaultName)\r
+ );\r
+ //\r
+ // We need to support the default value, so we add the declaration and\r
+ // the instantiation for the default value.\r
+ //\r
+ CStructTypeDeclaration decl = new CStructTypeDeclaration (variableDefaultName,\r
+ getHiiPtrTypeAlignmentSize(t),\r
+ getDataTypeDeclarationForVariableDefault(t, variableDefaultName, i),\r
+ true\r
+ ); \r
+ declaList.add(decl);\r
+ instTable.put(variableDefaultName, getDataTypeInstantiationForVariableDefault (t, variableDefaultName, i));\r
+ } else if (t.isVpdEnable()) {\r
+ /* typedef struct {\r
+ UINT32 Offset;\r
+ } VPD_HEAD;\r
+ */\r
+ s += tab + tab + String.format("{ %s }", t.skuData.get(i).value.vpdOffset);\r
+ } else {\r
+ if (t.isByteStreamType()) {\r
+ //\r
+ // Byte stream type input has their own "{" "}", so we won't help to insert.\r
+ //\r
+ s += tab + tab + String.format(" %s ", t.skuData.get(i).value.value);\r
+ } else {\r
+ s += tab + tab + String.format("{ %s }", t.skuData.get(i).value.value);\r
+ }\r
+ }\r
+ \r
+ if (i != t.skuData.size() - 1) {\r
+ s += commaNewLine;\r
+ } else {\r
+ s += newLine;\r
+ }\r
+\r
+ }\r
+ \r
+ s += tab + "}";\r
+ \r
+ return s;\r
+ }\r
+ \r
+ public static String getPcdDatabaseCommonDefinitions () \r
+ throws EntityException {\r
+\r
+ String retStr = "";\r
+ try {\r
+ File file = new File(GlobalData.getWorkspacePath() + File.separator + \r
+ "Tools" + File.separator + \r
+ "Conf" + File.separator +\r
+ "Pcd" + File.separator +\r
+ "PcdDatabaseCommonDefinitions.sample");\r
+ FileReader reader = new FileReader(file);\r
+ BufferedReader in = new BufferedReader(reader);\r
+ String str;\r
+ while ((str = in.readLine()) != null) {\r
+ retStr = retStr +"\r\n" + str;\r
+ }\r
+ } catch (Exception ex) {\r
+ throw new EntityException("Fatal error when generating PcdDatabase Common Definitions");\r
+ }\r
+\r
+ return retStr;\r
+ }\r
+\r
+ public static String getPcdDxeDatabaseDefinitions () \r
+ throws EntityException {\r
+\r
+ String retStr = "";\r
+ try {\r
+ File file = new File(GlobalData.getWorkspacePath() + File.separator + \r
+ "Tools" + File.separator + \r
+ "Conf" + File.separator +\r
+ "Pcd" + File.separator +\r
+ "PcdDatabaseDxeDefinitions.sample");\r
+ FileReader reader = new FileReader(file);\r
+ BufferedReader in = new BufferedReader(reader);\r
+ String str;\r
+ while ((str = in.readLine()) != null) {\r
+ retStr = retStr +"\r\n" + str;\r
+ }\r
+ } catch (Exception ex) {\r
+ throw new EntityException("Fatal error when generating PcdDatabase Dxe Definitions");\r
+ }\r
+\r
+ return retStr;\r
+ }\r
+\r
+ public static String getPcdPeiDatabaseDefinitions () \r
+ throws EntityException {\r
+\r
+ String retStr = "";\r
+ try {\r
+ File file = new File(GlobalData.getWorkspacePath() + File.separator + \r
+ "Tools" + File.separator + \r
+ "Conf" + File.separator +\r
+ "Pcd" + File.separator +\r
+ "PcdDatabasePeiDefinitions.sample");\r
+ FileReader reader = new FileReader(file);\r
+ BufferedReader in = new BufferedReader(reader);\r
+ String str;\r
+ while ((str = in.readLine()) != null) {\r
+ retStr = retStr +"\r\n" + str;\r
+ }\r
+ } catch (Exception ex) {\r
+ throw new EntityException("Fatal error when generating PcdDatabase Pei Definitions");\r
+ }\r
+\r
+ return retStr;\r
+ }\r
+\r
+ /**\r
+ Translate the schema string to UUID instance.\r
+ \r
+ In schema, the string of UUID is defined as following two types string:\r
+ 1) GuidArrayType: pattern = 0x[a-fA-F0-9]{1,8},( )*0x[a-fA-F0-9]{1,4},(\r
+ )*0x[a-fA-F0-9]{1,4}(,( )*\{)?(,?( )*0x[a-fA-F0-9]{1,2}){8}( )*(\})?\r
+ \r
+ 2) GuidNamingConvention: pattern =\r
+ [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}\r
+ \r
+ This function will convert string and create uuid instance.\r
+ \r
+ @param uuidString UUID string in XML file\r
+ \r
+ @return UUID UUID instance\r
+ **/\r
+ private UUID translateSchemaStringToUUID(String uuidString) \r
+ throws EntityException {\r
+ String temp;\r
+ String[] splitStringArray;\r
+ int index;\r
+ int chIndex;\r
+ int chLen;\r
+\r
+ if (uuidString == null) {\r
+ return null;\r
+ }\r
+\r
+ if (uuidString.length() == 0) {\r
+ return null;\r
+ }\r
+\r
+ if (uuidString.equals("0") ||\r
+ uuidString.equalsIgnoreCase("0x0")) {\r
+ return new UUID(0, 0);\r
+ }\r
+\r
+ uuidString = uuidString.replaceAll("\\{", "");\r
+ uuidString = uuidString.replaceAll("\\}", "");\r
+\r
+ //\r
+ // If the UUID schema string is GuidArrayType type then need translate \r
+ // to GuidNamingConvention type at first.\r
+ // \r
+ if ((uuidString.charAt(0) == '0') && ((uuidString.charAt(1) == 'x') || (uuidString.charAt(1) == 'X'))) {\r
+ splitStringArray = uuidString.split("," );\r
+ if (splitStringArray.length != 11) {\r
+ throw new EntityException ("[FPD file error] Wrong format for UUID string: " + uuidString);\r
+ }\r
+\r
+ //\r
+ // Remove blank space from these string and remove header string "0x"\r
+ // \r
+ for (index = 0; index < 11; index ++) {\r
+ splitStringArray[index] = splitStringArray[index].trim();\r
+ splitStringArray[index] = splitStringArray[index].substring(2, splitStringArray[index].length());\r
+ }\r
+\r
+ //\r
+ // Add heading '0' to normalize the string length\r
+ // \r
+ for (index = 3; index < 11; index ++) {\r
+ chLen = splitStringArray[index].length();\r
+ for (chIndex = 0; chIndex < 2 - chLen; chIndex ++) {\r
+ splitStringArray[index] = "0" + splitStringArray[index];\r
+ }\r
+ }\r
+\r
+ //\r
+ // construct the final GuidNamingConvention string\r
+ // \r
+ temp = String.format("%s-%s-%s-%s%s-%s%s%s%s%s%s",\r
+ splitStringArray[0],\r
+ splitStringArray[1],\r
+ splitStringArray[2],\r
+ splitStringArray[3],\r
+ splitStringArray[4],\r
+ splitStringArray[5],\r
+ splitStringArray[6],\r
+ splitStringArray[7],\r
+ splitStringArray[8],\r
+ splitStringArray[9],\r
+ splitStringArray[10]);\r
+ uuidString = temp;\r
+ }\r
+\r
+ return UUID.fromString(uuidString);\r
+ }\r
+}\r
+\r
+/** Module Info class is the data structure to hold information got from GlobalData.\r
+*/\r
+class ModuleInfo {\r
+ ///\r
+ /// Module's ID for a <ModuleSA>\r
+ /// \r
+ private FpdModuleIdentification moduleId;\r
+ ///\r
+ /// <PcdBuildDefinition> xmlobject in FPD file for a <ModuleSA>\r
+ /// \r
+ private PcdBuildDefinitionDocument.PcdBuildDefinition pcdBuildDef;\r
+\r
+ public ModuleInfo (FpdModuleIdentification moduleId, XmlObject pcdDef) {\r
+ this.moduleId = moduleId;\r
+ this.pcdBuildDef = ((PcdBuildDefinitionDocument)pcdDef).getPcdBuildDefinition();\r
+ }\r
+\r
+ public FpdModuleIdentification getModuleId (){\r
+ return moduleId;\r
+ }\r
+\r
+ public PcdBuildDefinitionDocument.PcdBuildDefinition getPcdBuildDef(){\r
+ return pcdBuildDef;\r
+ }\r
+}\r
+\r
+/** This action class is to collect PCD information from MSA, SPD, FPD xml file.\r
+ This class will be used for wizard and build tools, So it can *not* inherit\r
+ from buildAction or UIAction.\r
+**/\r
+public class CollectPCDAction {\r
+ ///\r
+ /// memoryDatabase hold all PCD information collected from SPD, MSA, FPD.\r
+ /// \r
+ private MemoryDatabaseManager dbManager;\r
+ ///\r
+ /// Workspacepath hold the workspace information.\r
+ /// \r
+ private String workspacePath;\r
+ ///\r
+ /// FPD file is the root file. \r
+ /// \r
+ private String fpdFilePath;\r
+ ///\r
+ /// Message level for CollectPCDAction.\r
+ /// \r
+ private int originalMessageLevel;\r
+ ///\r
+ /// Cache the fpd docment instance for private usage.\r
+ /// \r
+ private PlatformSurfaceAreaDocument fpdDocInstance;\r
+ ///\r
+ /// xmlObject name\r
+ /// \r
+ private static String xmlObjectName = "PcdBuildDefinition"; \r
+ \r
+ /**\r
+ Set WorkspacePath parameter for this action class.\r
+\r
+ @param workspacePath parameter for this action\r
+ **/\r
+ public void setWorkspacePath(String workspacePath) {\r
+ this.workspacePath = workspacePath;\r
+ }\r
+\r
+ /**\r
+ Set action message level for CollectPcdAction tool.\r
+\r
+ The message should be restored when this action exit.\r
+\r
+ @param actionMessageLevel parameter for this action\r
+ **/\r
+ public void setActionMessageLevel(int actionMessageLevel) {\r
+ originalMessageLevel = ActionMessage.messageLevel;\r
+ ActionMessage.messageLevel = actionMessageLevel;\r
+ }\r
+\r
+ /**\r
+ Set FPDFileName parameter for this action class.\r
+\r
+ @param fpdFilePath fpd file path\r
+ **/\r
+ public void setFPDFilePath(String fpdFilePath) {\r
+ this.fpdFilePath = fpdFilePath;\r
+ }\r
+\r
+ /**\r
+ Common function interface for outer.\r
+ \r
+ @param workspacePath The path of workspace of current build or analysis.\r
+ @param fpdFilePath The fpd file path of current build or analysis.\r
+ @param messageLevel The message level for this Action.\r
+ \r
+ @throws Exception The exception of this function. Because it can *not* be predict\r
+ where the action class will be used. So only Exception can be throw.\r
+ \r
+ **/\r
+ public void perform(String workspacePath, String fpdFilePath, \r
+ int messageLevel) throws Exception {\r
+ setWorkspacePath(workspacePath);\r
+ setFPDFilePath(fpdFilePath);\r
+ setActionMessageLevel(messageLevel);\r
+ checkParameter();\r
+ execute();\r
+ ActionMessage.messageLevel = originalMessageLevel;\r
+ }\r
+\r
+ /**\r
+ Core execution function for this action class.\r
+ \r
+ This function work flows will be:\r
+ 1) Collect and prepocess PCD information from FPD file, all PCD\r
+ information will be stored into memory database.\r
+ 2) Generate 3 strings for\r
+ a) All modules using Dynamic(Ex) PCD entry.(Token Number)\r
+ b) PEI PCDDatabase (C Structure) for PCD Service PEIM.\r
+ c) DXE PCD Database (C structure) for PCD Service DXE.\r
+ \r
+ \r
+ @throws EntityException Exception indicate failed to execute this action.\r
+ \r
+ **/\r
+ public void execute() throws EntityException {\r
+ //\r
+ // Get memoryDatabaseManager instance from GlobalData.\r
+ // The memoryDatabaseManager should be initialized for whatever build\r
+ // tools or wizard tools\r
+ //\r
+ if((dbManager = GlobalData.getPCDMemoryDBManager()) == null) {\r
+ throw new EntityException("The instance of PCD memory database manager is null");\r
+ }\r
+\r
+ //\r
+ // Collect all PCD information defined in FPD file.\r
+ // Evenry token defind in FPD will be created as an token into \r
+ // memory database.\r
+ //\r
+ createTokenInDBFromFPD();\r
+ \r
+ //\r
+ // Generate for PEI, DXE PCD DATABASE's definition and initialization.\r
+ //\r
+ genPcdDatabaseSourceCode ();\r
+ \r
+ }\r
+\r
+ /**\r
+ This function generates source code for PCD Database.\r
+ \r
+ @param void\r
+ @throws EntityException If the token does *not* exist in memory database.\r
+\r
+ **/\r
+ private void genPcdDatabaseSourceCode()\r
+ throws EntityException {\r
+ String PcdCommonHeaderString = PcdDatabase.getPcdDatabaseCommonDefinitions();\r
+\r
+ ArrayList<Token> alPei = new ArrayList<Token> ();\r
+ ArrayList<Token> alDxe = new ArrayList<Token> ();\r
+\r
+ dbManager.getTwoPhaseDynamicRecordArray(alPei, alDxe);\r
+ PcdDatabase pcdPeiDatabase = new PcdDatabase (alPei, "PEI", 0);\r
+ pcdPeiDatabase.genCode();\r
+ MemoryDatabaseManager.PcdPeimHString = PcdCommonHeaderString + pcdPeiDatabase.getHString() + \r
+ PcdDatabase.getPcdPeiDatabaseDefinitions();\r
+ MemoryDatabaseManager.PcdPeimCString = pcdPeiDatabase.getCString();\r
+\r
+ PcdDatabase pcdDxeDatabase = new PcdDatabase(alDxe, "DXE", alPei.size());\r
+ pcdDxeDatabase.genCode();\r
+ MemoryDatabaseManager.PcdDxeHString = MemoryDatabaseManager.PcdPeimHString + pcdDxeDatabase.getHString() + \r
+ PcdDatabase.getPcdDxeDatabaseDefinitions();\r
+ MemoryDatabaseManager.PcdDxeCString = pcdDxeDatabase.getCString();\r
+ }\r
+\r
+ /**\r
+ Get component array from FPD.\r
+ \r
+ This function maybe provided by some Global class.\r
+ \r
+ @return List<ModuleInfo> the component array.\r
+ \r
+ */\r
+ private List<ModuleInfo> getComponentsFromFPD() \r
+ throws EntityException {\r
+ List<ModuleInfo> allModules = new ArrayList<ModuleInfo>();\r
+ FrameworkModulesDocument.FrameworkModules fModules = null;\r
+ ModuleSADocument.ModuleSA[] modules = null;\r
+ Map<FpdModuleIdentification, XmlObject> pcdBuildDefinitions = null;\r
+\r
+ pcdBuildDefinitions = GlobalData.getFpdPcdBuildDefinitions();\r
+ if (pcdBuildDefinitions == null) {\r
+ return null;\r
+ }\r
+\r
+ //\r
+ // Loop map to retrieve all PCD build definition and Module id \r
+ // \r
+ Iterator item = pcdBuildDefinitions.keySet().iterator();\r
+ while (item.hasNext()){\r
+ FpdModuleIdentification id = (FpdModuleIdentification) item.next();\r
+ allModules.add(new ModuleInfo(id, pcdBuildDefinitions.get(id))); \r
+ }\r
+ \r
+ return allModules;\r
+ }\r
+\r
+ /**\r
+ Create token instance object into memory database, the token information\r
+ comes for FPD file. Normally, FPD file will contain all token platform \r
+ informations.\r
+ \r
+ @return FrameworkPlatformDescriptionDocument The FPD document instance for furture usage.\r
+ \r
+ @throws EntityException Failed to parse FPD xml file.\r
+ \r
+ **/\r
+ private void createTokenInDBFromFPD() \r
+ throws EntityException {\r
+ int index = 0;\r
+ int index2 = 0;\r
+ int pcdIndex = 0;\r
+ List<PcdBuildDefinition.PcdData> pcdBuildDataArray = new ArrayList<PcdBuildDefinition.PcdData>();\r
+ PcdBuildDefinition.PcdData pcdBuildData = null;\r
+ Token token = null;\r
+ List<ModuleInfo> modules = null;\r
+ String primaryKey = null;\r
+ String exceptionString = null;\r
+ UsageInstance usageInstance = null;\r
+ String primaryKey1 = null;\r
+ String primaryKey2 = null;\r
+ boolean isDuplicate = false;\r
+ Token.PCD_TYPE pcdType = Token.PCD_TYPE.UNKNOWN;\r
+ Token.DATUM_TYPE datumType = Token.DATUM_TYPE.UNKNOWN;\r
+ long tokenNumber = 0;\r
+ String moduleName = null;\r
+ String datum = null;\r
+ int maxDatumSize = 0;\r
+ String[] tokenSpaceStrRet = null;\r
+ UsageIdentification usageId = null;\r
+ ModuleIdentification moduleId = null;\r
+\r
+ //\r
+ // ----------------------------------------------\r
+ // 1), Get all <ModuleSA> from FPD file.\r
+ // ----------------------------------------------\r
+ // \r
+ modules = getComponentsFromFPD();\r
+\r
+ if (modules == null) {\r
+ throw new EntityException("[FPD file error] No modules in FPD file, Please check whether there are elements in <FrameworkModules> in FPD file!");\r
+ }\r
+\r
+ //\r
+ // -------------------------------------------------------------------\r
+ // 2), Loop all modules to process <PcdBuildDeclarations> for each module.\r
+ // -------------------------------------------------------------------\r
+ // \r
+ for (index = 0; index < modules.size(); index ++) {\r
+ //\r
+ // It is legal for a module does not contains ANY pcd build definitions.\r
+ // \r
+ if (modules.get(index).getPcdBuildDef() == null) {\r
+ continue;\r
+ }\r
+ \r
+ pcdBuildDataArray = modules.get(index).getPcdBuildDef().getPcdDataList();\r
+\r
+ moduleName = modules.get(index).getModuleId().getModule().getName();\r
+\r
+ //\r
+ // ----------------------------------------------------------------------\r
+ // 2.1), Loop all Pcd entry for a module and add it into memory database.\r
+ // ----------------------------------------------------------------------\r
+ // \r
+ for (pcdIndex = 0; pcdIndex < pcdBuildDataArray.size(); pcdIndex ++) {\r
+ pcdBuildData = pcdBuildDataArray.get(pcdIndex);\r
+ \r
+ try {\r
+ tokenSpaceStrRet = GlobalData.getGuidInfoFromCname(pcdBuildData.getTokenSpaceGuidCName());\r
+ } catch ( Exception e ) {\r
+ throw new EntityException ("Faile get Guid for token " + pcdBuildData.getCName() + ":" + e.getMessage());\r
+ }\r
+\r
+ if (tokenSpaceStrRet == null) {\r
+ throw new EntityException ("Fail to get Token space guid for token" + pcdBuildData.getCName());\r
+ } \r
+\r
+ primaryKey = Token.getPrimaryKeyString(pcdBuildData.getCName(), tokenSpaceStrRet[1]);\r
+ pcdType = Token.getpcdTypeFromString(pcdBuildData.getItemType().toString());\r
+ datumType = Token.getdatumTypeFromString(pcdBuildData.getDatumType().toString());\r
+ tokenNumber = Long.decode(pcdBuildData.getToken().toString());\r
+ if (pcdBuildData.getValue() != null) {\r
+ datum = pcdBuildData.getValue().toString();\r
+ } else {\r
+ datum = null;\r
+ }\r
+ maxDatumSize = pcdBuildData.getMaxDatumSize();\r
+\r
+ if ((pcdType == Token.PCD_TYPE.FEATURE_FLAG) &&\r
+ (datumType != Token.DATUM_TYPE.BOOLEAN)){\r
+ exceptionString = String.format("[FPD file error] For PCD %s in module %s, the PCD type is FEATRUE_FLAG but "+\r
+ "datum type of this PCD entry is not BOOLEAN!",\r
+ pcdBuildData.getCName(),\r
+ moduleName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ //\r
+ // -------------------------------------------------------------------------------------------\r
+ // 2.1.1), Do some necessary checking work for FixedAtBuild, FeatureFlag and PatchableInModule\r
+ // -------------------------------------------------------------------------------------------\r
+ // \r
+ if (!Token.isDynamic(pcdType)) {\r
+ //\r
+ // Value is required.\r
+ // \r
+ if (datum == null) {\r
+ exceptionString = String.format("[FPD file error] There is no value for PCD entry %s in module %s!",\r
+ pcdBuildData.getCName(),\r
+ moduleName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ //\r
+ // Check whether the datum size is matched datum type.\r
+ // \r
+ if ((exceptionString = verifyDatum(pcdBuildData.getCName(), \r
+ moduleName,\r
+ datum,\r
+ datumType,\r
+ maxDatumSize)) != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+\r
+ //\r
+ // ---------------------------------------------------------------------------------\r
+ // 2.1.2), Create token or update token information for current anaylized PCD data.\r
+ // ---------------------------------------------------------------------------------\r
+ // \r
+ if (dbManager.isTokenInDatabase(primaryKey)) {\r
+ //\r
+ // If the token is already exist in database, do some necessary checking\r
+ // and add a usage instance into this token in database\r
+ // \r
+ token = dbManager.getTokenByKey(primaryKey);\r
+ \r
+ //\r
+ // checking for DatumType, DatumType should be unique for one PCD used in different\r
+ // modules.\r
+ // \r
+ if (token.datumType != datumType) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD entry %s is %s, which is different with %s defined in before!",\r
+ pcdBuildData.getCName(), \r
+ pcdBuildData.getDatumType().toString(), \r
+ Token.getStringOfdatumType(token.datumType));\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ //\r
+ // Check token number is valid\r
+ // \r
+ if (tokenNumber != token.tokenNumber) {\r
+ exceptionString = String.format("[FPD file error] The token number of PCD entry %s in module %s is different with same PCD entry in other modules!",\r
+ pcdBuildData.getCName(),\r
+ moduleName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ //\r
+ // For same PCD used in different modules, the PCD type should all be dynamic or non-dynamic.\r
+ // \r
+ if (token.isDynamicPCD != Token.isDynamic(pcdType)) {\r
+ exceptionString = String.format("[FPD file error] For PCD entry %s in module %s, you define dynamic or non-dynamic PCD type which"+\r
+ "is different with others module's",\r
+ token.cName,\r
+ moduleName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ if (token.isDynamicPCD) {\r
+ //\r
+ // Check datum is equal the datum in dynamic information.\r
+ // For dynamic PCD, you can do not write <Value> in sperated every <PcdBuildDefinition> in different <ModuleSA>,\r
+ // But if you write, the <Value> must be same as the value in <DynamicPcdBuildDefinitions>.\r
+ // \r
+ if (!token.isSkuEnable() && \r
+ (token.getDefaultSku().type == DynamicTokenValue.VALUE_TYPE.DEFAULT_TYPE) &&\r
+ (datum != null)) {\r
+ if (!datum.equalsIgnoreCase(token.getDefaultSku().value)) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in module %s, the datum in <ModuleSA> is "+\r
+ "not equal to the datum in <DynamicPcdBuildDefinitions>, it is "+\r
+ "illega! You could no set <Value> in <ModuleSA> for a dynamic PCD!",\r
+ token.cName,\r
+ moduleName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+\r
+ if ((maxDatumSize != 0) &&\r
+ (maxDatumSize != token.datumSize)){\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in module %s, the max datum size is %d which "+\r
+ "is different with <MaxDatumSize> %d defined in <DynamicPcdBuildDefinitions>!",\r
+ token.cName,\r
+ moduleName,\r
+ maxDatumSize,\r
+ token.datumSize);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+ \r
+ } else {\r
+ //\r
+ // If the token is not in database, create a new token instance and add\r
+ // a usage instance into this token in database.\r
+ // \r
+ try {\r
+ tokenSpaceStrRet = GlobalData.getGuidInfoFromCname(pcdBuildData.getTokenSpaceGuidCName());\r
+ } catch (Exception e) {\r
+ throw new EntityException("Fail to get token space guid for token " + token.cName);\r
+ }\r
+\r
+ if (tokenSpaceStrRet == null) {\r
+ throw new EntityException("Fail to get token space guid for token " + token.cName);\r
+ }\r
+\r
+ token = new Token(pcdBuildData.getCName(), tokenSpaceStrRet[1]);\r
+ \r
+ token.datumType = datumType;\r
+ token.tokenNumber = tokenNumber;\r
+ token.isDynamicPCD = Token.isDynamic(pcdType);\r
+ token.datumSize = maxDatumSize;\r
+ \r
+ if (token.isDynamicPCD) {\r
+ //\r
+ // For Dynamic and Dynamic Ex type, need find the dynamic information\r
+ // in <DynamicPcdBuildDefinition> section in FPD file.\r
+ // \r
+ updateDynamicInformation(moduleName, \r
+ token,\r
+ datum,\r
+ maxDatumSize);\r
+ }\r
+ \r
+ dbManager.addTokenToDatabase(primaryKey, token);\r
+ }\r
+\r
+ //\r
+ // -----------------------------------------------------------------------------------\r
+ // 2.1.3), Add the PcdType in current module into this Pcd token's supported PCD type.\r
+ // -----------------------------------------------------------------------------------\r
+ // \r
+ token.updateSupportPcdType(pcdType);\r
+\r
+ //\r
+ // ------------------------------------------------\r
+ // 2.1.4), Create an usage instance for this token.\r
+ // ------------------------------------------------\r
+ // \r
+ moduleId = modules.get(index).getModuleId().getModule();\r
+ usageId = new UsageIdentification (moduleId.getName(), \r
+ moduleId.getGuid(), \r
+ moduleId.getPackage().getName(), \r
+ moduleId.getPackage().getGuid(), \r
+ modules.get(index).getModuleId().getArch(),\r
+ moduleId.getVersion(),\r
+ moduleId.getModuleType());\r
+ usageInstance = new UsageInstance(token, \r
+ usageId,\r
+ pcdType,\r
+ datum,\r
+ maxDatumSize);\r
+ token.addUsageInstance(usageInstance);\r
+ }\r
+ }\r
+\r
+ //\r
+ // ------------------------------------------------\r
+ // 3), Add unreference dynamic_Ex pcd token into Pcd database.\r
+ // ------------------------------------------------\r
+ // \r
+ List<Token> tokenArray = getUnreferencedDynamicPcd();\r
+ if (tokenArray != null) {\r
+ for (index = 0; index < tokenArray.size(); index ++) {\r
+ dbManager.addTokenToDatabase(tokenArray.get(index).getPrimaryKeyString(), \r
+ tokenArray.get(index));\r
+ }\r
+ }\r
+ }\r
+\r
+ private List<Token> getUnreferencedDynamicPcd () throws EntityException {\r
+ List<Token> tokenArray = new ArrayList<Token>();\r
+ Token token = null;\r
+ DynamicPcdBuildDefinitions dynamicPcdBuildDefinitions = null;\r
+ List<DynamicPcdBuildDefinitions.PcdBuildData> dynamicPcdBuildDataArray = null;\r
+ DynamicPcdBuildDefinitions.PcdBuildData pcdBuildData = null;\r
+ List<DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo> skuInfoList = null;\r
+ Token.PCD_TYPE pcdType;\r
+ SkuInstance skuInstance = null;\r
+ String primaryKey = null;\r
+ boolean hasSkuId0 = false;\r
+ int index, offset, index2;\r
+ String temp;\r
+ String exceptionString;\r
+ String hiiDefaultValue;\r
+ String tokenSpaceStrRet[];\r
+ String variableGuidString[];\r
+\r
+ //\r
+ // Open fpd document to get <DynamicPcdBuildDefinition> Section.\r
+ // BUGBUG: the function should be move GlobalData in furture.\r
+ // \r
+ if (fpdDocInstance == null) {\r
+ try {\r
+ fpdDocInstance = (PlatformSurfaceAreaDocument)XmlObject.Factory.parse(new File(fpdFilePath));\r
+ } catch(IOException ioE) {\r
+ throw new EntityException("File IO error for xml file:" + fpdFilePath + "\n" + ioE.getMessage());\r
+ } catch(XmlException xmlE) {\r
+ throw new EntityException("Can't parse the FPD xml fle:" + fpdFilePath + "\n" + xmlE.getMessage());\r
+ }\r
+ }\r
+\r
+ dynamicPcdBuildDefinitions = fpdDocInstance.getPlatformSurfaceArea().getDynamicPcdBuildDefinitions();\r
+ if (dynamicPcdBuildDefinitions == null) {\r
+ return null;\r
+ }\r
+\r
+ dynamicPcdBuildDataArray = dynamicPcdBuildDefinitions.getPcdBuildDataList();\r
+ for (index2 = 0; index2 < dynamicPcdBuildDataArray.size(); index2 ++) {\r
+ pcdBuildData = dynamicPcdBuildDataArray.get(index2);\r
+ try {\r
+ tokenSpaceStrRet = GlobalData.getGuidInfoFromCname(pcdBuildData.getTokenSpaceGuidCName());\r
+ } catch ( Exception e ) {\r
+ throw new EntityException ("Faile get Guid for token " + pcdBuildData.getCName() + ":" + e.getMessage());\r
+ }\r
+\r
+ if (tokenSpaceStrRet == null) {\r
+ throw new EntityException ("Fail to get Token space guid for token" + pcdBuildData.getCName());\r
+ } \r
+\r
+ primaryKey = Token.getPrimaryKeyString(pcdBuildData.getCName(),\r
+ tokenSpaceStrRet[1]);\r
+\r
+ if (dbManager.isTokenInDatabase(primaryKey)) {\r
+ continue;\r
+ }\r
+\r
+ pcdType = Token.getpcdTypeFromString(pcdBuildData.getItemType().toString());\r
+ if (pcdType != Token.PCD_TYPE.DYNAMIC_EX) {\r
+ throw new EntityException (String.format("[FPD file error] It not allowed for DYNAMIC PCD %s who is no used by any module",\r
+ pcdBuildData.getCName()));\r
+ }\r
+\r
+ //\r
+ // Create new token for unreference dynamic PCD token\r
+ // \r
+ token = new Token(pcdBuildData.getCName(), tokenSpaceStrRet[1]);\r
+ token.datumSize = pcdBuildData.getMaxDatumSize();\r
+ \r
+\r
+ token.datumType = Token.getdatumTypeFromString(pcdBuildData.getDatumType().toString());\r
+ token.tokenNumber = Long.decode(pcdBuildData.getToken().toString());\r
+ token.dynamicExTokenNumber = token.tokenNumber;\r
+ token.isDynamicPCD = true; \r
+ token.updateSupportPcdType(pcdType);\r
+\r
+ exceptionString = verifyDatum(token.cName, \r
+ null,\r
+ null, \r
+ token.datumType, \r
+ token.datumSize);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ skuInfoList = pcdBuildData.getSkuInfoList();\r
+\r
+ //\r
+ // Loop all sku data \r
+ // \r
+ for (index = 0; index < skuInfoList.size(); index ++) {\r
+ skuInstance = new SkuInstance();\r
+ //\r
+ // Although SkuId in schema is BigInteger, but in fact, sku id is 32 bit value.\r
+ // \r
+ temp = skuInfoList.get(index).getSkuId().toString();\r
+ skuInstance.id = Integer.decode(temp);\r
+ if (skuInstance.id == 0) {\r
+ hasSkuId0 = true;\r
+ }\r
+ //\r
+ // Judge whether is DefaultGroup at first, because most case is DefautlGroup.\r
+ // \r
+ if (skuInfoList.get(index).getValue() != null) {\r
+ skuInstance.value.setValue(skuInfoList.get(index).getValue().toString());\r
+ if ((exceptionString = verifyDatum(token.cName, \r
+ null, \r
+ skuInfoList.get(index).getValue().toString(), \r
+ token.datumType, \r
+ token.datumSize)) != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ token.skuData.add(skuInstance);\r
+\r
+ continue;\r
+ }\r
+\r
+ //\r
+ // Judge whether is HII group case.\r
+ // \r
+ if (skuInfoList.get(index).getVariableName() != null) {\r
+ exceptionString = null;\r
+ if (skuInfoList.get(index).getVariableGuid() == null) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+\r
+ "file, who use HII, but there is no <VariableGuid> defined for Sku %d data!",\r
+ token.cName,\r
+ index);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ } \r
+ }\r
+\r
+ if (skuInfoList.get(index).getVariableOffset() == null) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+\r
+ "file, who use HII, but there is no <VariableOffset> defined for Sku %d data!",\r
+ token.cName,\r
+ index);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+\r
+ if (skuInfoList.get(index).getHiiDefaultValue() == null) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+\r
+ "file, who use HII, but there is no <HiiDefaultValue> defined for Sku %d data!",\r
+ token.cName,\r
+ index);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+\r
+ if (skuInfoList.get(index).getHiiDefaultValue() != null) {\r
+ hiiDefaultValue = skuInfoList.get(index).getHiiDefaultValue().toString();\r
+ } else {\r
+ hiiDefaultValue = null;\r
+ }\r
+\r
+ if ((exceptionString = verifyDatum(token.cName, \r
+ null, \r
+ hiiDefaultValue, \r
+ token.datumType, \r
+ token.datumSize)) != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ offset = Integer.decode(skuInfoList.get(index).getVariableOffset());\r
+ if (offset > 0xFFFF) {\r
+ throw new EntityException(String.format("[FPD file error] For dynamic PCD %s , the variable offset defined in sku %d data "+\r
+ "exceed 64K, it is not allowed!",\r
+ token.cName,\r
+ index));\r
+ }\r
+\r
+ //\r
+ // Get variable guid string according to the name of guid which will be mapped into a GUID in SPD file.\r
+ // \r
+ variableGuidString = GlobalData.getGuidInfoFromCname(skuInfoList.get(index).getVariableGuid().toString());\r
+ if (variableGuidString == null) {\r
+ throw new EntityException(String.format("[GUID Error] For dynamic PCD %s, the variable guid %s can be found in all SPD file!",\r
+ token.cName, \r
+ skuInfoList.get(index).getVariableGuid().toString()));\r
+ }\r
+ String variableStr = skuInfoList.get(index).getVariableName();\r
+ Pattern pattern = Pattern.compile("0x([a-fA-F0-9]){4}");\r
+ Matcher matcher = pattern.matcher(variableStr);\r
+ List<String> varNameList = new ArrayList<String>();\r
+ while (matcher.find()){\r
+ String str = variableStr.substring(matcher.start(),matcher.end());\r
+ varNameList.add(str);\r
+ }\r
+\r
+ skuInstance.value.setHiiData(varNameList,\r
+ translateSchemaStringToUUID(variableGuidString[1]),\r
+ skuInfoList.get(index).getVariableOffset(),\r
+ skuInfoList.get(index).getHiiDefaultValue().toString());\r
+ token.skuData.add(skuInstance);\r
+ continue;\r
+ }\r
+\r
+ if (skuInfoList.get(index).getVpdOffset() != null) {\r
+ skuInstance.value.setVpdData(skuInfoList.get(index).getVpdOffset());\r
+ token.skuData.add(skuInstance);\r
+ continue;\r
+ }\r
+\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s, the dynamic info must "+\r
+ "be one of 'DefaultGroup', 'HIIGroup', 'VpdGroup'.",\r
+ token.cName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ if (!hasSkuId0) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions>, there are "+\r
+ "no sku id = 0 data, which is required for every dynamic PCD",\r
+ token.cName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ tokenArray.add(token);\r
+ }\r
+\r
+ return tokenArray;\r
+ }\r
+\r
+ /**\r
+ Verify the datum value according its datum size and datum type, this\r
+ function maybe moved to FPD verification tools in future.\r
+ \r
+ @param cName\r
+ @param moduleName\r
+ @param datum\r
+ @param datumType\r
+ @param maxDatumSize\r
+ \r
+ @return String\r
+ */\r
+ /***/\r
+ public String verifyDatum(String cName,\r
+ String moduleName,\r
+ String datum, \r
+ Token.DATUM_TYPE datumType, \r
+ int maxDatumSize) {\r
+ String exceptionString = null;\r
+ int value;\r
+ BigInteger value64;\r
+ String subStr;\r
+ int index;\r
+\r
+ if (moduleName == null) {\r
+ moduleName = "section <DynamicPcdBuildDefinitions>";\r
+ } else {\r
+ moduleName = "module " + moduleName;\r
+ }\r
+\r
+ if (maxDatumSize == 0) {\r
+ exceptionString = String.format("[FPD file error] You maybe miss <MaxDatumSize> for PCD %s in %s",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+\r
+ switch (datumType) {\r
+ case UINT8:\r
+ if (maxDatumSize != 1) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+\r
+ "is UINT8, but datum size is %d, they are not matched!",\r
+ cName,\r
+ moduleName,\r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+\r
+ if (datum != null) {\r
+ try {\r
+ value = Integer.decode(datum);\r
+ } catch (NumberFormatException nfeExp) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not valid "+\r
+ "digital format of UINT8",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+ if (value > 0xFF) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s exceed"+\r
+ " the max size of UINT8 - 0xFF",\r
+ cName, \r
+ moduleName,\r
+ datum);\r
+ return exceptionString;\r
+ }\r
+ }\r
+ break;\r
+ case UINT16:\r
+ if (maxDatumSize != 2) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+\r
+ "is UINT16, but datum size is %d, they are not matched!",\r
+ cName,\r
+ moduleName,\r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+ if (datum != null) {\r
+ try {\r
+ value = Integer.decode(datum);\r
+ } catch (NumberFormatException nfeExp) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is "+\r
+ "not valid digital of UINT16",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+ if (value > 0xFFFF) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s "+\r
+ "which exceed the range of UINT16 - 0xFFFF",\r
+ cName, \r
+ moduleName,\r
+ datum);\r
+ return exceptionString;\r
+ }\r
+ }\r
+ break;\r
+ case UINT32:\r
+ if (maxDatumSize != 4) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+\r
+ "is UINT32, but datum size is %d, they are not matched!",\r
+ cName,\r
+ moduleName,\r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+\r
+ if (datum != null) {\r
+ try {\r
+ if (datum.length() > 2) {\r
+ if ((datum.charAt(0) == '0') && \r
+ ((datum.charAt(1) == 'x') || (datum.charAt(1) == 'X'))){\r
+ subStr = datum.substring(2, datum.length());\r
+ value64 = new BigInteger(subStr, 16);\r
+ } else {\r
+ value64 = new BigInteger(datum);\r
+ }\r
+ } else {\r
+ value64 = new BigInteger(datum);\r
+ }\r
+ } catch (NumberFormatException nfeExp) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not "+\r
+ "valid digital of UINT32",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+\r
+ if (value64.bitLength() > 32) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s which "+\r
+ "exceed the range of UINT32 - 0xFFFFFFFF",\r
+ cName, \r
+ moduleName,\r
+ datum);\r
+ return exceptionString;\r
+ }\r
+ }\r
+ break;\r
+ case UINT64:\r
+ if (maxDatumSize != 8) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+\r
+ "is UINT64, but datum size is %d, they are not matched!",\r
+ cName,\r
+ moduleName,\r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+\r
+ if (datum != null) {\r
+ try {\r
+ if (datum.length() > 2) {\r
+ if ((datum.charAt(0) == '0') && \r
+ ((datum.charAt(1) == 'x') || (datum.charAt(1) == 'X'))){\r
+ subStr = datum.substring(2, datum.length());\r
+ value64 = new BigInteger(subStr, 16);\r
+ } else {\r
+ value64 = new BigInteger(datum);\r
+ }\r
+ } else {\r
+ value64 = new BigInteger(datum);\r
+ }\r
+ } catch (NumberFormatException nfeExp) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is not valid"+\r
+ " digital of UINT64",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+\r
+ if (value64.bitLength() > 64) {\r
+ exceptionString = String.format("[FPD file error] The datum for PCD %s in %s is %s "+\r
+ "exceed the range of UINT64 - 0xFFFFFFFFFFFFFFFF",\r
+ cName, \r
+ moduleName,\r
+ datum);\r
+ return exceptionString;\r
+ }\r
+ }\r
+ break;\r
+ case BOOLEAN:\r
+ if (maxDatumSize != 1) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+\r
+ "is BOOLEAN, but datum size is %d, they are not matched!",\r
+ cName,\r
+ moduleName,\r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+\r
+ if (datum != null) {\r
+ if (!(datum.equalsIgnoreCase("TRUE") ||\r
+ datum.equalsIgnoreCase("FALSE"))) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD data %s in %s "+\r
+ "is BOOELAN, but value is not 'true'/'TRUE' or 'FALSE'/'false'",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+\r
+ }\r
+ break;\r
+ case POINTER:\r
+ if (datum == null) {\r
+ break;\r
+ }\r
+\r
+ char ch = datum.charAt(0);\r
+ int start, end;\r
+ String strValue;\r
+ //\r
+ // For void* type PCD, only three datum is support:\r
+ // 1) Unicode: string with start char is "L"\r
+ // 2) Ansci: String start char is ""\r
+ // 3) byte array: String start char "{"\r
+ // \r
+ if (ch == 'L') {\r
+ start = datum.indexOf('\"');\r
+ end = datum.lastIndexOf('\"');\r
+ if ((start > end) || \r
+ (end > datum.length())||\r
+ ((start == end) && (datum.length() > 0))) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID* and datum is "+\r
+ "a UNICODE string because start with L\", but format maybe"+\r
+ "is not right, correct UNICODE string is L\"...\"!",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+\r
+ strValue = datum.substring(start + 1, end);\r
+ if ((strValue.length() * 2) > maxDatumSize) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is "+\r
+ "a UNICODE string, but the datum size is %d exceed to <MaxDatumSize> : %d",\r
+ cName,\r
+ moduleName,\r
+ strValue.length() * 2, \r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+ } else if (ch == '\"'){\r
+ start = datum.indexOf('\"');\r
+ end = datum.lastIndexOf('\"');\r
+ if ((start > end) || \r
+ (end > datum.length())||\r
+ ((start == end) && (datum.length() > 0))) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID* and datum is "+\r
+ "a ANSCII string because start with \", but format maybe"+\r
+ "is not right, correct ANSIC string is \"...\"!",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+ strValue = datum.substring(start + 1, end);\r
+ if ((strValue.length()) > maxDatumSize) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is "+\r
+ "a ANSCI string, but the datum size is %d which exceed to <MaxDatumSize> : %d",\r
+ cName,\r
+ moduleName,\r
+ strValue.length(),\r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+ } else if (ch =='{') {\r
+ String[] strValueArray;\r
+\r
+ start = datum.indexOf('{');\r
+ end = datum.lastIndexOf('}');\r
+ strValue = datum.substring(start + 1, end);\r
+ strValue = strValue.trim();\r
+ if (strValue.length() == 0) {\r
+ exceptionString = String.format ("[FPD file error] The datum type of PCD %s in %s is VOID*, and "+\r
+ "it is byte array in fact, but '{}' is not valid for NULL datam but"+\r
+ " need use '{0}'",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+ strValueArray = strValue.split(",");\r
+ for (index = 0; index < strValueArray.length; index ++) {\r
+ try{\r
+ value = Integer.decode(strValueArray[index].trim());\r
+ } catch (NumberFormatException nfeEx) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and "+\r
+ "it is byte array in fact. For every byte in array should be a valid"+\r
+ "byte digital, but element %s is not a valid byte digital!",\r
+ cName,\r
+ moduleName,\r
+ strValueArray[index]);\r
+ return exceptionString;\r
+ }\r
+ if (value > 0xFF) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, "+\r
+ "it is byte array in fact. But the element of %s exceed the byte range",\r
+ cName,\r
+ moduleName,\r
+ strValueArray[index]);\r
+ return exceptionString;\r
+ }\r
+ }\r
+\r
+ if (strValueArray.length > maxDatumSize) {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*, and datum is byte"+\r
+ "array, but the number of bytes is %d which exceed to <MaxDatumSzie> : %d!",\r
+ cName,\r
+ moduleName,\r
+ strValueArray.length,\r
+ maxDatumSize);\r
+ return exceptionString;\r
+ }\r
+ } else {\r
+ exceptionString = String.format("[FPD file error] The datum type of PCD %s in %s is VOID*. For VOID* type, you have three format choise:\n "+\r
+ "1) UNICODE string: like L\"xxxx\";\r\n"+\r
+ "2) ANSIC string: like \"xxx\";\r\n"+\r
+ "3) Byte array: like {0x2, 0x45, 0x23}\r\n"+\r
+ "But the datum in seems does not following above format!",\r
+ cName, \r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+ break;\r
+ default:\r
+ exceptionString = String.format("[FPD file error] For PCD entry %s in %s, datum type is unknown, it should be one of "+\r
+ "UINT8, UINT16, UINT32, UINT64, VOID*, BOOLEAN",\r
+ cName,\r
+ moduleName);\r
+ return exceptionString;\r
+ }\r
+ return null;\r
+ }\r
+\r
+ /**\r
+ Get dynamic information for a dynamic PCD from <DynamicPcdBuildDefinition> seciton in FPD file.\r
+ \r
+ This function should be implemented in GlobalData in future.\r
+ \r
+ @param token The token instance which has hold module's PCD information\r
+ @param moduleName The name of module who will use this Dynamic PCD.\r
+ \r
+ @return DynamicPcdBuildDefinitions.PcdBuildData\r
+ */\r
+ /***/\r
+ private DynamicPcdBuildDefinitions.PcdBuildData getDynamicInfoFromFPD(Token token,\r
+ String moduleName)\r
+ throws EntityException {\r
+ int index = 0;\r
+ String exceptionString = null;\r
+ String dynamicPrimaryKey = null;\r
+ DynamicPcdBuildDefinitions dynamicPcdBuildDefinitions = null;\r
+ List<DynamicPcdBuildDefinitions.PcdBuildData> dynamicPcdBuildDataArray = null;\r
+ String[] tokenSpaceStrRet = null;\r
+\r
+ //\r
+ // If FPD document is not be opened, open and initialize it.\r
+ // BUGBUG: The code should be moved into GlobalData in future.\r
+ // \r
+ if (fpdDocInstance == null) {\r
+ try {\r
+ fpdDocInstance = (PlatformSurfaceAreaDocument)XmlObject.Factory.parse(new File(fpdFilePath));\r
+ } catch(IOException ioE) {\r
+ throw new EntityException("File IO error for xml file:" + fpdFilePath + "\n" + ioE.getMessage());\r
+ } catch(XmlException xmlE) {\r
+ throw new EntityException("Can't parse the FPD xml fle:" + fpdFilePath + "\n" + xmlE.getMessage());\r
+ }\r
+ }\r
+ \r
+ dynamicPcdBuildDefinitions = fpdDocInstance.getPlatformSurfaceArea().getDynamicPcdBuildDefinitions();\r
+ if (dynamicPcdBuildDefinitions == null) {\r
+ exceptionString = String.format("[FPD file error] There are no <PcdDynamicBuildDescriptions> in FPD file but contains Dynamic type "+\r
+ "PCD entry %s in module %s!",\r
+ token.cName,\r
+ moduleName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ dynamicPcdBuildDataArray = dynamicPcdBuildDefinitions.getPcdBuildDataList();\r
+ for (index = 0; index < dynamicPcdBuildDataArray.size(); index ++) {\r
+ //String tokenSpaceGuidString = GlobalData.getGuidInfoFromCname(dynamicPcdBuildDataArray.get(index).getTokenSpaceGuidCName())[1];\r
+ String tokenSpaceGuidString = null;\r
+ try {\r
+ tokenSpaceStrRet = GlobalData.getGuidInfoFromCname(dynamicPcdBuildDataArray.get(index).getTokenSpaceGuidCName());\r
+ } catch (Exception e) {\r
+ throw new EntityException ("Fail to get token space guid for token " + dynamicPcdBuildDataArray.get(index).getCName());\r
+ }\r
+ \r
+ if (tokenSpaceStrRet == null) {\r
+ throw new EntityException ("Fail to get token space guid for token " + dynamicPcdBuildDataArray.get(index).getCName());\r
+ }\r
+\r
+ dynamicPrimaryKey = Token.getPrimaryKeyString(dynamicPcdBuildDataArray.get(index).getCName(),\r
+ tokenSpaceStrRet[1]);\r
+ if (dynamicPrimaryKey.equalsIgnoreCase(token.getPrimaryKeyString())) {\r
+ return dynamicPcdBuildDataArray.get(index);\r
+ }\r
+ }\r
+\r
+ return null;\r
+ }\r
+\r
+ /**\r
+ Update dynamic information for PCD entry.\r
+ \r
+ Dynamic information is retrieved from <PcdDynamicBuildDeclarations> in\r
+ FPD file.\r
+ \r
+ @param moduleName The name of the module who use this PCD\r
+ @param token The token instance\r
+ @param datum The <datum> in module's PCD information\r
+ @param maxDatumSize The <maxDatumSize> in module's PCD information\r
+ \r
+ @return Token\r
+ */\r
+ private Token updateDynamicInformation(String moduleName, \r
+ Token token,\r
+ String datum,\r
+ int maxDatumSize) \r
+ throws EntityException {\r
+ int index = 0;\r
+ int offset;\r
+ String exceptionString = null;\r
+ DynamicTokenValue dynamicValue;\r
+ SkuInstance skuInstance = null;\r
+ String temp;\r
+ boolean hasSkuId0 = false;\r
+ Token.PCD_TYPE pcdType = Token.PCD_TYPE.UNKNOWN;\r
+ long tokenNumber = 0;\r
+ String hiiDefaultValue = null;\r
+ String[] variableGuidString = null;\r
+\r
+ List<DynamicPcdBuildDefinitions.PcdBuildData.SkuInfo> skuInfoList = null;\r
+ DynamicPcdBuildDefinitions.PcdBuildData dynamicInfo = null;\r
+\r
+ dynamicInfo = getDynamicInfoFromFPD(token, moduleName);\r
+ if (dynamicInfo == null) {\r
+ exceptionString = String.format("[FPD file error] For Dynamic PCD %s used by module %s, "+\r
+ "there is no dynamic information in <DynamicPcdBuildDefinitions> "+\r
+ "in FPD file, but it is required!",\r
+ token.cName,\r
+ moduleName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ token.datumSize = dynamicInfo.getMaxDatumSize();\r
+\r
+ exceptionString = verifyDatum(token.cName, \r
+ moduleName,\r
+ null, \r
+ token.datumType, \r
+ token.datumSize);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ if ((maxDatumSize != 0) && \r
+ (maxDatumSize != token.datumSize)) {\r
+ exceptionString = String.format("FPD file error] For dynamic PCD %s, the datum size in module %s is %d, but "+\r
+ "the datum size in <DynamicPcdBuildDefinitions> is %d, they are not match!",\r
+ token.cName,\r
+ moduleName, \r
+ maxDatumSize,\r
+ dynamicInfo.getMaxDatumSize());\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ tokenNumber = Long.decode(dynamicInfo.getToken().toString());\r
+ if (tokenNumber != token.tokenNumber) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s, the token number in module %s is 0x%x, but"+\r
+ "in <DynamicPcdBuildDefinictions>, the token number is 0x%x, they are not match!",\r
+ token.cName,\r
+ moduleName,\r
+ token.tokenNumber,\r
+ tokenNumber);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ pcdType = Token.getpcdTypeFromString(dynamicInfo.getItemType().toString());\r
+ token.dynamicExTokenNumber = tokenNumber;\r
+\r
+ skuInfoList = dynamicInfo.getSkuInfoList();\r
+\r
+ //\r
+ // Loop all sku data \r
+ // \r
+ for (index = 0; index < skuInfoList.size(); index ++) {\r
+ skuInstance = new SkuInstance();\r
+ //\r
+ // Although SkuId in schema is BigInteger, but in fact, sku id is 32 bit value.\r
+ // \r
+ temp = skuInfoList.get(index).getSkuId().toString();\r
+ skuInstance.id = Integer.decode(temp);\r
+ if (skuInstance.id == 0) {\r
+ hasSkuId0 = true;\r
+ }\r
+ //\r
+ // Judge whether is DefaultGroup at first, because most case is DefautlGroup.\r
+ // \r
+ if (skuInfoList.get(index).getValue() != null) {\r
+ skuInstance.value.setValue(skuInfoList.get(index).getValue().toString());\r
+ if ((exceptionString = verifyDatum(token.cName, \r
+ null, \r
+ skuInfoList.get(index).getValue().toString(), \r
+ token.datumType, \r
+ token.datumSize)) != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ token.skuData.add(skuInstance);\r
+\r
+ //\r
+ // Judege wether is same of datum between module's information\r
+ // and dynamic information.\r
+ // \r
+ if (datum != null) {\r
+ if ((skuInstance.id == 0) &&\r
+ !datum.toString().equalsIgnoreCase(skuInfoList.get(index).getValue().toString())) {\r
+ exceptionString = "[FPD file error] For dynamic PCD " + token.cName + ", the value in module " + moduleName + " is " + datum.toString() + " but the "+\r
+ "value of sku 0 data in <DynamicPcdBuildDefinition> is " + skuInstance.value.value + ". They are must be same!"+\r
+ " or you could not define value for a dynamic PCD in every <ModuleSA>!"; \r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+ continue;\r
+ }\r
+\r
+ //\r
+ // Judge whether is HII group case.\r
+ // \r
+ if (skuInfoList.get(index).getVariableName() != null) {\r
+ exceptionString = null;\r
+ if (skuInfoList.get(index).getVariableGuid() == null) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+\r
+ "file, who use HII, but there is no <VariableGuid> defined for Sku %d data!",\r
+ token.cName,\r
+ index);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ } \r
+ }\r
+\r
+ if (skuInfoList.get(index).getVariableOffset() == null) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+\r
+ "file, who use HII, but there is no <VariableOffset> defined for Sku %d data!",\r
+ token.cName,\r
+ index);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+\r
+ if (skuInfoList.get(index).getHiiDefaultValue() == null) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions> section in FPD "+\r
+ "file, who use HII, but there is no <HiiDefaultValue> defined for Sku %d data!",\r
+ token.cName,\r
+ index);\r
+ if (exceptionString != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+ }\r
+\r
+ if (skuInfoList.get(index).getHiiDefaultValue() != null) {\r
+ hiiDefaultValue = skuInfoList.get(index).getHiiDefaultValue().toString();\r
+ } else {\r
+ hiiDefaultValue = null;\r
+ }\r
+\r
+ if ((exceptionString = verifyDatum(token.cName, \r
+ null, \r
+ hiiDefaultValue, \r
+ token.datumType, \r
+ token.datumSize)) != null) {\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ offset = Integer.decode(skuInfoList.get(index).getVariableOffset());\r
+ if (offset > 0xFFFF) {\r
+ throw new EntityException(String.format("[FPD file error] For dynamic PCD %s , the variable offset defined in sku %d data "+\r
+ "exceed 64K, it is not allowed!",\r
+ token.cName,\r
+ index));\r
+ }\r
+\r
+ //\r
+ // Get variable guid string according to the name of guid which will be mapped into a GUID in SPD file.\r
+ // \r
+ variableGuidString = GlobalData.getGuidInfoFromCname(skuInfoList.get(index).getVariableGuid().toString());\r
+ if (variableGuidString == null) {\r
+ throw new EntityException(String.format("[GUID Error] For dynamic PCD %s, the variable guid %s can be found in all SPD file!",\r
+ token.cName, \r
+ skuInfoList.get(index).getVariableGuid().toString()));\r
+ }\r
+ String variableStr = skuInfoList.get(index).getVariableName();\r
+ Pattern pattern = Pattern.compile("0x([a-fA-F0-9]){4}");\r
+ Matcher matcher = pattern.matcher(variableStr);\r
+ List<String> varNameList = new ArrayList<String>();\r
+ while (matcher.find()){\r
+ String str = variableStr.substring(matcher.start(),matcher.end());\r
+ varNameList.add(str);\r
+ }\r
+ \r
+ skuInstance.value.setHiiData(varNameList,\r
+ translateSchemaStringToUUID(variableGuidString[1]),\r
+ skuInfoList.get(index).getVariableOffset(),\r
+ skuInfoList.get(index).getHiiDefaultValue().toString());\r
+ token.skuData.add(skuInstance);\r
+ continue;\r
+ }\r
+\r
+ if (skuInfoList.get(index).getVpdOffset() != null) {\r
+ skuInstance.value.setVpdData(skuInfoList.get(index).getVpdOffset());\r
+ token.skuData.add(skuInstance);\r
+ continue;\r
+ }\r
+\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s, the dynamic info must "+\r
+ "be one of 'DefaultGroup', 'HIIGroup', 'VpdGroup'.",\r
+ token.cName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ if (!hasSkuId0) {\r
+ exceptionString = String.format("[FPD file error] For dynamic PCD %s in <DynamicPcdBuildDefinitions>, there are "+\r
+ "no sku id = 0 data, which is required for every dynamic PCD",\r
+ token.cName);\r
+ throw new EntityException(exceptionString);\r
+ }\r
+\r
+ return token;\r
+ }\r
+\r
+ /**\r
+ Translate the schema string to UUID instance.\r
+ \r
+ In schema, the string of UUID is defined as following two types string:\r
+ 1) GuidArrayType: pattern = 0x[a-fA-F0-9]{1,8},( )*0x[a-fA-F0-9]{1,4},(\r
+ )*0x[a-fA-F0-9]{1,4}(,( )*\{)?(,?( )*0x[a-fA-F0-9]{1,2}){8}( )*(\})?\r
+ \r
+ 2) GuidNamingConvention: pattern =\r
+ [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}\r
+ \r
+ This function will convert string and create uuid instance.\r
+ \r
+ @param uuidString UUID string in XML file\r
+ \r
+ @return UUID UUID instance\r
+ **/\r
+ private UUID translateSchemaStringToUUID(String uuidString) \r
+ throws EntityException {\r
+ String temp;\r
+ String[] splitStringArray;\r
+ int index;\r
+ int chIndex;\r
+ int chLen;\r
+\r
+ if (uuidString == null) {\r
+ return null;\r
+ }\r
+\r
+ if (uuidString.length() == 0) {\r
+ return null;\r
+ }\r
+\r
+ if (uuidString.equals("0") ||\r
+ uuidString.equalsIgnoreCase("0x0")) {\r
+ return new UUID(0, 0);\r
+ }\r
+\r
+ uuidString = uuidString.replaceAll("\\{", "");\r
+ uuidString = uuidString.replaceAll("\\}", "");\r
+\r
+ //\r
+ // If the UUID schema string is GuidArrayType type then need translate \r
+ // to GuidNamingConvention type at first.\r
+ // \r
+ if ((uuidString.charAt(0) == '0') && ((uuidString.charAt(1) == 'x') || (uuidString.charAt(1) == 'X'))) {\r
+ splitStringArray = uuidString.split("," );\r
+ if (splitStringArray.length != 11) {\r
+ throw new EntityException ("[FPD file error] Wrong format for UUID string: " + uuidString);\r
+ }\r
+\r
+ //\r
+ // Remove blank space from these string and remove header string "0x"\r
+ // \r
+ for (index = 0; index < 11; index ++) {\r
+ splitStringArray[index] = splitStringArray[index].trim();\r
+ splitStringArray[index] = splitStringArray[index].substring(2, splitStringArray[index].length());\r
+ }\r
+\r
+ //\r
+ // Add heading '0' to normalize the string length\r
+ // \r
+ for (index = 3; index < 11; index ++) {\r
+ chLen = splitStringArray[index].length();\r
+ for (chIndex = 0; chIndex < 2 - chLen; chIndex ++) {\r
+ splitStringArray[index] = "0" + splitStringArray[index];\r
+ }\r
+ }\r
+\r
+ //\r
+ // construct the final GuidNamingConvention string\r
+ // \r
+ temp = String.format("%s-%s-%s-%s%s-%s%s%s%s%s%s",\r
+ splitStringArray[0],\r
+ splitStringArray[1],\r
+ splitStringArray[2],\r
+ splitStringArray[3],\r
+ splitStringArray[4],\r
+ splitStringArray[5],\r
+ splitStringArray[6],\r
+ splitStringArray[7],\r
+ splitStringArray[8],\r
+ splitStringArray[9],\r
+ splitStringArray[10]);\r
+ uuidString = temp;\r
+ }\r
+\r
+ return UUID.fromString(uuidString);\r