a. Added doxygen comments
[people/mcb30/basetools.git] / Source / Python / AutoGen / GenC.py
1 ## @file\r
2 # Routines for generating AutoGen.h and AutoGen.c\r
3 #\r
4 # Copyright (c) 2007, Intel Corporation\r
5 # All rights reserved. This program and the accompanying materials\r
6 # are licensed and made available under the terms and conditions of the BSD License\r
7 # which accompanies this distribution.  The full text of the license may be found at\r
8 # http://opensource.org/licenses/bsd-license.php\r
9 #\r
10 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
11 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
12 #\r
13 \r
14 ## Import Modules\r
15 #\r
16 import string\r
17 \r
18 from Common import EdkLogger\r
19 \r
20 from Common.BuildToolError import *\r
21 from Common.DataType import *\r
22 from Common.EdkIIWorkspace import *\r
23 from Common.Misc import *\r
24 from StrGather import *\r
25 \r
26 ## PCD type string\r
27 gItemTypeStringDatabase  = {\r
28     TAB_PCDS_FEATURE_FLAG       :   'FixedAtBuild',\r
29     TAB_PCDS_FIXED_AT_BUILD     :   'FixedAtBuild',\r
30     TAB_PCDS_PATCHABLE_IN_MODULE:   'BinaryPatch',\r
31     TAB_PCDS_DYNAMIC            :   '',\r
32     TAB_PCDS_DYNAMIC_DEFAULT    :   '',\r
33     TAB_PCDS_DYNAMIC_VPD        :   '',\r
34     TAB_PCDS_DYNAMIC_HII        :   '',\r
35     TAB_PCDS_DYNAMIC_EX         :   '',\r
36     TAB_PCDS_DYNAMIC_EX_DEFAULT :   '',\r
37     TAB_PCDS_DYNAMIC_EX_VPD     :   '',\r
38     TAB_PCDS_DYNAMIC_EX_HII     :   '',\r
39 }\r
40 \r
41 ## Dynamic PCD types\r
42 gDynamicPcd = [TAB_PCDS_DYNAMIC, TAB_PCDS_DYNAMIC_DEFAULT, TAB_PCDS_DYNAMIC_VPD, TAB_PCDS_DYNAMIC_HII]\r
43 \r
44 ## Dynamic-ex PCD types\r
45 gDynamicExPcd = [TAB_PCDS_DYNAMIC_EX, TAB_PCDS_DYNAMIC_EX_DEFAULT, TAB_PCDS_DYNAMIC_EX_VPD, TAB_PCDS_DYNAMIC_EX_HII]\r
46 \r
47 ## Datum size\r
48 gDatumSizeStringDatabase = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOLEAN','VOID*':'8'}\r
49 gDatumSizeStringDatabaseH = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'BOOL','VOID*':'PTR'}\r
50 gDatumSizeStringDatabaseLib = {'UINT8':'8','UINT16':'16','UINT32':'32','UINT64':'64','BOOLEAN':'Bool','VOID*':'Ptr'}\r
51 \r
52 ## Mapping between PCD driver type and EFI phase\r
53 gPcdPhaseMap = {\r
54     "PEI_PCD_DRIVER"    :   "PEI",\r
55     "DXE_PCD_DRIVER"    :   "DXE"\r
56 }\r
57 \r
58 gPcdDatabaseCommonAutoGenH = """\r
59 //\r
60 // The following definition will be generated by build tool\r
61 //\r
62 \r
63 //\r
64 // Common definitions\r
65 //\r
66 typedef UINT8 SKU_ID;\r
67 \r
68 #define PCD_TYPE_SHIFT        28\r
69 \r
70 #define PCD_TYPE_DATA         (0x0 << PCD_TYPE_SHIFT)\r
71 #define PCD_TYPE_HII          (0x8 << PCD_TYPE_SHIFT)\r
72 #define PCD_TYPE_VPD          (0x4 << PCD_TYPE_SHIFT)\r
73 #define PCD_TYPE_SKU_ENABLED  (0x2 << PCD_TYPE_SHIFT)\r
74 #define PCD_TYPE_STRING       (0x1 << PCD_TYPE_SHIFT)\r
75 \r
76 #define PCD_TYPE_ALL_SET      (PCD_TYPE_DATA | PCD_TYPE_HII | PCD_TYPE_VPD | PCD_TYPE_SKU_ENABLED | PCD_TYPE_STRING)\r
77 \r
78 #define PCD_DATUM_TYPE_SHIFT  24\r
79 \r
80 #define PCD_DATUM_TYPE_POINTER  (0x0 << PCD_DATUM_TYPE_SHIFT)\r
81 #define PCD_DATUM_TYPE_UINT8    (0x1 << PCD_DATUM_TYPE_SHIFT)\r
82 #define PCD_DATUM_TYPE_UINT16   (0x2 << PCD_DATUM_TYPE_SHIFT)\r
83 #define PCD_DATUM_TYPE_UINT32   (0x4 << PCD_DATUM_TYPE_SHIFT)\r
84 #define PCD_DATUM_TYPE_UINT64   (0x8 << PCD_DATUM_TYPE_SHIFT)\r
85 \r
86 #define PCD_DATUM_TYPE_ALL_SET  (PCD_DATUM_TYPE_POINTER | \\\r
87                                  PCD_DATUM_TYPE_UINT8   | \\\r
88                                  PCD_DATUM_TYPE_UINT16  | \\\r
89                                  PCD_DATUM_TYPE_UINT32  | \\\r
90                                  PCD_DATUM_TYPE_UINT64)\r
91 \r
92 #define PCD_DATABASE_OFFSET_MASK (~(PCD_TYPE_ALL_SET | PCD_DATUM_TYPE_ALL_SET))\r
93 \r
94 typedef struct  {\r
95   UINT32  ExTokenNumber;\r
96   UINT16  LocalTokenNumber;   // PCD Number of this particular platform build\r
97   UINT16  ExGuidIndex;        // Index of GuidTable\r
98 } DYNAMICEX_MAPPING;\r
99 \r
100 typedef struct {\r
101   UINT32  SkuDataStartOffset; //We have to use offsetof MACRO as we don't know padding done by compiler\r
102   UINT32  SkuIdTableOffset;   //Offset from the PCD_DB\r
103 } SKU_HEAD;\r
104 \r
105 typedef struct {\r
106   UINT16  GuidTableIndex;     // Offset in Guid Table in units of GUID.\r
107   UINT16  StringIndex;        // Offset in String Table in units of UINT16.\r
108   UINT16  Offset;             // Offset in Variable\r
109   UINT16  DefaultValueOffset; // Offset of the Default Value\r
110 } VARIABLE_HEAD;\r
111 \r
112 typedef  struct {\r
113   UINT32  Offset;\r
114 } VPD_HEAD;\r
115 \r
116 typedef UINT16 STRING_HEAD;\r
117 \r
118 typedef UINT16 SIZE_INFO;\r
119 \r
120 #define offsetof(s,m)  (UINT32) (UINTN) &(((s *)0)->m)\r
121 \r
122 """\r
123 \r
124 gPcdDatabaseEpilogueAutoGenH = """\r
125 typedef struct {\r
126   PEI_PCD_DATABASE PeiDb;\r
127   DXE_PCD_DATABASE DxeDb;\r
128 } PCD_DATABASE;\r
129 \r
130 #define PCD_TOTAL_TOKEN_NUMBER (PEI_LOCAL_TOKEN_NUMBER + DXE_LOCAL_TOKEN_NUMBER)\r
131 \r
132 """\r
133 \r
134 gPcdDatabaseAutoGenH = """\r
135 #define ${PHASE}_GUID_TABLE_SIZE                ${GUID_TABLE_SIZE}\r
136 #define ${PHASE}_STRING_TABLE_SIZE              ${STRING_TABLE_SIZE}\r
137 #define ${PHASE}_SKUID_TABLE_SIZE               ${SKUID_TABLE_SIZE}\r
138 #define ${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE  ${LOCAL_TOKEN_NUMBER_TABLE_SIZE}\r
139 #define ${PHASE}_LOCAL_TOKEN_NUMBER             ${LOCAL_TOKEN_NUMBER}\r
140 #define ${PHASE}_EXMAPPING_TABLE_SIZE           ${EXMAPPING_TABLE_SIZE}\r
141 #define ${PHASE}_EX_TOKEN_NUMBER                ${EX_TOKEN_NUMBER}\r
142 #define ${PHASE}_SIZE_TABLE_SIZE                ${SIZE_TABLE_SIZE}\r
143 #define ${PHASE}_GUID_TABLE_EMPTY               ${GUID_TABLE_EMPTY}\r
144 #define ${PHASE}_STRING_TABLE_EMPTY             ${STRING_TABLE_EMPTY}\r
145 #define ${PHASE}_SKUID_TABLE_EMPTY              ${SKUID_TABLE_EMPTY}\r
146 #define ${PHASE}_DATABASE_EMPTY                 ${DATABASE_EMPTY}\r
147 #define ${PHASE}_EXMAP_TABLE_EMPTY              ${EXMAP_TABLE_EMPTY}\r
148 \r
149 typedef struct {\r
150 ${BEGIN}  UINT64             ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}];\r
151 ${END}\r
152 ${BEGIN}  UINT64             ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64};\r
153 ${END}\r
154 ${BEGIN}  UINT32             ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}];\r
155 ${END}\r
156 ${BEGIN}  UINT32             ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32};\r
157 ${END}\r
158 ${BEGIN}  VPD_HEAD           ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}];\r
159 ${END}\r
160   DYNAMICEX_MAPPING  ExMapTable[${PHASE}_EXMAPPING_TABLE_SIZE];\r
161   UINT32             LocalTokenNumberTable[${PHASE}_LOCAL_TOKEN_NUMBER_TABLE_SIZE];\r
162   GUID               GuidTable[${PHASE}_GUID_TABLE_SIZE];\r
163 ${BEGIN}  STRING_HEAD        ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}];\r
164 ${END}\r
165 ${BEGIN}  VARIABLE_HEAD      ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}[${VARIABLE_HEAD_NUMSKUS_DECL}];\r
166 ${END}\r
167 ${BEGIN}  UINT16             StringTable${STRING_TABLE_INDEX}[${STRING_TABLE_LENGTH}]; /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
168 ${END}\r
169   SIZE_INFO          SizeTable[${PHASE}_SIZE_TABLE_SIZE];\r
170 ${BEGIN}  UINT16             ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}];\r
171 ${END}\r
172 ${BEGIN}  UINT16             ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16};\r
173 ${END}\r
174 ${BEGIN}  UINT8              ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}];\r
175 ${END}\r
176 ${BEGIN}  UINT8              ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8};\r
177 ${END}\r
178 ${BEGIN}  BOOLEAN            ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}];\r
179 ${END}\r
180 ${BEGIN}  BOOLEAN            ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN};\r
181 ${END}\r
182   UINT8              SkuIdTable[${PHASE}_SKUID_TABLE_SIZE];\r
183 ${SYSTEM_SKU_ID}\r
184 } ${PHASE}_PCD_DATABASE_INIT;\r
185 \r
186 typedef struct {\r
187 ${PCD_DATABASE_UNINIT_EMPTY}\r
188 ${BEGIN}  UINT64   ${UNINIT_CNAME_DECL_UINT64}_${UNINIT_GUID_DECL_UINT64}[${UNINIT_NUMSKUS_DECL_UINT64}];\r
189 ${END}\r
190 ${BEGIN}  UINT32   ${UNINIT_CNAME_DECL_UINT32}_${UNINIT_GUID_DECL_UINT32}[${UNINIT_NUMSKUS_DECL_UINT32}];\r
191 ${END}\r
192 ${BEGIN}  UINT16   ${UNINIT_CNAME_DECL_UINT16}_${UNINIT_GUID_DECL_UINT16}[${UNINIT_NUMSKUS_DECL_UINT16}];\r
193 ${END}\r
194 ${BEGIN}  UINT8    ${UNINIT_CNAME_DECL_UINT8}_${UNINIT_GUID_DECL_UINT8}[${UNINIT_NUMSKUS_DECL_UINT8}];\r
195 ${END}\r
196 ${BEGIN}  BOOLEAN  ${UNINIT_CNAME_DECL_BOOLEAN}_${UNINIT_GUID_DECL_BOOLEAN}[${UNINIT_NUMSKUS_DECL_BOOLEAN}];\r
197 ${END}\r
198 } ${PHASE}_PCD_DATABASE_UNINIT;\r
199 \r
200 #define PCD_${PHASE}_SERVICE_DRIVER_VERSION         2\r
201 \r
202 typedef struct {\r
203   ${PHASE}_PCD_DATABASE_INIT    Init;\r
204   ${PHASE}_PCD_DATABASE_UNINIT  Uninit;\r
205 } ${PHASE}_PCD_DATABASE;\r
206 \r
207 #define ${PHASE}_NEX_TOKEN_NUMBER (${PHASE}_LOCAL_TOKEN_NUMBER - ${PHASE}_EX_TOKEN_NUMBER)\r
208 """\r
209 \r
210 gEmptyPcdDatabaseAutoGenC = """\r
211 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
212   /* ExMapTable */\r
213   {\r
214     {0, 0, 0}\r
215   },\r
216   /* LocalTokenNumberTable */\r
217   {\r
218     0\r
219   },\r
220   /* GuidTable */\r
221   {\r
222     {0x00000000, 0x0000, 0x0000, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}\r
223   },\r
224   /* StringTable */\r
225   { 0 },\r
226   /* SizeTable */\r
227   {\r
228     0, 0\r
229   },\r
230   /* SkuIdTable */\r
231   { 0 },\r
232   ${SYSTEM_SKU_ID_VALUE}\r
233 };\r
234 """\r
235 \r
236 gPcdDatabaseAutoGenC = """\r
237 ${PHASE}_PCD_DATABASE_INIT g${PHASE}PcdDbInit = {\r
238 ${BEGIN}  { ${INIT_VALUE_UINT64} }, /*  ${INIT_CNAME_DECL_UINT64}_${INIT_GUID_DECL_UINT64}[${INIT_NUMSKUS_DECL_UINT64}] */\r
239 ${END}\r
240 ${BEGIN}  ${VARDEF_VALUE_UINT64}, /* ${VARDEF_CNAME_UINT64}_${VARDEF_GUID_UINT64}_VariableDefault_${VARDEF_SKUID_UINT64} */\r
241 ${END}\r
242 ${BEGIN}  { ${INIT_VALUE_UINT32} }, /*  ${INIT_CNAME_DECL_UINT32}_${INIT_GUID_DECL_UINT32}[${INIT_NUMSKUS_DECL_UINT32}] */\r
243 ${END}\r
244 ${BEGIN}  ${VARDEF_VALUE_UINT32}, /* ${VARDEF_CNAME_UINT32}_${VARDEF_GUID_UINT32}_VariableDefault_${VARDEF_SKUID_UINT32} */\r
245 ${END}\r
246   /* VPD */\r
247 ${BEGIN}  { ${VPD_HEAD_VALUE} }, /* ${VPD_HEAD_CNAME_DECL}_${VPD_HEAD_GUID_DECL}[${VPD_HEAD_NUMSKUS_DECL}] */\r
248 ${END}\r
249   /* ExMapTable */\r
250   {\r
251 ${BEGIN}    { ${EXMAPPING_TABLE_EXTOKEN}, ${EXMAPPING_TABLE_LOCAL_TOKEN}, ${EXMAPPING_TABLE_GUID_INDEX} },\r
252 ${END}\r
253   },\r
254   /* LocalTokenNumberTable */\r
255   {\r
256 ${BEGIN}    offsetof(${PHASE}_PCD_DATABASE, ${TOKEN_INIT}.${TOKEN_CNAME}_${TOKEN_GUID}) | ${TOKEN_TYPE},\r
257 ${END}\r
258   },\r
259   /* GuidTable */\r
260   {\r
261 ${BEGIN}    ${GUID_STRUCTURE},\r
262 ${END}\r
263   },\r
264 ${BEGIN}  { ${STRING_HEAD_VALUE} }, /* ${STRING_HEAD_CNAME_DECL}_${STRING_HEAD_GUID_DECL}[${STRING_HEAD_NUMSKUS_DECL}] */\r
265 ${END}\r
266 ${BEGIN}  /* ${VARIABLE_HEAD_CNAME_DECL}_${VARIABLE_HEAD_GUID_DECL}[${VARIABLE_HEAD_NUMSKUS_DECL}] */\r
267   {\r
268     ${VARIABLE_HEAD_VALUE}\r
269   },\r
270 ${END}\r
271  /* StringTable */\r
272 ${BEGIN}  ${STRING_TABLE_VALUE}, /* ${STRING_TABLE_CNAME}_${STRING_TABLE_GUID} */\r
273 ${END}\r
274   /* SizeTable */\r
275   {\r
276 ${BEGIN}    ${SIZE_TABLE_MAXIMUM_LENGTH}, ${SIZE_TABLE_CURRENT_LENGTH}, /* ${SIZE_TABLE_CNAME}_${SIZE_TABLE_GUID} */\r
277 ${END}\r
278   },\r
279 ${BEGIN}  { ${INIT_VALUE_UINT16} }, /*  ${INIT_CNAME_DECL_UINT16}_${INIT_GUID_DECL_UINT16}[${INIT_NUMSKUS_DECL_UINT16}] */\r
280 ${END}\r
281 ${BEGIN}  ${VARDEF_VALUE_UINT16}, /* ${VARDEF_CNAME_UINT16}_${VARDEF_GUID_UINT16}_VariableDefault_${VARDEF_SKUID_UINT16} */\r
282 ${END}\r
283 ${BEGIN}  { ${INIT_VALUE_UINT8} }, /*  ${INIT_CNAME_DECL_UINT8}_${INIT_GUID_DECL_UINT8}[${INIT_NUMSKUS_DECL_UINT8}] */\r
284 ${END}\r
285 ${BEGIN}  ${VARDEF_VALUE_UINT8}, /* ${VARDEF_CNAME_UINT8}_${VARDEF_GUID_UINT8}_VariableDefault_${VARDEF_SKUID_UINT8} */\r
286 ${END}\r
287 ${BEGIN}  { ${INIT_VALUE_BOOLEAN} }, /*  ${INIT_CNAME_DECL_BOOLEAN}_${INIT_GUID_DECL_BOOLEAN}[${INIT_NUMSKUS_DECL_BOOLEAN}] */\r
288 ${END}\r
289 ${BEGIN}  ${VARDEF_VALUE_BOOLEAN}, /* ${VARDEF_CNAME_BOOLEAN}_${VARDEF_GUID_BOOLEAN}_VariableDefault_${VARDEF_SKUID_BOOLEAN} */\r
290 ${END}\r
291   /* SkuIdTable */\r
292   { ${BEGIN}${SKUID_VALUE}, ${END} },\r
293   ${SYSTEM_SKU_ID_VALUE}\r
294 };\r
295 """\r
296 \r
297 \r
298 ## AutoGen File Header Templates\r
299 gAutoGenHeaderString = """\\r
300 /**\r
301   DO NOT EDIT\r
302   FILE auto-generated\r
303   Module name:\r
304     $FileName\r
305   Abstract:       Auto-generated $FileName for building module or library.\r
306 **/\r
307 """\r
308 \r
309 gAutoGenHPrologueString = """\r
310 #ifndef _AUTOGENH_${Guid}\r
311 #define _AUTOGENH_${Guid}\r
312 \r
313 """\r
314 \r
315 gAutoGenHEpilogueString = """\r
316 #endif\r
317 """\r
318 \r
319 ## PEI Core Entry Point Templates\r
320 gPeiCoreEntryPointString = """\r
321 ${BEGIN}\r
322 EFI_STATUS\r
323 ${Function} (\r
324   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,\r
325   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,\r
326   IN VOID                           *OldCoreData\r
327   );\r
328 \r
329 EFI_STATUS\r
330 EFIAPI\r
331 ProcessModuleEntryPointList (\r
332   IN CONST  EFI_SEC_PEI_HAND_OFF    *SecCoreData,\r
333   IN CONST  EFI_PEI_PPI_DESCRIPTOR  *PpiList,\r
334   IN VOID                           *OldCoreData\r
335   )\r
336 \r
337 {\r
338   return ${Function} (SecCoreData, PpiList, OldCoreData);\r
339 }\r
340 ${END}\r
341 """\r
342 \r
343 \r
344 ## DXE Core Entry Point Templates\r
345 gDxeCoreEntryPointString = """\r
346 const UINT32 _gUefiDriverRevision = 0;\r
347 ${BEGIN}\r
348 VOID\r
349 ${Function} (\r
350   IN VOID  *HobStart\r
351   );\r
352 \r
353 VOID\r
354 EFIAPI\r
355 ProcessModuleEntryPointList (\r
356   IN VOID  *HobStart\r
357   )\r
358 \r
359 {\r
360   ${Function} (HobStart);\r
361 }\r
362 ${END}\r
363 """\r
364 \r
365 ## PEIM Entry Point Templates\r
366 gPeimEntryPointString = [\r
367 """\r
368 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
369 \r
370 EFI_STATUS\r
371 EFIAPI\r
372 ProcessModuleEntryPointList (\r
373   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
374   IN EFI_PEI_SERVICES     **PeiServices\r
375   )\r
376 \r
377 {\r
378   return EFI_SUCCESS;\r
379 }\r
380 """,\r
381 """\r
382 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
383 ${BEGIN}\r
384 EFI_STATUS\r
385 ${Function} (\r
386   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
387   IN EFI_PEI_SERVICES     **PeiServices\r
388   );\r
389 \r
390 EFI_STATUS\r
391 EFIAPI\r
392 ProcessModuleEntryPointList (\r
393   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
394   IN EFI_PEI_SERVICES     **PeiServices\r
395   )\r
396 \r
397 {\r
398   return ${Function} (FileHandle, PeiServices);\r
399 }\r
400 ${END}\r
401 """,\r
402 """\r
403 GLOBAL_REMOVE_IF_UNREFERENCED const UINT32 _gPeimRevision = 0;\r
404 \r
405 ${BEGIN}\r
406 EFI_STATUS\r
407 ${Function} (\r
408   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
409   IN EFI_PEI_SERVICES     **PeiServices\r
410   );\r
411 ${END}\r
412 \r
413 EFI_STATUS\r
414 EFIAPI\r
415 ProcessModuleEntryPointList (\r
416   IN EFI_PEI_FILE_HANDLE  FileHandle,\r
417   IN EFI_PEI_SERVICES     **PeiServices\r
418   )\r
419 \r
420 {\r
421   EFI_STATUS  Status;\r
422   EFI_STATUS  CombinedStatus;\r
423 \r
424   CombinedStatus = EFI_LOAD_ERROR;\r
425 ${BEGIN}\r
426   Status = ${Function} (FileHandle, PeiServices);\r
427   if (!EFI_ERROR (Status) || EFI_ERROR (CombinedStatus)) {\r
428     CombinedStatus = Status;\r
429   }\r
430 ${END}\r
431   return CombinedStatus;\r
432 }\r
433 """\r
434 ]\r
435 \r
436 ## DXE SMM Entry Point Templates\r
437 gDxeSmmEntryPointString = [\r
438 """\r
439 EFI_STATUS\r
440 EFIAPI\r
441 ProcessModuleEntryPointList (\r
442   IN EFI_HANDLE        ImageHandle,\r
443   IN EFI_SYSTEM_TABLE  *SystemTable\r
444   )\r
445 \r
446 {\r
447   return EFI_SUCCESS;\r
448 }\r
449 """,\r
450 """\r
451 ${BEGIN}\r
452 EFI_STATUS\r
453 ${Function} (\r
454   IN EFI_HANDLE        ImageHandle,\r
455   IN EFI_SYSTEM_TABLE  *SystemTable\r
456   );\r
457 ${END}\r
458 \r
459 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;\r
460 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;\r
461 \r
462 VOID\r
463 EFIAPI\r
464 ExitDriver (\r
465   IN EFI_STATUS  Status\r
466   )\r
467 {\r
468   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {\r
469     mDriverEntryPointStatus = Status;\r
470   }\r
471   LongJump (&mJumpContext, (UINTN)-1);\r
472   ASSERT (FALSE);\r
473 }\r
474 \r
475 EFI_STATUS\r
476 EFIAPI\r
477 ProcessModuleEntryPointList (\r
478   IN EFI_HANDLE        ImageHandle,\r
479   IN EFI_SYSTEM_TABLE  *SystemTable\r
480   )\r
481 \r
482 {\r
483 ${BEGIN}\r
484   if (SetJump (&mJumpContext) == 0) {\r
485     ExitDriver (${Function} (ImageHandle, SystemTable));\r
486     ASSERT (FALSE);\r
487   }\r
488 ${END}\r
489 \r
490   return mDriverEntryPointStatus;\r
491 }\r
492 """\r
493 ]\r
494 \r
495 ## UEFI Entry Point Templates\r
496 gUefiEntryPointString = [\r
497 """\r
498 const UINT32 _gUefiDriverRevision = 0;\r
499 \r
500 EFI_STATUS\r
501 EFIAPI\r
502 ProcessModuleEntryPointList (\r
503   IN EFI_HANDLE        ImageHandle,\r
504   IN EFI_SYSTEM_TABLE  *SystemTable\r
505   )\r
506 {\r
507   return EFI_SUCCESS;\r
508 }\r
509 """,\r
510 """\r
511 const UINT32 _gUefiDriverRevision = 0;\r
512 ${BEGIN}\r
513 EFI_STATUS\r
514 ${Function} (\r
515   IN EFI_HANDLE        ImageHandle,\r
516   IN EFI_SYSTEM_TABLE  *SystemTable\r
517   );\r
518 \r
519 EFI_STATUS\r
520 EFIAPI\r
521 ProcessModuleEntryPointList (\r
522   IN EFI_HANDLE        ImageHandle,\r
523   IN EFI_SYSTEM_TABLE  *SystemTable\r
524   )\r
525 \r
526 {\r
527   return ${Function} (ImageHandle, SystemTable);\r
528 }\r
529 ${END}\r
530 VOID\r
531 EFIAPI\r
532 ExitDriver (\r
533   IN EFI_STATUS  Status\r
534   )\r
535 {\r
536   if (EFI_ERROR (Status)) {\r
537     ProcessLibraryDestructorList (gImageHandle, gST);\r
538   }\r
539   gBS->Exit (gImageHandle, Status, 0, NULL);\r
540 }\r
541 """,\r
542 """\r
543 const UINT32 _gUefiDriverRevision = 0;\r
544 \r
545 ${BEGIN}\r
546 EFI_STATUS\r
547 ${Function} (\r
548   IN EFI_HANDLE        ImageHandle,\r
549   IN EFI_SYSTEM_TABLE  *SystemTable\r
550   );\r
551 ${END}\r
552 \r
553 EFI_STATUS\r
554 EFIAPI\r
555 ProcessModuleEntryPointList (\r
556   IN EFI_HANDLE        ImageHandle,\r
557   IN EFI_SYSTEM_TABLE  *SystemTable\r
558   )\r
559 \r
560 {\r
561   ${BEGIN}\r
562   if (SetJump (&mJumpContext) == 0) {\r
563     ExitDriver (${Function} (ImageHandle, SystemTable));\r
564     ASSERT (FALSE);\r
565   }\r
566   ${END}\r
567   return mDriverEntryPointStatus;\r
568 }\r
569 \r
570 static BASE_LIBRARY_JUMP_BUFFER  mJumpContext;\r
571 static EFI_STATUS  mDriverEntryPointStatus = EFI_LOAD_ERROR;\r
572 \r
573 VOID\r
574 EFIAPI\r
575 ExitDriver (\r
576   IN EFI_STATUS  Status\r
577   )\r
578 {\r
579   if (!EFI_ERROR (Status) || EFI_ERROR (mDriverEntryPointStatus)) {\r
580     mDriverEntryPointStatus = Status;\r
581   }\r
582   LongJump (&mJumpContext, (UINTN)-1);\r
583   ASSERT (FALSE);\r
584 }\r
585 """\r
586 ]\r
587 \r
588 ## UEFI Unload Image Templates\r
589 gUefiUnloadImageString = [\r
590 """\r
591 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
592 \r
593 EFI_STATUS\r
594 EFIAPI\r
595 ProcessModuleUnloadList (\r
596   IN EFI_HANDLE        ImageHandle\r
597   )\r
598 {\r
599   return EFI_SUCCESS;\r
600 }\r
601 """,\r
602 """\r
603 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
604 \r
605 ${BEGIN}\r
606 EFI_STATUS\r
607 ${Function} (\r
608   IN EFI_HANDLE        ImageHandle\r
609   );\r
610 \r
611 EFI_STATUS\r
612 EFIAPI\r
613 ProcessModuleUnloadList (\r
614   IN EFI_HANDLE        ImageHandle\r
615   )\r
616 {\r
617   return ${Function} (ImageHandle);\r
618 }\r
619 ${END}\r
620 """,\r
621 """\r
622 GLOBAL_REMOVE_IF_UNREFERENCED const UINT8 _gDriverUnloadImageCount = ${Count};\r
623 \r
624 ${BEGIN}\r
625 EFI_STATUS\r
626 ${Function} (\r
627   IN EFI_HANDLE        ImageHandle\r
628   );\r
629 ${END}\r
630 \r
631 EFI_STATUS\r
632 EFIAPI\r
633 ProcessModuleUnloadList (\r
634   IN EFI_HANDLE        ImageHandle\r
635   )\r
636 {\r
637   EFI_STATUS  Status;\r
638 \r
639   Status = EFI_SUCCESS;\r
640 ${BEGIN}\r
641   if (EFI_ERROR (Status)) {\r
642     ${Function} (ImageHandle);\r
643   } else {\r
644     Status = ${Function} (ImageHandle);\r
645   }\r
646 ${END}\r
647   return Status;\r
648 }\r
649 """\r
650 ]\r
651 \r
652 gLibraryStructorPrototype = {\r
653 'BASE'  : """${BEGIN}\r
654 EFI_STATUS\r
655 EFIAPI\r
656 ${Function} (\r
657   VOID\r
658   );${END}\r
659 """,\r
660 \r
661 'PEI'   : """${BEGIN}\r
662 EFI_STATUS\r
663 EFIAPI\r
664 ${Function} (\r
665   IN EFI_PEI_FILE_HANDLE       FileHandle,\r
666   IN EFI_PEI_SERVICES          **PeiServices\r
667   );${END}\r
668 """,\r
669 \r
670 'DXE'   : """${BEGIN}\r
671 EFI_STATUS\r
672 EFIAPI\r
673 ${Function} (\r
674   IN EFI_HANDLE        ImageHandle,\r
675   IN EFI_SYSTEM_TABLE  *SystemTable\r
676   );${END}\r
677 """,\r
678 }\r
679 \r
680 gLibraryStructorCall = {\r
681 'BASE'  : """${BEGIN}\r
682   Status = ${Function} ();\r
683   ASSERT_EFI_ERROR (Status);${END}\r
684 """,\r
685 \r
686 'PEI'   : """${BEGIN}\r
687   Status = ${Function} (FileHandle, PeiServices);\r
688   ASSERT_EFI_ERROR (Status);${END}\r
689 """,\r
690 \r
691 'DXE'   : """${BEGIN}\r
692   Status = ${Function} (ImageHandle, SystemTable);\r
693   ASSERT_EFI_ERROR (Status);${END}\r
694 """,\r
695 }\r
696 \r
697 ## Library Constructor and Destructor Templates\r
698 gLibraryString = {\r
699 'BASE'  :   """\r
700 ${BEGIN}${FunctionPrototype}${END}\r
701 \r
702 VOID\r
703 EFIAPI\r
704 ProcessLibrary${Type}List (\r
705   VOID\r
706   )\r
707 {\r
708 ${BEGIN}  EFI_STATUS  Status;\r
709 ${FunctionCall}${END}\r
710 }\r
711 """,\r
712 \r
713 'PEI'   :   """\r
714 ${BEGIN}${FunctionPrototype}${END}\r
715 \r
716 VOID\r
717 EFIAPI\r
718 ProcessLibrary${Type}List (\r
719   IN EFI_PEI_FILE_HANDLE       FileHandle,\r
720   IN EFI_PEI_SERVICES          **PeiServices\r
721   )\r
722 {\r
723 ${BEGIN}  EFI_STATUS  Status;\r
724 ${FunctionCall}${END}\r
725 }\r
726 """,\r
727 \r
728 'DXE'   :   """\r
729 ${BEGIN}${FunctionPrototype}${END}\r
730 \r
731 VOID\r
732 EFIAPI\r
733 ProcessLibrary${Type}List (\r
734   IN EFI_HANDLE        ImageHandle,\r
735   IN EFI_SYSTEM_TABLE  *SystemTable\r
736   )\r
737 {\r
738 ${BEGIN}  EFI_STATUS  Status;\r
739 ${FunctionCall}${END}\r
740 }\r
741 """,\r
742 }\r
743 \r
744 gSpecificationString = """\r
745 ${BEGIN}\r
746 #undef ${SpecificationName}\r
747 #define ${SpecificationName} ${SpecificationValue}\r
748 ${END}\r
749 """\r
750 \r
751 gBasicHeaderFile = "Base.h"\r
752 \r
753 gModuleTypeHeaderFile = {\r
754     "BASE"              :   [gBasicHeaderFile],\r
755     "SEC"               :   ["PiPei.h", "Library/DebugLib.h"],\r
756     "PEI_CORE"          :   ["PiPei.h", "Library/DebugLib.h"],\r
757     "PEIM"              :   ["PiPei.h", "Library/DebugLib.h"],\r
758     "DXE_CORE"          :   ["PiDxe.h", "Library/DebugLib.h"],\r
759     "DXE_DRIVER"        :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
760     "DXE_SMM_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
761     "DXE_RUNTIME_DRIVER":   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
762     "DXE_SAL_DRIVER"    :   ["PiDxe.h", "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
763     "UEFI_DRIVER"       :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
764     "UEFI_APPLICATION"  :   ["Uefi.h",  "Library/BaseLib.h", "Library/DebugLib.h", "Library/UefiBootServicesTableLib.h"],\r
765     "USER_DEFINED"      :   [gBasicHeaderFile]\r
766 }\r
767 \r
768 ## Create code for module PCDs\r
769 #\r
770 #   @param      Info        The ModuleAutoGen object\r
771 #   @param      AutoGenC    The TemplateString object for C code\r
772 #   @param      AutoGenH    The TemplateString object for header file\r
773 #   @param      Pcd         The PCD object\r
774 #\r
775 def CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
776     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[Pcd.TokenSpaceGuidCName]\r
777     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
778     #\r
779     # Write PCDs\r
780     #\r
781     PcdTokenName = '_PCD_TOKEN_' + Pcd.TokenCName\r
782     if Pcd.Type in gDynamicExPcd:\r
783         TokenNumber = int(Pcd.TokenValue, 0)\r
784     else:\r
785         if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
786             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
787         TokenNumber = PcdTokenNumber[Pcd.TokenCName, Pcd.TokenSpaceGuidCName]\r
788     AutoGenH.Append('#define %s  %d\n' % (PcdTokenName, TokenNumber))\r
789 \r
790     EdkLogger.debug(EdkLogger.DEBUG_3, "Creating code for " + Pcd.TokenCName + "|" + Pcd.TokenSpaceGuidCName)\r
791     if Pcd.Type not in gItemTypeStringDatabase:\r
792         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
793     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
794         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
795 \r
796     DatumSize = gDatumSizeStringDatabase[Pcd.DatumType]\r
797     DatumSizeLib = gDatumSizeStringDatabaseLib[Pcd.DatumType]\r
798     GetModeName = '_PCD_GET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
799     SetModeName = '_PCD_SET_MODE_' + gDatumSizeStringDatabaseH[Pcd.DatumType] + '_' + Pcd.TokenCName\r
800 \r
801     if Pcd.Type in gDynamicExPcd:\r
802         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
803         if Pcd.DatumType == 'VOID*':\r
804             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
805         else:\r
806             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, Pcd.TokenSpaceGuidCName, PcdTokenName))\r
807     elif Pcd.Type in gDynamicPcd:\r
808         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
809         if Pcd.DatumType == 'VOID*':\r
810             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
811         else:\r
812             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
813     else:\r
814         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[Pcd.Type] + '_' + Pcd.TokenCName\r
815         Const = 'const'\r
816         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
817             Const = ''\r
818         Type = ''\r
819         Array = ''\r
820         Value = Pcd.DefaultValue\r
821         if Pcd.DatumType == 'UINT64':\r
822             if not Value.endswith('ULL'):\r
823                 Value += 'ULL'\r
824         if Pcd.DatumType == 'VOID*':\r
825             if Pcd.MaxDatumSize == None or Pcd.MaxDatumSize == '':\r
826                 EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown [MaxDatumSize] of PCD [%s.%s]" % (Pcd.TokenSpaceGuidCName, Pcd.TokenCName))\r
827 \r
828             ArraySize = int(Pcd.MaxDatumSize, 0)\r
829             if Value[0] == '{':\r
830                 Type = '(VOID *)'\r
831             else:\r
832                 Unicode = False\r
833                 if Value[0] == 'L':\r
834                     Unicode = True\r
835                 Value = Value.lstrip('L').strip('"')\r
836                 NewValue = '{'\r
837                 for Index in range(0,len(Value)):\r
838                     NewValue = NewValue + str(ord(Value[Index]) % 0x100) + ', '\r
839                     if Unicode:\r
840                         NewValue = NewValue + str(ord(Value[Index]) / 0x100) + ', '\r
841                 if Unicode:\r
842                     if ArraySize < (len(Value)*2 + 2):\r
843                         ArraySize = len(Value)*2 + 2\r
844                     NewValue = NewValue + '0, '\r
845                 else:\r
846                     if ArraySize < (len(Value) + 1):\r
847                         ArraySize = len(Value) + 1\r
848                 Value = NewValue + '0 }'\r
849             Array = '[%d]' % ArraySize\r
850 \r
851         PcdValueName = '_PCD_VALUE_' + Pcd.TokenCName\r
852         if Pcd.DatumType == 'VOID*' and Value[0] == '{':\r
853             AutoGenH.Append('#define _PCD_PATCHABLE_%s_SIZE %s\n' % (Pcd.TokenCName, Pcd.MaxDatumSize))\r
854             AutoGenH.Append('#define %s  %s%s\n' %(PcdValueName, Type, PcdVariableName))\r
855             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s UINT8 %s%s = %s;\n' % (Const, PcdVariableName, Array, Value))\r
856             AutoGenH.Append('extern %s UINT8 %s%s;\n' %(Const, PcdVariableName, Array))\r
857             AutoGenH.Append('#define %s  %s%s\n' %(GetModeName, Type, PcdVariableName))\r
858         else:\r
859             AutoGenH.Append('#define %s  %s\n' %(PcdValueName, Value))\r
860             AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s %s = %s;\n' %(Const, Pcd.DatumType, PcdVariableName, PcdValueName))\r
861             AutoGenH.Append('extern %s  %s  %s%s;\n' % (Const, Pcd.DatumType, PcdVariableName, Array))\r
862             AutoGenH.Append('#define %s  %s%s\n' % (GetModeName, Type, PcdVariableName))\r
863 \r
864         if Pcd.Type == TAB_PCDS_PATCHABLE_IN_MODULE:\r
865             if Pcd.DatumType == 'VOID*':\r
866                 AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPatchPcdSetPtr(_gPcd_BinaryPatch_%s, (UINTN)_PCD_PATCHABLE_%s_SIZE, (SizeOfBuffer), (Buffer))\n' % (SetModeName, Pcd.TokenCName, Pcd.TokenCName))\r
867             else:\r
868                 AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
869         else:\r
870             AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
871 \r
872 ## Create code for library module PCDs\r
873 #\r
874 #   @param      Info        The ModuleAutoGen object\r
875 #   @param      AutoGenC    The TemplateString object for C code\r
876 #   @param      AutoGenH    The TemplateString object for header file\r
877 #   @param      Pcd         The PCD object\r
878 #\r
879 def CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd):\r
880     PcdTokenNumber = Info.PlatformInfo.PcdTokenNumber\r
881     TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
882     TokenCName  = Pcd.TokenCName\r
883     TokenSpaceGuidValue = Pcd.TokenSpaceGuidValue   #Info.GuidList[TokenSpaceGuidCName]\r
884     if (Pcd.TokenCName, Pcd.TokenSpaceGuidCName) not in PcdTokenNumber:\r
885         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "No generated token number for %s|%s\n" % (Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
886     TokenNumber = PcdTokenNumber[TokenCName, TokenSpaceGuidCName]\r
887 \r
888     if Pcd.Type not in gItemTypeStringDatabase:\r
889         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown PCD type [%s] of PCD %s|%s" % (Pcd.Type, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
890     if Pcd.DatumType not in gDatumSizeStringDatabase:\r
891         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
892 \r
893     DatumType   = Pcd.DatumType\r
894     DatumSize   = gDatumSizeStringDatabaseH[DatumType]\r
895     DatumSizeLib= gDatumSizeStringDatabaseLib[DatumType]\r
896     GetModeName = '_PCD_GET_MODE_' + DatumSize + '_' + TokenCName\r
897     SetModeName = '_PCD_SET_MODE_' + DatumSize + '_' + TokenCName\r
898 \r
899     Type = ''\r
900     Array = ''\r
901     if Pcd.DatumType == 'VOID*':\r
902         Type = '(VOID *)'\r
903         Array = '[]'\r
904 \r
905     AutoGenH.Append('#define _PCD_TOKEN_%s  %d\n' % (TokenCName, TokenNumber))\r
906 \r
907     PcdItemType = Pcd.Type\r
908     #if PcdItemType in gDynamicPcd:\r
909     #    PcdItemType = TAB_PCDS_FIXED_AT_BUILD\r
910     #    if (TokenCName, TokenSpaceGuidCName) in Info.PlatformInfo.Platform.Pcds:\r
911     #        PcdItemType  = Info.PlatformInfo.Platform.Pcds[TokenCName, TokenSpaceGuidCName].Type\r
912     if PcdItemType in gDynamicExPcd:\r
913         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
914         AutoGenH.Append('#define %s  LibPcdGetEx%s(&%s, %s)\n' % (GetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
915         if DatumType == 'VOID*':\r
916             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSetEx%s(&%s, %s, (SizeOfBuffer), (Buffer))\n' % (SetModeName,DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
917         else:\r
918             AutoGenH.Append('#define %s(Value)  LibPcdSetEx%s(&%s, %s, (Value))\n' % (SetModeName, DatumSizeLib, TokenSpaceGuidCName, PcdTokenName))\r
919     if PcdItemType in gDynamicPcd:\r
920         PcdTokenName = '_PCD_TOKEN_' + TokenCName\r
921         AutoGenH.Append('#define %s  LibPcdGet%s(%s)\n' % (GetModeName, DatumSizeLib, PcdTokenName))\r
922         if DatumType == 'VOID*':\r
923             AutoGenH.Append('#define %s(SizeOfBuffer, Buffer)  LibPcdSet%s(%s, (SizeOfBuffer), (Buffer))\n' %(SetModeName, DatumSizeLib, PcdTokenName))\r
924         else:\r
925             AutoGenH.Append('#define %s(Value)  LibPcdSet%s(%s, (Value))\n' % (SetModeName, DatumSizeLib, PcdTokenName))\r
926     if PcdItemType == TAB_PCDS_PATCHABLE_IN_MODULE:\r
927         PcdVariableName = '_gPcd_' + gItemTypeStringDatabase[TAB_PCDS_PATCHABLE_IN_MODULE] + '_' + TokenCName\r
928         AutoGenH.Append('extern %s _gPcd_BinaryPatch_%s%s;\n' %(DatumType, TokenCName, Array) )\r
929         AutoGenH.Append('#define %s  %s_gPcd_BinaryPatch_%s\n' %(GetModeName, Type, TokenCName))\r
930         AutoGenH.Append('#define %s(Value)  (%s = (Value))\n' % (SetModeName, PcdVariableName))\r
931     if PcdItemType == TAB_PCDS_FIXED_AT_BUILD or PcdItemType == TAB_PCDS_FEATURE_FLAG:\r
932         AutoGenH.Append('extern const %s _gPcd_FixedAtBuild_%s%s;\n' %(DatumType, TokenCName, Array))\r
933         #AutoGenH.Append('#define _PCD_VALUE_%s  _gPcd_FixedAtBuild_%s\n' %(TokenCName, TokenCName))\r
934         AutoGenH.Append('#define %s  %s_gPcd_FixedAtBuild_%s\n' %(GetModeName, Type, TokenCName))\r
935         AutoGenH.Append('//#define %s  ASSERT(FALSE)  // It is not allowed to set value for a FIXED_AT_BUILD PCD\n' % SetModeName)\r
936 \r
937 ## Create code for PCD database in DXE or PEI phase\r
938 #\r
939 #   @param      Platform    The platform object\r
940 #   @retval     tuple       Two TemplateString objects for C code and header file,\r
941 #                           respectively\r
942 #\r
943 def CreatePcdDatabasePhaseSpecificAutoGen (Platform, Phase):\r
944     AutoGenC = TemplateString()\r
945     AutoGenH = TemplateString()\r
946 \r
947     Dict = {\r
948         'PHASE'                         : Phase,\r
949         'GUID_TABLE_SIZE'               : '1',\r
950         'STRING_TABLE_SIZE'             : '1',\r
951         'SKUID_TABLE_SIZE'              : '1',\r
952         'LOCAL_TOKEN_NUMBER_TABLE_SIZE' : '1',\r
953         'LOCAL_TOKEN_NUMBER'            : '0',\r
954         'EXMAPPING_TABLE_SIZE'          : '1',\r
955         'EX_TOKEN_NUMBER'               : '0',\r
956         'SIZE_TABLE_SIZE'               : '2',\r
957         'GUID_TABLE_EMPTY'              : 'TRUE',\r
958         'STRING_TABLE_EMPTY'            : 'TRUE',\r
959         'SKUID_TABLE_EMPTY'             : 'TRUE',\r
960         'DATABASE_EMPTY'                : 'TRUE',\r
961         'EXMAP_TABLE_EMPTY'             : 'TRUE',\r
962         'PCD_DATABASE_UNINIT_EMPTY'     : '  UINT8  dummy; /* PCD_DATABASE_UNINIT is emptry */',\r
963         'SYSTEM_SKU_ID'                 : '  SKU_ID             SystemSkuId;',\r
964         'SYSTEM_SKU_ID_VALUE'           : '0'\r
965     }\r
966 \r
967     for DatumType in ['UINT64','UINT32','UINT16','UINT8','BOOLEAN']:\r
968         Dict['VARDEF_CNAME_' + DatumType] = []\r
969         Dict['VARDEF_GUID_' + DatumType]  = []\r
970         Dict['VARDEF_SKUID_' + DatumType] = []\r
971         Dict['VARDEF_VALUE_' + DatumType] = []\r
972         for Init in ['INIT','UNINIT']:\r
973             Dict[Init+'_CNAME_DECL_' + DatumType]   = []\r
974             Dict[Init+'_GUID_DECL_' + DatumType]    = []\r
975             Dict[Init+'_NUMSKUS_DECL_' + DatumType] = []\r
976             Dict[Init+'_VALUE_' + DatumType]        = []\r
977 \r
978     for Type in ['STRING_HEAD','VPD_HEAD','VARIABLE_HEAD']:\r
979         Dict[Type + '_CNAME_DECL']   = []\r
980         Dict[Type + '_GUID_DECL']    = []\r
981         Dict[Type + '_NUMSKUS_DECL'] = []\r
982         Dict[Type + '_VALUE'] = []\r
983 \r
984     Dict['STRING_TABLE_INDEX'] = []\r
985     Dict['STRING_TABLE_LENGTH']  = []\r
986     Dict['STRING_TABLE_CNAME'] = []\r
987     Dict['STRING_TABLE_GUID']  = []\r
988     Dict['STRING_TABLE_VALUE'] = []\r
989 \r
990     Dict['SIZE_TABLE_CNAME'] = []\r
991     Dict['SIZE_TABLE_GUID']  = []\r
992     Dict['SIZE_TABLE_CURRENT_LENGTH']  = []\r
993     Dict['SIZE_TABLE_MAXIMUM_LENGTH']  = []\r
994 \r
995     Dict['EXMAPPING_TABLE_EXTOKEN'] = []\r
996     Dict['EXMAPPING_TABLE_LOCAL_TOKEN'] = []\r
997     Dict['EXMAPPING_TABLE_GUID_INDEX'] = []\r
998 \r
999     Dict['GUID_STRUCTURE'] = []\r
1000 \r
1001     Dict['SKUID_VALUE'] = []\r
1002 \r
1003     if Phase == 'DXE':\r
1004         Dict['SYSTEM_SKU_ID'] = ''\r
1005         Dict['SYSTEM_SKU_ID_VALUE'] = ''\r
1006 \r
1007     StringTableIndex = 0\r
1008     StringTableSize = 0\r
1009     NumberOfLocalTokens = 0\r
1010     NumberOfPeiLocalTokens = 0\r
1011     NumberOfDxeLocalTokens = 0\r
1012     NumberOfExTokens = 0\r
1013     NumberOfSizeItems = 0\r
1014     GuidList = []\r
1015 \r
1016     for Pcd in Platform.DynamicPcdList:\r
1017         CName = Pcd.TokenCName\r
1018         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1019 \r
1020         EdkLogger.debug(EdkLogger.DEBUG_3, "PCD: %s %s (%s : %s)" % (CName, TokenSpaceGuidCName, Pcd.Phase, Phase))\r
1021         if Pcd.DatumType not in gDatumSizeStringDatabase:\r
1022             EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Unknown datum type [%s] of PCD %s|%s" % (Pcd.DatumType, Pcd.TokenCName, Pcd.TokenSpaceGuidCName))\r
1023 \r
1024         if Pcd.Phase == 'PEI':\r
1025             NumberOfPeiLocalTokens += 1\r
1026         if Pcd.Phase == 'DXE':\r
1027             NumberOfDxeLocalTokens += 1\r
1028         if Pcd.Phase != Phase:\r
1029             continue\r
1030 \r
1031         #\r
1032         # TODO: need GetGuidValue() definition\r
1033         #\r
1034         TokenSpaceGuidStructure = Pcd.TokenSpaceGuidValue\r
1035         TokenSpaceGuid = GuidStructureStringToGuidValueName(TokenSpaceGuidStructure)\r
1036         if Pcd.Type in gDynamicExPcd:\r
1037             if TokenSpaceGuid not in GuidList:\r
1038                 GuidList += [TokenSpaceGuid]\r
1039                 Dict['GUID_STRUCTURE'].append(TokenSpaceGuidStructure)\r
1040             NumberOfExTokens += 1\r
1041 \r
1042         ValueList = []\r
1043         StringHeadOffsetList = []\r
1044         VpdHeadOffsetList = []\r
1045         VariableHeadValueList = []\r
1046         Pcd.InitString = 'UNINIT'\r
1047 \r
1048         if Pcd.DatumType == 'VOID*':\r
1049             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_POINTER']\r
1050         elif Pcd.DatumType == 'BOOLEAN':\r
1051             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_UINT8']\r
1052         else:\r
1053             Pcd.TokenTypeList = ['PCD_DATUM_TYPE_' + Pcd.DatumType]\r
1054 \r
1055         if len(Pcd.SkuInfoList) > 1:\r
1056             Pcd.TokenTypeList += ['PCD_TYPE_SKU_ENABLED']\r
1057 \r
1058         for SkuName in Pcd.SkuInfoList:\r
1059             Sku = Pcd.SkuInfoList[SkuName]\r
1060             SkuId = Sku.SkuId\r
1061             if SkuId == None or SkuId == '':\r
1062                 continue\r
1063 \r
1064             if SkuId not in Dict['SKUID_VALUE']:\r
1065                 Dict['SKUID_VALUE'].append(SkuId)\r
1066 \r
1067             SkuIdIndex =   Dict['SKUID_VALUE'].index(SkuId)\r
1068             if len(Sku.VariableName) > 0:\r
1069                 Pcd.TokenTypeList += ['PCD_TYPE_HII']\r
1070                 Pcd.InitString = 'INIT'\r
1071                 VariableNameStructure = '{' + ', '.join(Sku.VariableName.split(" ")) + ', 0x0000}'\r
1072                 if VariableNameStructure not in Dict['STRING_TABLE_VALUE']:\r
1073                     Dict['STRING_TABLE_CNAME'].append(CName)\r
1074                     Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1075                     if StringTableIndex == 0:\r
1076                         Dict['STRING_TABLE_INDEX'].append('')\r
1077                     else:\r
1078                         Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1079 \r
1080                     Dict['STRING_TABLE_LENGTH'].append(len(Sku.VariableName) + 1)\r
1081                     Dict['STRING_TABLE_VALUE'].append(VariableNameStructure)\r
1082                     StringTableIndex += 1\r
1083                     StringTableSize += len(Sku.VariableName) + 1\r
1084 \r
1085                 VariableHeadStringIndex = 0\r
1086                 for Index in range(Dict['STRING_TABLE_VALUE'].index(VariableNameStructure)):\r
1087                     VariableHeadStringIndex += Dict['STRING_TABLE_LENGTH'][Index]\r
1088 \r
1089                 VariableGuidStructure = Sku.VariableGuidValue\r
1090                 VariableGuid = GuidStructureStringToGuidValueName(VariableGuidStructure)\r
1091                 if VariableGuid not in GuidList:\r
1092                     GuidList += [VariableGuid]\r
1093                     Dict['GUID_STRUCTURE'].append(VariableGuidStructure)\r
1094                 VariableHeadGuidIndex = GuidList.index(VariableGuid)\r
1095 \r
1096                 VariableHeadValueList.append('%d, %d, %s, offsetof(${PHASE}_PCD_DATABASE, Init.%s_%s_VariableDefault_%s)' %\r
1097                                              (VariableHeadGuidIndex, VariableHeadStringIndex, Sku.VariableOffset, CName, TokenSpaceGuid, SkuIdIndex))\r
1098                 Dict['VARDEF_CNAME_'+Pcd.DatumType].append(CName)\r
1099                 Dict['VARDEF_GUID_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1100                 Dict['VARDEF_SKUID_'+Pcd.DatumType].append(SkuIdIndex)\r
1101                 Dict['VARDEF_VALUE_'+Pcd.DatumType].append(Sku.HiiDefaultValue)\r
1102             elif Sku.VpdOffset != '':\r
1103                 Pcd.TokenTypeList += ['PCD_TYPE_VPD']\r
1104                 Pcd.InitString = 'INIT'\r
1105                 VpdHeadOffsetList.append(Sku.VpdOffset)\r
1106             else:\r
1107                 if Pcd.DatumType == 'VOID*':\r
1108                     Pcd.TokenTypeList += ['PCD_TYPE_STRING']\r
1109                     Pcd.InitString = 'INIT'\r
1110                     if Sku.DefaultValue != '':\r
1111                         NumberOfSizeItems += 1\r
1112                         Dict['STRING_TABLE_CNAME'].append(CName)\r
1113                         Dict['STRING_TABLE_GUID'].append(TokenSpaceGuid)\r
1114 \r
1115                         if StringTableIndex == 0:\r
1116                             Dict['STRING_TABLE_INDEX'].append('')\r
1117                         else:\r
1118                             Dict['STRING_TABLE_INDEX'].append('_%d' % StringTableIndex)\r
1119                         if Sku.DefaultValue[0] == 'L':\r
1120                             Size = (len(Sku.DefaultValue) - 3) * 2\r
1121                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1122                         elif Sku.DefaultValue[0] == '"':\r
1123                             Size = len(Sku.DefaultValue) - 2\r
1124                             Dict['STRING_TABLE_VALUE'].append(Sku.DefaultValue)\r
1125                         elif Sku.DefaultValue[0] == '{':\r
1126                             Size = len(Sku.DefaultValue.replace(',',' ').split())\r
1127                             Dict['STRING_TABLE_VALUE'].append('{' + Sku.DefaultValue + '}')\r
1128 \r
1129                         StringHeadOffsetList.append(str(StringTableSize))\r
1130                         Dict['SIZE_TABLE_CNAME'].append(CName)\r
1131                         Dict['SIZE_TABLE_GUID'].append(TokenSpaceGuid)\r
1132                         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(Size)\r
1133                         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(Pcd.MaxDatumSize)\r
1134                         if Pcd.MaxDatumSize != '':\r
1135                             MaxDatumSize = int(Pcd.MaxDatumSize, 0)\r
1136                             if MaxDatumSize > Size:\r
1137                                 Size = MaxDatumSize\r
1138                         Dict['STRING_TABLE_LENGTH'].append(Size / 2 + 1)\r
1139                         StringTableIndex += 1\r
1140                         StringTableSize += (Size / 2 + 1)\r
1141                 else:\r
1142                     Pcd.TokenTypeList += ['PCD_TYPE_DATA']\r
1143                     if Sku.DefaultValue == 'TRUE':\r
1144                         Pcd.InitString = 'INIT'\r
1145                     else:\r
1146                         try:\r
1147                             if int(Sku.DefaultValue, 0) != 0:\r
1148                                 Pcd.InitString = 'INIT'\r
1149                         except:\r
1150                             pass\r
1151                     ValueList.append(Sku.DefaultValue)\r
1152 \r
1153         Pcd.TokenTypeList = list(set(Pcd.TokenTypeList))\r
1154 \r
1155         if 'PCD_TYPE_HII' in Pcd.TokenTypeList:\r
1156             Dict['VARIABLE_HEAD_CNAME_DECL'].append(CName)\r
1157             Dict['VARIABLE_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1158             Dict['VARIABLE_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1159             Dict['VARIABLE_HEAD_VALUE'].append('{ %s }\n' % ' },\n    { '.join(VariableHeadValueList))\r
1160         if 'PCD_TYPE_VPD' in Pcd.TokenTypeList:\r
1161             Dict['VPD_HEAD_CNAME_DECL'].append(CName)\r
1162             Dict['VPD_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1163             Dict['VPD_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1164             Dict['VPD_HEAD_VALUE'].append('{ %s }' % ' }, { '.join(VpdHeadOffsetList))\r
1165         if 'PCD_TYPE_STRING' in Pcd.TokenTypeList:\r
1166             Dict['STRING_HEAD_CNAME_DECL'].append(CName)\r
1167             Dict['STRING_HEAD_GUID_DECL'].append(TokenSpaceGuid)\r
1168             Dict['STRING_HEAD_NUMSKUS_DECL'].append(len(Pcd.SkuInfoList))\r
1169             Dict['STRING_HEAD_VALUE'].append(', '.join(StringHeadOffsetList))\r
1170         if 'PCD_TYPE_DATA' in Pcd.TokenTypeList:\r
1171             Dict[Pcd.InitString+'_CNAME_DECL_'+Pcd.DatumType].append(CName)\r
1172             Dict[Pcd.InitString+'_GUID_DECL_'+Pcd.DatumType].append(TokenSpaceGuid)\r
1173             Dict[Pcd.InitString+'_NUMSKUS_DECL_'+Pcd.DatumType].append(len(Pcd.SkuInfoList))\r
1174             if Pcd.InitString == 'UNINIT':\r
1175                 Dict['PCD_DATABASE_UNINIT_EMPTY'] = ''\r
1176             else:\r
1177                 Dict[Pcd.InitString+'_VALUE_'+Pcd.DatumType].append(', '.join(ValueList))\r
1178 \r
1179     if Phase == 'PEI':\r
1180         NumberOfLocalTokens = NumberOfPeiLocalTokens\r
1181     if Phase == 'DXE':\r
1182         NumberOfLocalTokens = NumberOfDxeLocalTokens\r
1183 \r
1184     Dict['TOKEN_INIT']       = ['' for x in range(NumberOfLocalTokens)]\r
1185     Dict['TOKEN_CNAME']      = ['' for x in range(NumberOfLocalTokens)]\r
1186     Dict['TOKEN_GUID']       = ['' for x in range(NumberOfLocalTokens)]\r
1187     Dict['TOKEN_TYPE']       = ['' for x in range(NumberOfLocalTokens)]\r
1188 \r
1189     for Pcd in Platform.DynamicPcdList:\r
1190         CName = Pcd.TokenCName\r
1191         TokenSpaceGuidCName = Pcd.TokenSpaceGuidCName\r
1192         if Pcd.Phase != Phase:\r
1193             continue\r
1194 \r
1195         TokenSpaceGuid = GuidStructureStringToGuidValueName(Pcd.TokenSpaceGuidValue) #(Platform.PackageList, TokenSpaceGuidCName))\r
1196         GeneratedTokenNumber = Platform.PcdTokenNumber[CName, TokenSpaceGuidCName] - 1\r
1197         if Phase == 'DXE':\r
1198             GeneratedTokenNumber -= NumberOfPeiLocalTokens\r
1199 \r
1200         EdkLogger.debug(EdkLogger.DEBUG_1, "PCD = %s | %s" % (CName, TokenSpaceGuidCName))\r
1201         EdkLogger.debug(EdkLogger.DEBUG_1, "phase = %s" % Phase)\r
1202         EdkLogger.debug(EdkLogger.DEBUG_1, "GeneratedTokenNumber = %s" % str(GeneratedTokenNumber))\r
1203 \r
1204         Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Init'\r
1205         if Pcd.InitString == 'UNINIT':\r
1206             Dict['TOKEN_INIT'][GeneratedTokenNumber] = 'Uninit'\r
1207         Dict['TOKEN_CNAME'][GeneratedTokenNumber] = CName\r
1208         Dict['TOKEN_GUID'][GeneratedTokenNumber] = TokenSpaceGuid\r
1209         Dict['TOKEN_TYPE'][GeneratedTokenNumber] = ' | '.join(Pcd.TokenTypeList)\r
1210         if Pcd.Type in gDynamicExPcd:\r
1211             Dict['EXMAPPING_TABLE_EXTOKEN'].append(Pcd.TokenValue)\r
1212             if Phase == 'DXE':\r
1213                 GeneratedTokenNumber += NumberOfPeiLocalTokens\r
1214             Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(GeneratedTokenNumber)\r
1215             Dict['EXMAPPING_TABLE_GUID_INDEX'].append(GuidList.index(TokenSpaceGuid))\r
1216 \r
1217     if GuidList != []:\r
1218         Dict['GUID_TABLE_EMPTY'] = 'FALSE'\r
1219         Dict['GUID_TABLE_SIZE'] = len(GuidList)\r
1220     else:\r
1221         Dict['GUID_STRUCTURE'] = [GuidStringToGuidStructureString('00000000-0000-0000-0000-000000000000')]\r
1222 \r
1223     if StringTableIndex == 0:\r
1224         Dict['STRING_TABLE_INDEX'].append('')\r
1225         Dict['STRING_TABLE_LENGTH'].append(1)\r
1226         Dict['STRING_TABLE_CNAME'].append('')\r
1227         Dict['STRING_TABLE_GUID'].append('')\r
1228         Dict['STRING_TABLE_VALUE'].append('{ 0 }')\r
1229     else:\r
1230         Dict['STRING_TABLE_EMPTY'] = 'FALSE'\r
1231         Dict['STRING_TABLE_SIZE'] = StringTableSize\r
1232 \r
1233     if Dict['SIZE_TABLE_CNAME'] == []:\r
1234         Dict['SIZE_TABLE_CNAME'].append('')\r
1235         Dict['SIZE_TABLE_GUID'].append('')\r
1236         Dict['SIZE_TABLE_CURRENT_LENGTH'].append(0)\r
1237         Dict['SIZE_TABLE_MAXIMUM_LENGTH'].append(0)\r
1238 \r
1239     if NumberOfLocalTokens != 0:\r
1240         Dict['DATABASE_EMPTY']                = 'FALSE'\r
1241         Dict['LOCAL_TOKEN_NUMBER_TABLE_SIZE'] = NumberOfLocalTokens\r
1242         Dict['LOCAL_TOKEN_NUMBER']            = NumberOfLocalTokens\r
1243 \r
1244     if NumberOfExTokens != 0:\r
1245         Dict['EXMAP_TABLE_EMPTY']    = 'FALSE'\r
1246         Dict['EXMAPPING_TABLE_SIZE'] = NumberOfExTokens\r
1247         Dict['EX_TOKEN_NUMBER']      = NumberOfExTokens\r
1248     else:\r
1249         Dict['EXMAPPING_TABLE_EXTOKEN'].append(0)\r
1250         Dict['EXMAPPING_TABLE_LOCAL_TOKEN'].append(0)\r
1251         Dict['EXMAPPING_TABLE_GUID_INDEX'].append(0)\r
1252 \r
1253     if NumberOfSizeItems != 0:\r
1254         Dict['SIZE_TABLE_SIZE'] = NumberOfSizeItems * 2\r
1255 \r
1256     AutoGenH.Append(gPcdDatabaseAutoGenH, Dict)\r
1257     if NumberOfLocalTokens == 0:\r
1258         AutoGenC.Append(gEmptyPcdDatabaseAutoGenC, Dict)\r
1259     else:\r
1260         AutoGenC.Append(gPcdDatabaseAutoGenC, Dict)\r
1261 \r
1262     return AutoGenH, AutoGenC\r
1263 \r
1264 ## Create code for PCD database\r
1265 #\r
1266 #   @param      Info        The ModuleAutoGen object\r
1267 #   @param      AutoGenC    The TemplateString object for C code\r
1268 #   @param      AutoGenH    The TemplateString object for header file\r
1269 #\r
1270 def CreatePcdDatabaseCode (Info, AutoGenC, AutoGenH):\r
1271     if Info.PcdIsDriver == "":\r
1272         return\r
1273     if Info.PcdIsDriver not in gPcdPhaseMap:\r
1274         EdkLogger.error("AutoGen", AUTOGEN_ERROR, "Not supported PcdIsDriver type:%s\n" % Info.PcdIsDriver)\r
1275 \r
1276     AutoGenH.Append(gPcdDatabaseCommonAutoGenH)\r
1277     AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, 'PEI')\r
1278     AutoGenH.Append(AdditionalAutoGenH.String)\r
1279 \r
1280     Phase = gPcdPhaseMap[Info.PcdIsDriver]\r
1281     if Phase == 'PEI':\r
1282         AutoGenC.Append(AdditionalAutoGenC.String)\r
1283 \r
1284     if Phase == 'DXE':\r
1285         AdditionalAutoGenH, AdditionalAutoGenC = CreatePcdDatabasePhaseSpecificAutoGen (Info.PlatformInfo, Phase)\r
1286         AutoGenH.Append(AdditionalAutoGenH.String)\r
1287         AutoGenC.Append(AdditionalAutoGenC.String)\r
1288         AutoGenH.Append(gPcdDatabaseEpilogueAutoGenH)\r
1289 \r
1290 ## Create code for library constructor\r
1291 #\r
1292 #   @param      Info        The ModuleAutoGen object\r
1293 #   @param      AutoGenC    The TemplateString object for C code\r
1294 #   @param      AutoGenH    The TemplateString object for header file\r
1295 #\r
1296 def CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH):\r
1297     if Info.IsLibrary:\r
1298         return\r
1299     #\r
1300     # Library Constructors\r
1301     #\r
1302     ConstructorPrototypeString = TemplateString()\r
1303     ConstructorCallingString = TemplateString()\r
1304     for Lib in Info.DependentLibraryList:\r
1305         if len(Lib.ConstructorList) <= 0:\r
1306             continue\r
1307         Dict = {'Function':Lib.ConstructorList}\r
1308         if Lib.ModuleType == 'BASE':\r
1309             ConstructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1310             ConstructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1311         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1312             ConstructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1313             ConstructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1314         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1315             ConstructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1316             ConstructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1317 \r
1318     if str(ConstructorPrototypeString) == '':\r
1319         ConstructorPrototypeList = []\r
1320     else:\r
1321         ConstructorPrototypeList = [str(ConstructorPrototypeString)]\r
1322     if str(ConstructorCallingString) == '':\r
1323         ConstructorCallingList = []\r
1324     else:\r
1325         ConstructorCallingList = [str(ConstructorCallingString)]\r
1326 \r
1327     Dict = {\r
1328         'Type'              :   'Constructor',\r
1329         'FunctionPrototype' :   ConstructorPrototypeList,\r
1330         'FunctionCall'      :   ConstructorCallingList\r
1331     }\r
1332     if Info.ModuleType == 'BASE':\r
1333         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1334     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1335         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1336     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1337         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1338 \r
1339 ## Create code for library destructor\r
1340 #\r
1341 #   @param      Info        The ModuleAutoGen object\r
1342 #   @param      AutoGenC    The TemplateString object for C code\r
1343 #   @param      AutoGenH    The TemplateString object for header file\r
1344 #\r
1345 def CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH):\r
1346     if Info.IsLibrary:\r
1347         return\r
1348     #\r
1349     # Library Destructors\r
1350     #\r
1351     DestructorPrototypeString = TemplateString()\r
1352     DestructorCallingString = TemplateString()\r
1353     for Index in range(len(Info.DependentLibraryList)-1, -1, -1):\r
1354         Lib = Info.DependentLibraryList[Index]\r
1355         if len(Lib.DestructorList) <= 0:\r
1356             continue\r
1357         Dict = {'Function':Lib.DestructorList}\r
1358         if Lib.ModuleType == 'BASE':\r
1359             DestructorPrototypeString.Append(gLibraryStructorPrototype['BASE'], Dict)\r
1360             DestructorCallingString.Append(gLibraryStructorCall['BASE'], Dict)\r
1361         elif Lib.ModuleType in ['PEI_CORE','PEIM']:\r
1362             DestructorPrototypeString.Append(gLibraryStructorPrototype['PEI'], Dict)\r
1363             DestructorCallingString.Append(gLibraryStructorCall['PEI'], Dict)\r
1364         elif Lib.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1365             DestructorPrototypeString.Append(gLibraryStructorPrototype['DXE'], Dict)\r
1366             DestructorCallingString.Append(gLibraryStructorCall['DXE'], Dict)\r
1367 \r
1368     if str(DestructorPrototypeString) == '':\r
1369         DestructorPrototypeList = []\r
1370     else:\r
1371         DestructorPrototypeList = [str(DestructorPrototypeString)]\r
1372     if str(DestructorCallingString) == '':\r
1373         DestructorCallingList = []\r
1374     else:\r
1375         DestructorCallingList = [str(DestructorCallingString)]\r
1376 \r
1377     Dict = {\r
1378         'Type'              :   'Destructor',\r
1379         'FunctionPrototype' :   DestructorPrototypeList,\r
1380         'FunctionCall'      :   DestructorCallingList\r
1381     }\r
1382     if Info.ModuleType == 'BASE':\r
1383         AutoGenC.Append(gLibraryString['BASE'], Dict)\r
1384     elif Info.ModuleType in ['PEI_CORE','PEIM']:\r
1385         AutoGenC.Append(gLibraryString['PEI'], Dict)\r
1386     elif Info.ModuleType in ['DXE_CORE','DXE_DRIVER','DXE_SMM_DRIVER','DXE_RUNTIME_DRIVER','DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1387         AutoGenC.Append(gLibraryString['DXE'], Dict)\r
1388 \r
1389 \r
1390 ## Create code for ModuleEntryPoint\r
1391 #\r
1392 #   @param      Info        The ModuleAutoGen object\r
1393 #   @param      AutoGenC    The TemplateString object for C code\r
1394 #   @param      AutoGenH    The TemplateString object for header file\r
1395 #\r
1396 def CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH):\r
1397     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1398         return\r
1399     #\r
1400     # Module Entry Points\r
1401     #\r
1402     NumEntryPoints = len(Info.Module.ModuleEntryPointList)\r
1403     Dict = {'Function':Info.Module.ModuleEntryPointList}\r
1404 \r
1405     if Info.ModuleType in ['PEI_CORE', 'DXE_CORE']:\r
1406         if NumEntryPoints != 1:\r
1407             EdkLogger.error("AutoGen", AUTOGEN_ERROR, '%s must have exactly one entry point' % Info.ModuleType,\r
1408                             ExtraData=", ".join(Info.Module.ModuleEntryPointList))\r
1409     if Info.ModuleType == 'PEI_CORE':\r
1410         AutoGenC.Append(gPeiCoreEntryPointString, Dict)\r
1411     elif Info.ModuleType == 'DXE_CORE':\r
1412         AutoGenC.Append(gDxeCoreEntryPointString, Dict)\r
1413     elif Info.ModuleType == 'PEIM':\r
1414         if NumEntryPoints < 2:\r
1415             AutoGenC.Append(gPeimEntryPointString[NumEntryPoints], Dict)\r
1416         else:\r
1417             AutoGenC.Append(gPeimEntryPointString[2], Dict)\r
1418     elif Info.ModuleType in ['DXE_RUNTIME_DRIVER','DXE_DRIVER','DXE_SMM_DRIVER', 'DXE_SAL_DRIVER','UEFI_DRIVER','UEFI_APPLICATION']:\r
1419         if Info.ModuleType == 'DXE_SMM_DRIVER':\r
1420             if NumEntryPoints == 0:\r
1421                 AutoGenC.Append(gDxeSmmEntryPointString[0], Dict)\r
1422             else:\r
1423                 AutoGenC.Append(gDxeSmmEntryPointString[1], Dict)\r
1424         else:\r
1425             if NumEntryPoints < 2:\r
1426                 AutoGenC.Append(gUefiEntryPointString[NumEntryPoints], Dict)\r
1427             else:\r
1428                 AutoGenC.Append(gUefiEntryPointString[2], Dict)\r
1429 \r
1430 ## Create code for ModuleUnloadImage\r
1431 #\r
1432 #   @param      Info        The ModuleAutoGen object\r
1433 #   @param      AutoGenC    The TemplateString object for C code\r
1434 #   @param      AutoGenH    The TemplateString object for header file\r
1435 #\r
1436 def CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH):\r
1437     if Info.IsLibrary or Info.ModuleType == "USER_DEFINED":\r
1438         return\r
1439     #\r
1440     # Unload Image Handlers\r
1441     #\r
1442     NumUnloadImage = len(Info.Module.ModuleUnloadImageList)\r
1443     Dict = {'Count':NumUnloadImage, 'Function':Info.Module.ModuleUnloadImageList}\r
1444     if NumUnloadImage < 2:\r
1445         AutoGenC.Append(gUefiUnloadImageString[NumUnloadImage], Dict)\r
1446     else:\r
1447         AutoGenC.Append(gUefiUnloadImageString[2], Dict)\r
1448 \r
1449 ## Create code for GUID\r
1450 #\r
1451 #   @param      Info        The ModuleAutoGen object\r
1452 #   @param      AutoGenC    The TemplateString object for C code\r
1453 #   @param      AutoGenH    The TemplateString object for header file\r
1454 #\r
1455 def CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH):\r
1456     if Info.IsLibrary:\r
1457         return\r
1458 \r
1459     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1460         GuidType = "GUID"\r
1461     else:\r
1462         GuidType = "EFI_GUID"\r
1463 \r
1464     #\r
1465     # GUIDs\r
1466     #\r
1467     for Key in Info.GuidList:\r
1468         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.GuidList[Key]))\r
1469 \r
1470 ## Create code for protocol\r
1471 #\r
1472 #   @param      Info        The ModuleAutoGen object\r
1473 #   @param      AutoGenC    The TemplateString object for C code\r
1474 #   @param      AutoGenH    The TemplateString object for header file\r
1475 #\r
1476 def CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH):\r
1477     if Info.IsLibrary:\r
1478         return\r
1479 \r
1480     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1481         GuidType = "GUID"\r
1482     else:\r
1483         GuidType = "EFI_GUID"\r
1484 \r
1485     #\r
1486     # Protocol GUIDs\r
1487     #\r
1488     for Key in Info.ProtocolList:\r
1489         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.ProtocolList[Key]))\r
1490 \r
1491 ## Create code for PPI\r
1492 #\r
1493 #   @param      Info        The ModuleAutoGen object\r
1494 #   @param      AutoGenC    The TemplateString object for C code\r
1495 #   @param      AutoGenH    The TemplateString object for header file\r
1496 #\r
1497 def CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH):\r
1498     if Info.IsLibrary:\r
1499         return\r
1500 \r
1501     if Info.ModuleType in ["USER_DEFINED", "BASE"]:\r
1502         GuidType = "GUID"\r
1503     else:\r
1504         GuidType = "EFI_GUID"\r
1505 \r
1506     #\r
1507     # PPI GUIDs\r
1508     #\r
1509     for Key in Info.PpiList:\r
1510         AutoGenC.Append('GLOBAL_REMOVE_IF_UNREFERENCED %s %s = %s;\n' % (GuidType, Key, Info.PpiList[Key]))\r
1511 \r
1512 ## Create code for PCD\r
1513 #\r
1514 #   @param      Info        The ModuleAutoGen object\r
1515 #   @param      AutoGenC    The TemplateString object for C code\r
1516 #   @param      AutoGenH    The TemplateString object for header file\r
1517 #\r
1518 def CreatePcdCode(Info, AutoGenC, AutoGenH):\r
1519     if Info.IsLibrary:\r
1520         for Pcd in Info.PcdList:\r
1521             CreateLibraryPcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1522     else:\r
1523         for Pcd in Info.PcdList:\r
1524             CreateModulePcdCode(Info, AutoGenC, AutoGenH, Pcd)\r
1525     CreatePcdDatabaseCode(Info, AutoGenC, AutoGenH)\r
1526 \r
1527 ## Create code for unicode string definition\r
1528 #\r
1529 #   @param      Info        The ModuleAutoGen object\r
1530 #   @param      AutoGenC    The TemplateString object for C code\r
1531 #   @param      AutoGenH    The TemplateString object for header file\r
1532 #\r
1533 def CreateUnicodeStringCode(Info, AutoGenC, AutoGenH):\r
1534     if len(Info.UnicodeFileList) == 0:\r
1535         return\r
1536 \r
1537     WorkingDir = os.getcwd()\r
1538     os.chdir(Info.WorkspaceDir)\r
1539 \r
1540     #IncList = [os.path.join(Info.WorkspaceDir, Inc) for Inc in Info.IncludePathList]\r
1541     IncList = [Info.SourceDir]\r
1542     SrcList = [F[0] for F in Info.SourceFileList]\r
1543     Header, Code = GetStringFiles(Info.UnicodeFileList, SrcList, IncList, ['.uni'], Info.Name)\r
1544     AutoGenC.Append("\n//\n//Unicode String Pack Definition\n//\n")\r
1545     AutoGenC.Append(Code)\r
1546     AutoGenC.Append("\n")\r
1547     AutoGenH.Append("\n//\n//Unicode String ID\n//\n")\r
1548     AutoGenH.Append(Header)\r
1549     AutoGenH.Append("\n#define STRING_ARRAY_NAME %sStrings\n" % Info.Name)\r
1550     os.chdir(WorkingDir)\r
1551 \r
1552 ## Create common code\r
1553 #\r
1554 #   @param      Info        The ModuleAutoGen object\r
1555 #   @param      AutoGenC    The TemplateString object for C code\r
1556 #   @param      AutoGenH    The TemplateString object for header file\r
1557 #\r
1558 def CreateHeaderCode(Info, AutoGenC, AutoGenH):\r
1559     # file header\r
1560     AutoGenH.Append(gAutoGenHeaderString,   {'FileName':'AutoGen.h'})\r
1561     # header file Prologue\r
1562     AutoGenH.Append(gAutoGenHPrologueString,{'Guid':Info.Guid.replace('-','_')})\r
1563     if Info.AutoGenVersion >= 0x00010005:\r
1564         # specification macros\r
1565         AutoGenH.Append(gSpecificationString,   {'SpecificationName':Info.Macro.keys(), \r
1566                                                  'SpecificationValue':Info.Macro.values()})\r
1567         # header files includes\r
1568         AutoGenH.Append("#include <%s>\n\n" % gBasicHeaderFile)\r
1569         AutoGenH.Append('\nextern GUID  gEfiCallerIdGuid;\n\n')\r
1570     \r
1571         if Info.IsLibrary:\r
1572             return\r
1573     \r
1574         AutoGenH.Append("#define EFI_CALLER_ID_GUID \\\n  %s\n" % GuidStringToGuidStructureString(Info.Guid))\r
1575     \r
1576     if Info.IsLibrary:\r
1577         return\r
1578     # C file header\r
1579     AutoGenC.Append(gAutoGenHeaderString, {'FileName':'AutoGen.c'})\r
1580     if Info.AutoGenVersion >= 0x00010005:\r
1581         # C file header files includes\r
1582         for Inc in gModuleTypeHeaderFile[Info.ModuleType]:\r
1583             AutoGenC.Append("#include <%s>\n" % Inc)\r
1584     \r
1585         #\r
1586         # Publish the CallerId Guid\r
1587         #\r
1588         AutoGenC.Append('\nGLOBAL_REMOVE_IF_UNREFERENCED GUID gEfiCallerIdGuid = %s;\n' % GuidStringToGuidStructureString(Info.Guid))\r
1589     else:\r
1590         # R8 modules my have nothing in the AutoGen.c. So it needs following line\r
1591         AutoGenC.Append('\nextern int __make_me_compile_correctly;\n\n')\r
1592 \r
1593 \r
1594 ## Create common code for header file\r
1595 #\r
1596 #   @param      Info        The ModuleAutoGen object\r
1597 #   @param      AutoGenC    The TemplateString object for C code\r
1598 #   @param      AutoGenH    The TemplateString object for header file\r
1599 #\r
1600 def CreateFooterCode(Info, AutoGenC, AutoGenH):\r
1601     AutoGenH.Append(gAutoGenHEpilogueString)\r
1602 \r
1603 ## Create code for a module\r
1604 #\r
1605 #   @param      Info        The ModuleAutoGen object\r
1606 #   @param      AutoGenC    The TemplateString object for C code\r
1607 #   @param      AutoGenH    The TemplateString object for header file\r
1608 #\r
1609 def CreateCode(Info, AutoGenC, AutoGenH):\r
1610     CreateHeaderCode(Info, AutoGenC, AutoGenH)\r
1611 \r
1612     if Info.AutoGenVersion >= 0x00010005:\r
1613         CreateLibraryConstructorCode(Info, AutoGenC, AutoGenH)\r
1614         CreateLibraryDestructorCode(Info, AutoGenC, AutoGenH)\r
1615         CreateModuleEntryPointCode(Info, AutoGenC, AutoGenH)\r
1616         CreateModuleUnloadImageCode(Info, AutoGenC, AutoGenH)\r
1617         CreateGuidDefinitionCode(Info, AutoGenC, AutoGenH)\r
1618         CreateProtocolDefinitionCode(Info, AutoGenC, AutoGenH)\r
1619         CreatePpiDefinitionCode(Info, AutoGenC, AutoGenH)\r
1620         CreatePcdCode(Info, AutoGenC, AutoGenH)\r
1621     CreateUnicodeStringCode(Info, AutoGenC, AutoGenH)\r
1622 \r
1623     CreateFooterCode(Info, AutoGenC, AutoGenH)\r
1624 \r
1625 ## Create the code file\r
1626 #\r
1627 #   @param      FilePath    The path of code file\r
1628 #   @param      Content     The content of code file\r
1629 #\r
1630 #   @retval     True        If file content is changed or file doesn't exist\r
1631 #   @retval     False       If the file exists and the content is not changed\r
1632 #\r
1633 def Generate(FilePath, Content):\r
1634     return SaveFileOnChange(FilePath, Content)\r