]> git.proxmox.com Git - mirror_edk2.git/blob - BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
projects / mirror_edk2.git / blob
? search:


b8350623f2a06f8c6f3dc6855f43bec5e3018448
[mirror_edk2.git] / BaseTools / Source / C / VfrCompile / VfrFormPkg.cpp
1 /** @file
2
3 The definition of CFormPkg's member function
4
5 Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
10
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14 **/
15
16 #include "stdio.h"
17 #include "assert.h"
18 #include "VfrFormPkg.h"
19
20 /*
21 * The definition of CFormPkg's member function
22 */
23
24 SPendingAssign::SPendingAssign (
25 IN CHAR8 *Key,
26 IN VOID *Addr,
27 IN UINT32 Len,
28 IN UINT32 LineNo,
29 IN CONST CHAR8 *Msg
30 )
31 {
32 mKey = NULL;
33 mAddr = Addr;
34 mLen = Len;
35 mFlag = PENDING;
36 mLineNo = LineNo;
37 mMsg = NULL;
38 mNext = NULL;
39 if (Key != NULL) {
40 mKey = new CHAR8[strlen (Key) + 1];
41 if (mKey != NULL) {
42 strcpy (mKey, Key);
43 }
44 }
45
46 if (Msg != NULL) {
47 mMsg = new CHAR8[strlen (Msg) + 1];
48 if (mMsg != NULL) {
49 strcpy (mMsg, Msg);
50 }
51 }
52 }
53
54 SPendingAssign::~SPendingAssign (
55 VOID
56 )
57 {
58 if (mKey != NULL) {
59 delete[] mKey;
60 }
61 mAddr = NULL;
62 mLen = 0;
63 mLineNo = 0;
64 if (mMsg != NULL) {
65 delete[] mMsg;
66 }
67 mNext = NULL;
68 }
69
70 VOID
71 SPendingAssign::SetAddrAndLen (
72 IN VOID *Addr,
73 IN UINT32 LineNo
74 )
75 {
76 mAddr = Addr;
77 mLineNo = LineNo;
78 }
79
80 VOID
81 SPendingAssign::AssignValue (
82 IN VOID *Addr,
83 IN UINT32 Len
84 )
85 {
86 memmove (mAddr, Addr, (mLen < Len ? mLen : Len));
87 mFlag = ASSIGNED;
88 }
89
90 CHAR8 *
91 SPendingAssign::GetKey (
92 VOID
93 )
94 {
95 return mKey;
96 }
97
98 CFormPkg::CFormPkg (
99 IN UINT32 BufferSize
100 )
101 {
102 CHAR8 *BufferStart;
103 CHAR8 *BufferEnd;
104 SBufferNode *Node;
105
106 mPkgLength = 0;
107 mBufferNodeQueueHead = NULL;
108 mCurrBufferNode = NULL;
109
110 Node = new SBufferNode;
111 if (Node == NULL) {
112 return ;
113 }
114 BufferStart = new CHAR8[BufferSize];
115 if (BufferStart == NULL) {
116 delete Node;
117 return;
118 }
119 BufferEnd = BufferStart + BufferSize;
120
121 memset (BufferStart, 0, BufferSize);
122 Node->mBufferStart = BufferStart;
123 Node->mBufferEnd = BufferEnd;
124 Node->mBufferFree = BufferStart;
125 Node->mNext = NULL;
126
127 mBufferSize = BufferSize;
128 mBufferNodeQueueHead = Node;
129 mBufferNodeQueueTail = Node;
130 mCurrBufferNode = Node;
131 }
132
133 CFormPkg::~CFormPkg ()
134 {
135 SBufferNode *pBNode;
136 SPendingAssign *pPNode;
137
138 while (mBufferNodeQueueHead != NULL) {
139 pBNode = mBufferNodeQueueHead;
140 mBufferNodeQueueHead = mBufferNodeQueueHead->mNext;
141 if (pBNode->mBufferStart != NULL) {
142 delete pBNode->mBufferStart;
143 delete pBNode;
144 }
145 }
146 mBufferNodeQueueTail = NULL;
147 mCurrBufferNode = NULL;
148
149 while (PendingAssignList != NULL) {
150 pPNode = PendingAssignList;
151 PendingAssignList = PendingAssignList->mNext;
152 delete pPNode;
153 }
154 PendingAssignList = NULL;
155 }
156
157 SBufferNode *
158 CFormPkg::CreateNewNode (
159 VOID
160 )
161 {
162 SBufferNode *Node;
163
164 Node = new SBufferNode;
165 if (Node == NULL) {
166 return NULL;
167 }
168
169 Node->mBufferStart = new CHAR8[mBufferSize];
170 if (Node->mBufferStart == NULL) {
171 delete Node;
172 return NULL;
173 } else {
174 memset (Node->mBufferStart, 0, mBufferSize);
175 Node->mBufferEnd = Node->mBufferStart + mBufferSize;
176 Node->mBufferFree = Node->mBufferStart;
177 Node->mNext = NULL;
178 }
179
180 return Node;
181 }
182
183 CHAR8 *
184 CFormPkg::IfrBinBufferGet (
185 IN UINT32 Len
186 )
187 {
188 CHAR8 *BinBuffer = NULL;
189 SBufferNode *Node = NULL;
190
191 if ((Len == 0) || (Len > mBufferSize)) {
192 return NULL;
193 }
194
195 if ((mCurrBufferNode->mBufferFree + Len) <= mCurrBufferNode->mBufferEnd) {
196 BinBuffer = mCurrBufferNode->mBufferFree;
197 mCurrBufferNode->mBufferFree += Len;
198 } else {
199 Node = CreateNewNode ();
200 if (Node == NULL) {
201 return NULL;
202 }
203
204 if (mBufferNodeQueueTail == NULL) {
205 mBufferNodeQueueHead = mBufferNodeQueueTail = Node;
206 } else {
207 mBufferNodeQueueTail->mNext = Node;
208 mBufferNodeQueueTail = Node;
209 }
210 mCurrBufferNode = Node;
211
212 //
213 // Now try again.
214 //
215 BinBuffer = mCurrBufferNode->mBufferFree;
216 mCurrBufferNode->mBufferFree += Len;
217 }
218
219 mPkgLength += Len;
220
221 return BinBuffer;
222 }
223
224 inline
225 UINT32
226 CFormPkg::GetPkgLength (
227 VOID
228 )
229 {
230 return mPkgLength;
231 }
232
233 VOID
234 CFormPkg::Open (
235 VOID
236 )
237 {
238 mReadBufferNode = mBufferNodeQueueHead;
239 mReadBufferOffset = 0;
240 }
241
242 VOID
243 CFormPkg::Close (
244 VOID
245 )
246 {
247 mReadBufferNode = NULL;
248 mReadBufferOffset = 0;
249 }
250
251 UINT32
252 CFormPkg::Read (
253 IN CHAR8 *Buffer,
254 IN UINT32 Size
255 )
256 {
257 UINT32 Index;
258
259 if ((Size == 0) || (Buffer == NULL)) {
260 return 0;
261 }
262
263 if (mReadBufferNode == NULL) {
264 return 0;
265 }
266
267 for (Index = 0; Index < Size; Index++) {
268 if ((mReadBufferNode->mBufferStart + mReadBufferOffset) < mReadBufferNode->mBufferFree) {
269 Buffer[Index] = mReadBufferNode->mBufferStart[mReadBufferOffset++];
270 } else {
271 if ((mReadBufferNode = mReadBufferNode->mNext) == NULL) {
272 return Index;
273 } else {
274 mReadBufferOffset = 0;
275 Index --;
276 }
277 }
278 }
279
280 return Size;
281 }
282
283 EFI_VFR_RETURN_CODE
284 CFormPkg::BuildPkgHdr (
285 OUT EFI_HII_PACKAGE_HEADER **PkgHdr
286 )
287 {
288 if (PkgHdr == NULL) {
289 return VFR_RETURN_FATAL_ERROR;
290 }
291
292 if (((*PkgHdr) = new EFI_HII_PACKAGE_HEADER) == NULL) {
293 return VFR_RETURN_OUT_FOR_RESOURCES;
294 }
295
296 (*PkgHdr)->Type = EFI_HII_PACKAGE_FORM;
297 (*PkgHdr)->Length = mPkgLength + sizeof (EFI_HII_PACKAGE_HEADER);
298
299 return VFR_RETURN_SUCCESS;
300 }
301
302 EFI_VFR_RETURN_CODE
303 CFormPkg::BuildPkg (
304 OUT PACKAGE_DATA &TBuffer
305 )
306 {
307
308 CHAR8 *Temp;
309 UINT32 Size;
310 CHAR8 Buffer[1024];
311
312 if (TBuffer.Buffer != NULL) {
313 delete TBuffer.Buffer;
314 }
315
316 TBuffer.Size = mPkgLength;
317 TBuffer.Buffer = NULL;
318 if (TBuffer.Size != 0) {
319 TBuffer.Buffer = new CHAR8[TBuffer.Size];
320 } else {
321 return VFR_RETURN_SUCCESS;
322 }
323
324 Temp = TBuffer.Buffer;
325 Open ();
326 while ((Size = Read (Buffer, 1024)) != 0) {
327 memcpy (Temp, Buffer, Size);
328 Temp += Size;
329 }
330 Close ();
331 return VFR_RETURN_SUCCESS;
332 }
333
334
335 EFI_VFR_RETURN_CODE
336 CFormPkg::BuildPkg (
337 IN FILE *Output,
338 IN PACKAGE_DATA *PkgData
339 )
340 {
341 EFI_VFR_RETURN_CODE Ret;
342 CHAR8 Buffer[1024];
343 UINT32 Size;
344 EFI_HII_PACKAGE_HEADER *PkgHdr;
345
346 if (Output == NULL) {
347 return VFR_RETURN_FATAL_ERROR;
348 }
349
350 if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) {
351 return Ret;
352 }
353 fwrite (PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER), 1, Output);
354 delete PkgHdr;
355
356 if (PkgData == NULL) {
357 Open ();
358 while ((Size = Read (Buffer, 1024)) != 0) {
359 fwrite (Buffer, Size, 1, Output);
360 }
361 Close ();
362 } else {
363 fwrite (PkgData->Buffer, PkgData->Size, 1, Output);
364 }
365
366 return VFR_RETURN_SUCCESS;
367 }
368
369 VOID
370 CFormPkg::_WRITE_PKG_LINE (
371 IN FILE *pFile,
372 IN UINT32 LineBytes,
373 IN CONST CHAR8 *LineHeader,
374 IN CHAR8 *BlkBuf,
375 IN UINT32 BlkSize
376 )
377 {
378 UINT32 Index;
379
380 if ((pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
381 return;
382 }
383
384 for (Index = 0; Index < BlkSize; Index++) {
385 if ((Index % LineBytes) == 0) {
386 fprintf (pFile, "\n%s", LineHeader);
387 }
388 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]);
389 }
390 }
391
392 VOID
393 CFormPkg::_WRITE_PKG_END (
394 IN FILE *pFile,
395 IN UINT32 LineBytes,
396 IN CONST CHAR8 *LineHeader,
397 IN CHAR8 *BlkBuf,
398 IN UINT32 BlkSize
399 )
400 {
401 UINT32 Index;
402
403 if ((BlkSize == 0) || (pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) {
404 return;
405 }
406
407 for (Index = 0; Index < BlkSize - 1; Index++) {
408 if ((Index % LineBytes) == 0) {
409 fprintf (pFile, "\n%s", LineHeader);
410 }
411 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]);
412 }
413
414 if ((Index % LineBytes) == 0) {
415 fprintf (pFile, "\n%s", LineHeader);
416 }
417 fprintf (pFile, "0x%02X\n", (UINT8)BlkBuf[Index]);
418 }
419
420 #define BYTES_PRE_LINE 0x10
421 UINT32 gAdjustOpcodeOffset = 0;
422 BOOLEAN gNeedAdjustOpcode = FALSE;
423 UINT32 gAdjustOpcodeLen = 0;
424
425 EFI_VFR_RETURN_CODE
426 CFormPkg::GenCFile (
427 IN CHAR8 *BaseName,
428 IN FILE *pFile,
429 IN PACKAGE_DATA *PkgData
430 )
431 {
432 EFI_VFR_RETURN_CODE Ret;
433 CHAR8 Buffer[BYTES_PRE_LINE * 8];
434 EFI_HII_PACKAGE_HEADER *PkgHdr;
435 UINT32 PkgLength = 0;
436 UINT32 ReadSize = 0;
437
438 if ((BaseName == NULL) || (pFile == NULL)) {
439 return VFR_RETURN_FATAL_ERROR;
440 }
441
442 fprintf (pFile, "\nunsigned char %sBin[] = {\n", BaseName);
443
444 if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) {
445 return Ret;
446 }
447
448 //
449 // For framework vfr file, the extension framework header will be added.
450 //
451 if (VfrCompatibleMode) {
452 fprintf (pFile, " // FRAMEWORK PACKAGE HEADER Length\n");
453 PkgLength = PkgHdr->Length + sizeof (UINT32) + 2;
454 _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&PkgLength, sizeof (UINT32));
455 fprintf (pFile, "\n\n // FRAMEWORK PACKAGE HEADER Type\n");
456 PkgLength = 3;
457 _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&PkgLength, sizeof (UINT16));
458 } else {
459 fprintf (pFile, " // ARRAY LENGTH\n");
460 PkgLength = PkgHdr->Length + sizeof (UINT32);
461 _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (CHAR8 *)&PkgLength, sizeof (UINT32));
462 }
463
464 fprintf (pFile, "\n\n // PACKAGE HEADER\n");
465 _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (CHAR8 *)PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER));
466 PkgLength = sizeof (EFI_HII_PACKAGE_HEADER);
467
468 fprintf (pFile, "\n\n // PACKAGE DATA\n");
469
470 if (PkgData == NULL) {
471 Open ();
472 while ((ReadSize = Read ((CHAR8 *)Buffer, BYTES_PRE_LINE * 8)) != 0) {
473 PkgLength += ReadSize;
474 if (PkgLength < PkgHdr->Length) {
475 _WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, " ", Buffer, ReadSize);
476 } else {
477 _WRITE_PKG_END (pFile, BYTES_PRE_LINE, " ", Buffer, ReadSize);
478 }
479 }
480 Close ();
481 } else {
482 if (PkgData->Size % BYTES_PRE_LINE != 0) {
483 PkgLength = PkgData->Size - (PkgData->Size % BYTES_PRE_LINE);
484 _WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, " ", PkgData->Buffer, PkgLength);
485 _WRITE_PKG_END (pFile, BYTES_PRE_LINE, " ", PkgData->Buffer + PkgLength, PkgData->Size % BYTES_PRE_LINE);
486 } else {
487 PkgLength = PkgData->Size - BYTES_PRE_LINE;
488 _WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, " ", PkgData->Buffer, PkgLength);
489 _WRITE_PKG_END (pFile, BYTES_PRE_LINE, " ", PkgData->Buffer + PkgLength, BYTES_PRE_LINE);
490 }
491 }
492
493 delete PkgHdr;
494 fprintf (pFile, "\n};\n");
495
496 return VFR_RETURN_SUCCESS;
497 }
498
499 EFI_VFR_RETURN_CODE
500 CFormPkg::AssignPending (
501 IN CHAR8 *Key,
502 IN VOID *ValAddr,
503 IN UINT32 ValLen,
504 IN UINT32 LineNo,
505 IN CONST CHAR8 *Msg
506 )
507 {
508 SPendingAssign *pNew;
509
510 pNew = new SPendingAssign (Key, ValAddr, ValLen, LineNo, Msg);
511 if (pNew == NULL) {
512 return VFR_RETURN_OUT_FOR_RESOURCES;
513 }
514
515 pNew->mNext = PendingAssignList;
516 PendingAssignList = pNew;
517 return VFR_RETURN_SUCCESS;
518 }
519
520 VOID
521 CFormPkg::DoPendingAssign (
522 IN CHAR8 *Key,
523 IN VOID *ValAddr,
524 IN UINT32 ValLen
525 )
526 {
527 SPendingAssign *pNode;
528
529 if ((Key == NULL) || (ValAddr == NULL)) {
530 return;
531 }
532
533 for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
534 if (strcmp (pNode->mKey, Key) == 0) {
535 pNode->AssignValue (ValAddr, ValLen);
536 }
537 }
538 }
539
540 bool
541 CFormPkg::HavePendingUnassigned (
542 VOID
543 )
544 {
545 SPendingAssign *pNode;
546
547 for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
548 if (pNode->mFlag == PENDING) {
549 return TRUE;
550 }
551 }
552
553 return FALSE;
554 }
555
556 VOID
557 CFormPkg::PendingAssignPrintAll (
558 VOID
559 )
560 {
561 SPendingAssign *pNode;
562
563 for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
564 if (pNode->mFlag == PENDING) {
565 gCVfrErrorHandle.PrintMsg (pNode->mLineNo, pNode->mKey, "Error", pNode->mMsg);
566 }
567 }
568 }
569
570 SBufferNode *
571 CFormPkg::GetBinBufferNodeForAddr (
572 IN CHAR8 *BinBuffAddr
573 )
574 {
575 SBufferNode *TmpNode;
576
577 TmpNode = mBufferNodeQueueHead;
578
579 while (TmpNode != NULL) {
580 if (TmpNode->mBufferStart <= BinBuffAddr && TmpNode->mBufferFree >= BinBuffAddr) {
581 return TmpNode;
582 }
583
584 TmpNode = TmpNode->mNext;
585 }
586
587 return NULL;
588 }
589
590 SBufferNode *
591 CFormPkg::GetNodeBefore(
592 IN SBufferNode *CurrentNode
593 )
594 {
595 SBufferNode *FirstNode = mBufferNodeQueueHead;
596 SBufferNode *LastNode = mBufferNodeQueueHead;
597
598 while (FirstNode != NULL) {
599 if (FirstNode == CurrentNode) {
600 break;
601 }
602
603 LastNode = FirstNode;
604 FirstNode = FirstNode->mNext;
605 }
606
607 if (FirstNode == NULL) {
608 LastNode = NULL;
609 }
610
611 return LastNode;
612 }
613
614 EFI_VFR_RETURN_CODE
615 CFormPkg::InsertNodeBefore(
616 IN SBufferNode *CurrentNode,
617 IN SBufferNode *NewNode
618 )
619 {
620 SBufferNode *LastNode = GetNodeBefore (CurrentNode);
621
622 if (LastNode == NULL) {
623 return VFR_RETURN_MISMATCHED;
624 }
625
626 NewNode->mNext = LastNode->mNext;
627 LastNode->mNext = NewNode;
628
629 return VFR_RETURN_SUCCESS;
630 }
631
632 CHAR8 *
633 CFormPkg::GetBufAddrBaseOnOffset (
634 IN UINT32 Offset
635 )
636 {
637 SBufferNode *TmpNode;
638 UINT32 TotalBufLen;
639 UINT32 CurrentBufLen;
640
641 TotalBufLen = 0;
642
643 for (TmpNode = mBufferNodeQueueHead; TmpNode != NULL; TmpNode = TmpNode->mNext) {
644 CurrentBufLen = TmpNode->mBufferFree - TmpNode->mBufferStart;
645 if (Offset >= TotalBufLen && Offset < TotalBufLen + CurrentBufLen) {
646 return TmpNode->mBufferStart + (Offset - TotalBufLen);
647 }
648
649 TotalBufLen += CurrentBufLen;
650 }
651
652 return NULL;
653 }
654
655 EFI_VFR_RETURN_CODE
656 CFormPkg::AdjustDynamicInsertOpcode (
657 IN CHAR8 *InserPositionAddr,
658 IN CHAR8 *InsertOpcodeAddr,
659 IN BOOLEAN CreateOpcodeAfterParsingVfr
660 )
661 {
662 SBufferNode *InserPositionNode;
663 SBufferNode *InsertOpcodeNode;
664 SBufferNode *NewRestoreNodeBegin;
665 SBufferNode *NewRestoreNodeEnd;
666 SBufferNode *NewLastEndNode;
667 SBufferNode *TmpNode;
668 UINT32 NeedRestoreCodeLen;
669
670 NewRestoreNodeEnd = NULL;
671
672 InserPositionNode = GetBinBufferNodeForAddr(InserPositionAddr);
673 InsertOpcodeNode = GetBinBufferNodeForAddr(InsertOpcodeAddr);
674 assert (InserPositionNode != NULL);
675 assert (InsertOpcodeNode != NULL);
676
677 if (InserPositionNode == InsertOpcodeNode) {
678 //
679 // Create New Node to save the restore opcode.
680 //
681 NeedRestoreCodeLen = InsertOpcodeAddr - InserPositionAddr;
682 gAdjustOpcodeLen = NeedRestoreCodeLen;
683 NewRestoreNodeBegin = CreateNewNode ();
684 if (NewRestoreNodeBegin == NULL) {
685 return VFR_RETURN_OUT_FOR_RESOURCES;
686 }
687 memcpy (NewRestoreNodeBegin->mBufferFree, InserPositionAddr, NeedRestoreCodeLen);
688 NewRestoreNodeBegin->mBufferFree += NeedRestoreCodeLen;
689
690 //
691 // Override the restore buffer data.
692 //
693 memmove (InserPositionAddr, InsertOpcodeAddr, InsertOpcodeNode->mBufferFree - InsertOpcodeAddr);
694 InsertOpcodeNode->mBufferFree -= NeedRestoreCodeLen;
695 memset (InsertOpcodeNode->mBufferFree, 0, NeedRestoreCodeLen);
696 } else {
697 //
698 // Create New Node to save the restore opcode.
699 //
700 NeedRestoreCodeLen = InserPositionNode->mBufferFree - InserPositionAddr;
701 gAdjustOpcodeLen = NeedRestoreCodeLen;
702 NewRestoreNodeBegin = CreateNewNode ();
703 if (NewRestoreNodeBegin == NULL) {
704 return VFR_RETURN_OUT_FOR_RESOURCES;
705 }
706 memcpy (NewRestoreNodeBegin->mBufferFree, InserPositionAddr, NeedRestoreCodeLen);
707 NewRestoreNodeBegin->mBufferFree += NeedRestoreCodeLen;
708 //
709 // Override the restore buffer data.
710 //
711 InserPositionNode->mBufferFree -= NeedRestoreCodeLen;
712 //
713 // Link the restore data to new node.
714 //
715 NewRestoreNodeBegin->mNext = InserPositionNode->mNext;
716
717 //
718 // Count the Adjust opcode len.
719 //
720 TmpNode = InserPositionNode->mNext;
721 while (TmpNode != InsertOpcodeNode) {
722 gAdjustOpcodeLen += TmpNode->mBufferFree - TmpNode->mBufferStart;
723 TmpNode = TmpNode->mNext;
724 }
725
726 //
727 // Create New Node to save the last node of restore opcode.
728 //
729 NeedRestoreCodeLen = InsertOpcodeAddr - InsertOpcodeNode->mBufferStart;
730 gAdjustOpcodeLen += NeedRestoreCodeLen;
731 if (NeedRestoreCodeLen > 0) {
732 NewRestoreNodeEnd = CreateNewNode ();
733 if (NewRestoreNodeEnd == NULL) {
734 return VFR_RETURN_OUT_FOR_RESOURCES;
735 }
736 memcpy (NewRestoreNodeEnd->mBufferFree, InsertOpcodeNode->mBufferStart, NeedRestoreCodeLen);
737 NewRestoreNodeEnd->mBufferFree += NeedRestoreCodeLen;
738 //
739 // Override the restore buffer data.
740 //
741 memmove (InsertOpcodeNode->mBufferStart, InsertOpcodeAddr, InsertOpcodeNode->mBufferFree - InsertOpcodeAddr);
742 InsertOpcodeNode->mBufferFree -= InsertOpcodeAddr - InsertOpcodeNode->mBufferStart;
743
744 //
745 // Insert the last restore data node.
746 //
747 TmpNode = GetNodeBefore (InsertOpcodeNode);
748 assert (TmpNode != NULL);
749
750 if (TmpNode == InserPositionNode) {
751 NewRestoreNodeBegin->mNext = NewRestoreNodeEnd;
752 } else {
753 TmpNode->mNext = NewRestoreNodeEnd;
754 }
755 //
756 // Connect the dynamic opcode node to the node after InserPositionNode.
757 //
758 InserPositionNode->mNext = InsertOpcodeNode;
759 }
760 }
761
762 if (CreateOpcodeAfterParsingVfr) {
763 //
764 // Th new opcodes were created after Parsing Vfr file,
765 // so the content in mBufferNodeQueueTail must be the new created opcodes.
766 // So connet the NewRestoreNodeBegin to the tail and update the tail node.
767 //
768 mBufferNodeQueueTail->mNext = NewRestoreNodeBegin;
769 if (NewRestoreNodeEnd != NULL) {
770 mBufferNodeQueueTail = NewRestoreNodeEnd;
771 } else {
772 mBufferNodeQueueTail = NewRestoreNodeBegin;
773 }
774 } else {
775 if (mBufferNodeQueueTail->mBufferFree - mBufferNodeQueueTail->mBufferStart > 2) {
776 //
777 // End form set opcode all in the mBufferNodeQueueTail node.
778 //
779 NewLastEndNode = CreateNewNode ();
780 if (NewLastEndNode == NULL) {
781 return VFR_RETURN_OUT_FOR_RESOURCES;
782 }
783 NewLastEndNode->mBufferStart[0] = 0x29;
784 NewLastEndNode->mBufferStart[1] = 0x02;
785 NewLastEndNode->mBufferFree += 2;
786
787 mBufferNodeQueueTail->mBufferFree -= 2;
788
789 mBufferNodeQueueTail->mNext = NewRestoreNodeBegin;
790 if (NewRestoreNodeEnd != NULL) {
791 NewRestoreNodeEnd->mNext = NewLastEndNode;
792 } else {
793 NewRestoreNodeBegin->mNext = NewLastEndNode;
794 }
795
796 mBufferNodeQueueTail = NewLastEndNode;
797 } else if (mBufferNodeQueueTail->mBufferFree - mBufferNodeQueueTail->mBufferStart == 2) {
798 TmpNode = GetNodeBefore(mBufferNodeQueueTail);
799 assert (TmpNode != NULL);
800
801 TmpNode->mNext = NewRestoreNodeBegin;
802 if (NewRestoreNodeEnd != NULL) {
803 NewRestoreNodeEnd->mNext = mBufferNodeQueueTail;
804 } else {
805 NewRestoreNodeBegin->mNext = mBufferNodeQueueTail;
806 }
807 }
808 }
809 mCurrBufferNode = mBufferNodeQueueTail;
810 return VFR_RETURN_SUCCESS;
811 }
812
813 EFI_VFR_RETURN_CODE
814 CFormPkg::DeclarePendingQuestion (
815 IN CVfrVarDataTypeDB &lCVfrVarDataTypeDB,
816 IN CVfrDataStorage &lCVfrDataStorage,
817 IN CVfrQuestionDB &lCVfrQuestionDB,
818 IN EFI_GUID *LocalFormSetGuid,
819 IN UINT32 LineNo,
820 OUT CHAR8 **InsertOpcodeAddr
821 )
822 {
823 SPendingAssign *pNode;
824 CHAR8 *VarStr;
825 UINT32 ArrayIdx;
826 CHAR8 FName[MAX_NAME_LEN];
827 CHAR8 *SName;
828 CHAR8 *NewStr;
829 UINT32 ShrinkSize = 0;
830 EFI_VFR_RETURN_CODE ReturnCode;
831 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
832 UINT8 LFlags;
833 UINT32 MaxValue;
834 CIfrGuid *GuidObj = NULL;
835
836 //
837 // Declare all questions as Numeric in DisableIf True
838 //
839 // DisableIf
840 CIfrDisableIf DIObj;
841 DIObj.SetLineNo (LineNo);
842 *InsertOpcodeAddr = DIObj.GetObjBinAddr ();
843
844 //TrueOpcode
845 CIfrTrue TObj (LineNo);
846
847 // Declare Numeric qeustion for each undefined question.
848 for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
849 if (pNode->mFlag == PENDING) {
850 EFI_VARSTORE_INFO Info;
851 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
852 //
853 // Register this question, assume it is normal question, not date or time question
854 //
855 VarStr = pNode->mKey;
856 ReturnCode = lCVfrQuestionDB.RegisterQuestion (NULL, VarStr, QId);
857 if (ReturnCode != VFR_RETURN_SUCCESS) {
858 gCVfrErrorHandle.HandleError (ReturnCode, pNode->mLineNo, pNode->mKey);
859 return ReturnCode;
860 }
861
862 #ifdef VFREXP_DEBUG
863 printf ("Undefined Question name is %s and Id is 0x%x\n", VarStr, QId);
864 #endif
865 //
866 // Get Question Info, framework vfr VarName == StructName
867 //
868 ReturnCode = lCVfrVarDataTypeDB.ExtractFieldNameAndArrary (VarStr, FName, ArrayIdx);
869 if (ReturnCode != VFR_RETURN_SUCCESS) {
870 gCVfrErrorHandle.PrintMsg (pNode->mLineNo, pNode->mKey, "Error", "Var string is not the valid C variable");
871 return ReturnCode;
872 }
873 //
874 // Get VarStoreType
875 //
876 ReturnCode = lCVfrDataStorage.GetVarStoreId (FName, &Info.mVarStoreId);
877 if (ReturnCode != VFR_RETURN_SUCCESS) {
878 gCVfrErrorHandle.PrintMsg (pNode->mLineNo, FName, "Error", "Var Store Type is not defined");
879 return ReturnCode;
880 }
881 VarStoreType = lCVfrDataStorage.GetVarStoreType (Info.mVarStoreId);
882
883 if (*VarStr == '\0' && ArrayIdx != INVALID_ARRAY_INDEX) {
884 ReturnCode = lCVfrDataStorage.GetNameVarStoreInfo (&Info, ArrayIdx);
885 } else {
886 if (VarStoreType == EFI_VFR_VARSTORE_EFI) {
887 ReturnCode = lCVfrDataStorage.GetEfiVarStoreInfo (&Info);
888 } else if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_BUFFER_BITS) {
889 VarStr = pNode->mKey;
890 //convert VarStr with store name to VarStr with structure name
891 ReturnCode = lCVfrDataStorage.GetBufferVarStoreDataTypeName (Info.mVarStoreId, &SName);
892 if (ReturnCode == VFR_RETURN_SUCCESS) {
893 NewStr = new CHAR8[strlen (VarStr) + strlen (SName) + 1];
894 NewStr[0] = '\0';
895 strcpy (NewStr, SName);
896 strcat (NewStr, VarStr + strlen (FName));
897 ReturnCode = lCVfrVarDataTypeDB.GetDataFieldInfo (NewStr, Info.mInfo.mVarOffset, Info.mVarType, Info.mVarTotalSize, Info.mIsBitVar);
898 delete[] NewStr;
899 }
900 } else {
901 ReturnCode = VFR_RETURN_UNSUPPORTED;
902 }
903 }
904 if (ReturnCode != VFR_RETURN_SUCCESS) {
905 gCVfrErrorHandle.HandleError (ReturnCode, pNode->mLineNo, pNode->mKey);
906 return ReturnCode;
907 }
908 //
909 // If the storage is bit fields, create Guid opcode to wrap the numeric opcode.
910 //
911 if (Info.mIsBitVar) {
912 GuidObj = new CIfrGuid(0);
913 GuidObj->SetGuid (&gEdkiiIfrBitVarGuid);
914 GuidObj->SetLineNo(LineNo);
915 }
916
917 CIfrNumeric CNObj;
918 CNObj.SetLineNo (LineNo);
919 CNObj.SetPrompt (0x0);
920 CNObj.SetHelp (0x0);
921 CNObj.SetQuestionId (QId);
922 CNObj.SetVarStoreInfo (&Info);
923
924 //
925 // Set Min/Max/Step Data and flags for the question with bit fields.Min/Max/Step Data are saved as UINT32 type for bit question.
926 //
927 if (Info.mIsBitVar) {
928 MaxValue = (1 << Info.mVarTotalSize) -1;
929 CNObj.SetMinMaxStepData ((UINT32) 0, MaxValue, (UINT32) 0);
930 ShrinkSize = 12;
931 LFlags = (EDKII_IFR_NUMERIC_SIZE_BIT & Info.mVarTotalSize);
932 CNObj.SetFlagsForBitField (0, LFlags);
933 } else {
934 //
935 // Numeric doesn't support BOOLEAN data type.
936 // BOOLEAN type has the same data size to UINT8.
937 //
938 if (Info.mVarType == EFI_IFR_TYPE_BOOLEAN) {
939 Info.mVarType = EFI_IFR_TYPE_NUM_SIZE_8;
940 }
941 CNObj.SetFlags (0, Info.mVarType);
942 //
943 // Use maximum value not to limit the vaild value for the undefined question.
944 //
945 switch (Info.mVarType) {
946 case EFI_IFR_TYPE_NUM_SIZE_64:
947 CNObj.SetMinMaxStepData ((UINT64) 0, (UINT64) -1 , (UINT64) 0);
948 ShrinkSize = 0;
949 break;
950 case EFI_IFR_TYPE_NUM_SIZE_32:
951 CNObj.SetMinMaxStepData ((UINT32) 0, (UINT32) -1 , (UINT32) 0);
952 ShrinkSize = 12;
953 break;
954 case EFI_IFR_TYPE_NUM_SIZE_16:
955 CNObj.SetMinMaxStepData ((UINT16) 0, (UINT16) -1 , (UINT16) 0);
956 ShrinkSize = 18;
957 break;
958 case EFI_IFR_TYPE_NUM_SIZE_8:
959 CNObj.SetMinMaxStepData ((UINT8) 0, (UINT8) -1 , (UINT8) 0);
960 ShrinkSize = 21;
961 break;
962 default:
963 break;
964 }
965 }
966 CNObj.ShrinkBinSize (ShrinkSize);
967
968 //
969 // For undefined Efi VarStore type question
970 // Append the extended guided opcode to contain VarName
971 //
972 if (VarStoreType == EFI_VFR_VARSTORE_EFI || VfrCompatibleMode) {
973 CIfrVarEqName CVNObj (QId, Info.mInfo.mVarName);
974 CVNObj.SetLineNo (LineNo);
975 }
976
977 //
978 // End for Numeric
979 //
980 CIfrEnd CEObj;
981 CEObj.SetLineNo (LineNo);
982 //
983 // End for Guided opcode
984 //
985 if (GuidObj != NULL) {
986 CIfrEnd CEObjGuid;
987 CEObjGuid.SetLineNo (LineNo);
988 GuidObj->SetScope(1);
989 delete GuidObj;
990 GuidObj = NULL;
991 }
992 }
993 }
994
995 //
996 // End for DisableIf
997 //
998 CIfrEnd SEObj;
999 SEObj.SetLineNo (LineNo);
1000
1001 return VFR_RETURN_SUCCESS;
1002 }
1003
1004 CFormPkg gCFormPkg;
1005
1006 SIfrRecord::SIfrRecord (
1007 VOID
1008 )
1009 {
1010 mIfrBinBuf = NULL;
1011 mBinBufLen = 0;
1012 mLineNo = 0xFFFFFFFF;
1013 mOffset = 0xFFFFFFFF;
1014 mNext = NULL;
1015 }
1016
1017 SIfrRecord::~SIfrRecord (
1018 VOID
1019 )
1020 {
1021 if (mIfrBinBuf != NULL) {
1022 //delete mIfrBinBuf;
1023 mIfrBinBuf = NULL;
1024 }
1025 mLineNo = 0xFFFFFFFF;
1026 mOffset = 0xFFFFFFFF;
1027 mBinBufLen = 0;
1028 mNext = NULL;
1029 }
1030
1031 CIfrRecordInfoDB::CIfrRecordInfoDB (
1032 VOID
1033 )
1034 {
1035 mSwitch = TRUE;
1036 mRecordCount = EFI_IFR_RECORDINFO_IDX_START;
1037 mIfrRecordListHead = NULL;
1038 mIfrRecordListTail = NULL;
1039 mAllDefaultTypeCount = 0;
1040 for (UINT8 i = 0; i < EFI_HII_MAX_SUPPORT_DEFAULT_TYPE; i++) {
1041 mAllDefaultIdArray[i] = 0xffff;
1042 }
1043 }
1044
1045 CIfrRecordInfoDB::~CIfrRecordInfoDB (
1046 VOID
1047 )
1048 {
1049 SIfrRecord *pNode;
1050
1051 while (mIfrRecordListHead != NULL) {
1052 pNode = mIfrRecordListHead;
1053 mIfrRecordListHead = mIfrRecordListHead->mNext;
1054 delete pNode;
1055 }
1056 }
1057
1058 SIfrRecord *
1059 CIfrRecordInfoDB::GetRecordInfoFromIdx (
1060 IN UINT32 RecordIdx
1061 )
1062 {
1063 UINT32 Idx;
1064 SIfrRecord *pNode = NULL;
1065
1066 if (RecordIdx == EFI_IFR_RECORDINFO_IDX_INVALUD) {
1067 return NULL;
1068 }
1069
1070 for (Idx = (EFI_IFR_RECORDINFO_IDX_START + 1), pNode = mIfrRecordListHead;
1071 (Idx != RecordIdx) && (pNode != NULL);
1072 Idx++, pNode = pNode->mNext)
1073 ;
1074
1075 return pNode;
1076 }
1077
1078 UINT32
1079 CIfrRecordInfoDB::IfrRecordRegister (
1080 IN UINT32 LineNo,
1081 IN CHAR8 *IfrBinBuf,
1082 IN UINT8 BinBufLen,
1083 IN UINT32 Offset
1084 )
1085 {
1086 SIfrRecord *pNew;
1087
1088 if (mSwitch == FALSE) {
1089 return EFI_IFR_RECORDINFO_IDX_INVALUD;
1090 }
1091
1092 if ((pNew = new SIfrRecord) == NULL) {
1093 return EFI_IFR_RECORDINFO_IDX_INVALUD;
1094 }
1095
1096 if (mIfrRecordListHead == NULL) {
1097 mIfrRecordListHead = pNew;
1098 mIfrRecordListTail = pNew;
1099 } else {
1100 mIfrRecordListTail->mNext = pNew;
1101 mIfrRecordListTail = pNew;
1102 }
1103 mRecordCount++;
1104
1105 return mRecordCount;
1106 }
1107
1108 VOID
1109 CIfrRecordInfoDB::IfrRecordInfoUpdate (
1110 IN UINT32 RecordIdx,
1111 IN UINT32 LineNo,
1112 IN CHAR8 *BinBuf,
1113 IN UINT8 BinBufLen,
1114 IN UINT32 Offset
1115 )
1116 {
1117 SIfrRecord *pNode;
1118 SIfrRecord *Prev;
1119
1120 if ((pNode = GetRecordInfoFromIdx (RecordIdx)) == NULL) {
1121 return;
1122 }
1123
1124 if (LineNo == 0) {
1125 //
1126 // Line number is not specified explicitly, try to use line number of previous opcode
1127 //
1128 Prev = GetRecordInfoFromIdx (RecordIdx - 1);
1129 if (Prev != NULL) {
1130 LineNo = Prev->mLineNo;
1131 }
1132 }
1133
1134 pNode->mLineNo = LineNo;
1135 pNode->mOffset = Offset;
1136 pNode->mBinBufLen = BinBufLen;
1137 pNode->mIfrBinBuf = BinBuf;
1138
1139 }
1140
1141 VOID
1142 CIfrRecordInfoDB::IfrRecordOutput (
1143 OUT PACKAGE_DATA &TBuffer
1144 )
1145 {
1146 CHAR8 *Temp;
1147 SIfrRecord *pNode;
1148
1149 if (TBuffer.Buffer != NULL) {
1150 delete TBuffer.Buffer;
1151 }
1152
1153 TBuffer.Size = 0;
1154 TBuffer.Buffer = NULL;
1155
1156
1157 if (mSwitch == FALSE) {
1158 return;
1159 }
1160
1161 for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1162 TBuffer.Size += pNode->mBinBufLen;
1163 }
1164
1165 if (TBuffer.Size != 0) {
1166 TBuffer.Buffer = new CHAR8[TBuffer.Size];
1167 } else {
1168 return;
1169 }
1170
1171 Temp = TBuffer.Buffer;
1172
1173 for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1174 if (pNode->mIfrBinBuf != NULL) {
1175 memcpy (Temp, pNode->mIfrBinBuf, pNode->mBinBufLen);
1176 Temp += pNode->mBinBufLen;
1177 }
1178 }
1179
1180 return;
1181 }
1182
1183 VOID
1184 CIfrRecordInfoDB::IfrRecordOutput (
1185 IN FILE *File,
1186 IN UINT32 LineNo
1187 )
1188 {
1189 SIfrRecord *pNode;
1190 UINT8 Index;
1191 UINT32 TotalSize;
1192
1193 if (mSwitch == FALSE) {
1194 return;
1195 }
1196
1197 if (File == NULL) {
1198 return;
1199 }
1200
1201 TotalSize = 0;
1202
1203 for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1204 if (pNode->mLineNo == LineNo || LineNo == 0) {
1205 fprintf (File, ">%08X: ", pNode->mOffset);
1206 TotalSize += pNode->mBinBufLen;
1207 if (pNode->mIfrBinBuf != NULL) {
1208 for (Index = 0; Index < pNode->mBinBufLen; Index++) {
1209 fprintf (File, "%02X ", (UINT8)(pNode->mIfrBinBuf[Index]));
1210 }
1211 }
1212 fprintf (File, "\n");
1213 }
1214 }
1215
1216 if (LineNo == 0) {
1217 fprintf (File, "\nTotal Size of all record is 0x%08X\n", TotalSize);
1218 }
1219 }
1220
1221 //
1222 // for framework vfr file
1223 // adjust opcode sequence for uefi IFR format
1224 // adjust inconsistent and varstore into the right position.
1225 //
1226 BOOLEAN
1227 CIfrRecordInfoDB::CheckQuestionOpCode (
1228 IN UINT8 OpCode
1229 )
1230 {
1231 switch (OpCode) {
1232 case EFI_IFR_CHECKBOX_OP:
1233 case EFI_IFR_NUMERIC_OP:
1234 case EFI_IFR_PASSWORD_OP:
1235 case EFI_IFR_ONE_OF_OP:
1236 case EFI_IFR_ACTION_OP:
1237 case EFI_IFR_STRING_OP:
1238 case EFI_IFR_DATE_OP:
1239 case EFI_IFR_TIME_OP:
1240 case EFI_IFR_ORDERED_LIST_OP:
1241 case EFI_IFR_REF_OP:
1242 return TRUE;
1243 default:
1244 return FALSE;
1245 }
1246 }
1247
1248 BOOLEAN
1249 CIfrRecordInfoDB::CheckIdOpCode (
1250 IN UINT8 OpCode
1251 )
1252 {
1253 switch (OpCode) {
1254 case EFI_IFR_EQ_ID_VAL_OP:
1255 case EFI_IFR_EQ_ID_ID_OP:
1256 case EFI_IFR_EQ_ID_VAL_LIST_OP:
1257 case EFI_IFR_QUESTION_REF1_OP:
1258 return TRUE;
1259 default:
1260 return FALSE;
1261 }
1262 }
1263
1264 EFI_QUESTION_ID
1265 CIfrRecordInfoDB::GetOpcodeQuestionId (
1266 IN EFI_IFR_OP_HEADER *OpHead
1267 )
1268 {
1269 EFI_IFR_QUESTION_HEADER *QuestionHead;
1270
1271 QuestionHead = (EFI_IFR_QUESTION_HEADER *) (OpHead + 1);
1272
1273 return QuestionHead->QuestionId;
1274 }
1275
1276 SIfrRecord *
1277 CIfrRecordInfoDB::GetRecordInfoFromOffset (
1278 IN UINT32 Offset
1279 )
1280 {
1281 SIfrRecord *pNode = NULL;
1282
1283 for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1284 if (pNode->mOffset == Offset) {
1285 return pNode;
1286 }
1287 }
1288
1289 return pNode;
1290 }
1291
1292 /**
1293 Add just the op code position.
1294
1295 Case1 (CreateOpcodeAfterParsingVfr == FALSE): The dynamic opcodes were created before the formset opcode,
1296 so pDynamicOpcodeNodes is before mIfrRecordListTail.
1297
1298 From
1299
1300 |mIfrRecordListHead + ...+ pAdjustNode + pDynamicOpcodeNodes + mIfrRecordListTail|
1301
1302 To
1303
1304 |mIfrRecordListHead + ...+ pDynamicOpcodeNodes + pAdjustNode + mIfrRecordListTail|
1305
1306 Case2 (CreateOpcodeAfterParsingVfr == TRUE): The dynamic opcodes were created after paring the vfr file,
1307 so new records are appennded to the end of OriginalIfrRecordListTail.
1308
1309 From
1310
1311 |mIfrRecordListHead + ...+ pAdjustNode + ... + OriginalIfrRecordListTail + pDynamicOpcodeNodes|
1312
1313 To
1314
1315 |mIfrRecordListHead + ...+ pDynamicOpcodeNodes + pAdjustNode + ... + OriginalIfrRecordListTail|
1316
1317
1318 @param CreateOpcodeAfterParsingVfr Whether create the dynamic opcode after parsing the VFR file.
1319
1320 **/
1321 BOOLEAN
1322 CIfrRecordInfoDB::IfrAdjustDynamicOpcodeInRecords (
1323 IN BOOLEAN CreateOpcodeAfterParsingVfr
1324 )
1325 {
1326 UINT32 OpcodeOffset;
1327 SIfrRecord *pNode, *pPreNode;
1328 SIfrRecord *pAdjustNode, *pNodeBeforeAdjust;
1329 SIfrRecord *pNodeBeforeDynamic;
1330
1331 pPreNode = NULL;
1332 pAdjustNode = NULL;
1333 pNodeBeforeDynamic = NULL;
1334 OpcodeOffset = 0;
1335
1336 //
1337 // Base on the gAdjustOpcodeOffset and gAdjustOpcodeLen to find the pAdjustNod, the node before pAdjustNode,
1338 // and the node before pDynamicOpcodeNode.
1339 //
1340 for (pNode = mIfrRecordListHead; pNode!= NULL; pNode = pNode->mNext) {
1341 if (OpcodeOffset == gAdjustOpcodeOffset) {
1342 pAdjustNode = pNode;
1343 pNodeBeforeAdjust = pPreNode;
1344 } else if (OpcodeOffset == gAdjustOpcodeOffset + gAdjustOpcodeLen) {
1345 pNodeBeforeDynamic = pPreNode;
1346 }
1347 if (pNode->mNext != NULL) {
1348 pPreNode = pNode;
1349 }
1350 OpcodeOffset += pNode->mBinBufLen;
1351 }
1352
1353 //
1354 // Check the nodes whether exist.
1355 //
1356 if (pNodeBeforeDynamic == NULL || pAdjustNode == NULL || pNodeBeforeAdjust == NULL) {
1357 return FALSE;
1358 }
1359
1360 //
1361 // Adjust the node. pPreNode save the Node before mIfrRecordListTail
1362 //
1363 pNodeBeforeAdjust->mNext = pNodeBeforeDynamic->mNext;
1364 if (CreateOpcodeAfterParsingVfr) {
1365 //
1366 // mIfrRecordListTail is the end of pDynamicNode (Case2).
1367 //
1368 mIfrRecordListTail->mNext = pAdjustNode;
1369 mIfrRecordListTail = pNodeBeforeDynamic;
1370 mIfrRecordListTail->mNext = NULL;
1371 } else {
1372 //
1373 //pPreNode is the end of pDynamicNode(Case1).
1374 //
1375 pPreNode->mNext = pAdjustNode;
1376 pNodeBeforeDynamic->mNext = mIfrRecordListTail;
1377 }
1378
1379 return TRUE;
1380 }
1381
1382 /**
1383 Update the record info(the position in the record list, offset and mIfrBinBuf) for new created record.
1384
1385 @param CreateOpcodeAfterParsingVfr Whether create the dynamic opcode after parsing the VFR file.
1386
1387 **/
1388 VOID
1389 CIfrRecordInfoDB::IfrUpdateRecordInfoForDynamicOpcode (
1390 IN BOOLEAN CreateOpcodeAfterParsingVfr
1391 )
1392 {
1393 SIfrRecord *pRecord;
1394
1395 //
1396 // Base on the original offset info to update the record list.
1397 //
1398 if (!IfrAdjustDynamicOpcodeInRecords(CreateOpcodeAfterParsingVfr)) {
1399 gCVfrErrorHandle.PrintMsg (0, (CHAR8 *)"Error", (CHAR8 *)"Can not find the adjust offset in the record.");
1400 }
1401
1402 //
1403 // Base on the opcode binary length to recalculate the offset for each opcode.
1404 //
1405 IfrAdjustOffsetForRecord();
1406
1407 //
1408 // Base on the offset to find the binary address.
1409 //
1410 pRecord = GetRecordInfoFromOffset(gAdjustOpcodeOffset);
1411 while (pRecord != NULL) {
1412 pRecord->mIfrBinBuf = gCFormPkg.GetBufAddrBaseOnOffset(pRecord->mOffset);
1413 pRecord = pRecord->mNext;
1414 }
1415 }
1416
1417
1418 VOID
1419 CIfrRecordInfoDB::IfrAdjustOffsetForRecord (
1420 VOID
1421 )
1422 {
1423 UINT32 OpcodeOffset;
1424 SIfrRecord *pNode;
1425
1426 OpcodeOffset = 0;
1427 for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) {
1428 pNode->mOffset = OpcodeOffset;
1429 OpcodeOffset += pNode->mBinBufLen;
1430 }
1431 }
1432
1433 EFI_VFR_RETURN_CODE
1434 CIfrRecordInfoDB::IfrRecordAdjust (
1435 VOID
1436 )
1437 {
1438 SIfrRecord *pNode, *preNode;
1439 SIfrRecord *uNode, *tNode;
1440 EFI_IFR_OP_HEADER *OpHead, *tOpHead;
1441 EFI_QUESTION_ID QuestionId;
1442 UINT32 StackCount;
1443 UINT32 QuestionScope;
1444 CHAR8 ErrorMsg[MAX_STRING_LEN] = {0, };
1445 EFI_VFR_RETURN_CODE Status;
1446
1447 //
1448 // Init local variable
1449 //
1450 Status = VFR_RETURN_SUCCESS;
1451 pNode = mIfrRecordListHead;
1452 preNode = pNode;
1453 QuestionScope = 0;
1454 while (pNode != NULL) {
1455 OpHead = (EFI_IFR_OP_HEADER *) pNode->mIfrBinBuf;
1456
1457 //
1458 // make sure the inconsistent opcode in question scope
1459 //
1460 if (QuestionScope > 0) {
1461 QuestionScope += OpHead->Scope;
1462 if (OpHead->OpCode == EFI_IFR_END_OP) {
1463 QuestionScope --;
1464 }
1465 }
1466
1467 if (CheckQuestionOpCode (OpHead->OpCode)) {
1468 QuestionScope = 1;
1469 }
1470 //
1471 // for the inconsistent opcode not in question scope, adjust it
1472 //
1473 if (OpHead->OpCode == EFI_IFR_INCONSISTENT_IF_OP && QuestionScope == 0) {
1474 //
1475 // for inconsistent opcode not in question scope
1476 //
1477
1478 //
1479 // Count inconsistent opcode Scope
1480 //
1481 StackCount = OpHead->Scope;
1482 QuestionId = EFI_QUESTION_ID_INVALID;
1483 tNode = pNode;
1484 while (tNode != NULL && StackCount > 0) {
1485 tNode = tNode->mNext;
1486 tOpHead = (EFI_IFR_OP_HEADER *) tNode->mIfrBinBuf;
1487 //
1488 // Calculate Scope Number
1489 //
1490 StackCount += tOpHead->Scope;
1491 if (tOpHead->OpCode == EFI_IFR_END_OP) {
1492 StackCount --;
1493 }
1494 //
1495 // by IdEqual opcode to get QuestionId
1496 //
1497 if (QuestionId == EFI_QUESTION_ID_INVALID &&
1498 CheckIdOpCode (tOpHead->OpCode)) {
1499 QuestionId = *(EFI_QUESTION_ID *) (tOpHead + 1);
1500 }
1501 }
1502 if (tNode == NULL || QuestionId == EFI_QUESTION_ID_INVALID) {
1503 //
1504 // report error; not found
1505 //
1506 sprintf (ErrorMsg, "Inconsistent OpCode Record list invalid QuestionId is 0x%X", QuestionId);
1507 gCVfrErrorHandle.PrintMsg (0, NULL, "Error", ErrorMsg);
1508 Status = VFR_RETURN_MISMATCHED;
1509 break;
1510 }
1511 //
1512 // extract inconsistent opcode list
1513 // pNode is Incosistent opcode, tNode is End Opcode
1514 //
1515
1516 //
1517 // insert inconsistent opcode list into the right question scope by questionid
1518 //
1519 for (uNode = mIfrRecordListHead; uNode != NULL; uNode = uNode->mNext) {
1520 tOpHead = (EFI_IFR_OP_HEADER *) uNode->mIfrBinBuf;
1521 if (CheckQuestionOpCode (tOpHead->OpCode) &&
1522 (QuestionId == GetOpcodeQuestionId (tOpHead))) {
1523 break;
1524 }
1525 }
1526 //
1527 // insert inconsistent opcode list and check LATE_CHECK flag
1528 //
1529 if (uNode != NULL) {
1530 if ((((EFI_IFR_QUESTION_HEADER *)(tOpHead + 1))->Flags & 0x20) != 0) {
1531 //
1532 // if LATE_CHECK flag is set, change inconsistent to nosumbit
1533 //
1534 OpHead->OpCode = EFI_IFR_NO_SUBMIT_IF_OP;
1535 }
1536
1537 //
1538 // skip the default storage for Date and Time
1539 //
1540 if ((uNode->mNext != NULL) && (*uNode->mNext->mIfrBinBuf == EFI_IFR_DEFAULT_OP)) {
1541 uNode = uNode->mNext;
1542 }
1543
1544 preNode->mNext = tNode->mNext;
1545 tNode->mNext = uNode->mNext;
1546 uNode->mNext = pNode;
1547 //
1548 // reset pNode to head list, scan the whole list again.
1549 //
1550 pNode = mIfrRecordListHead;
1551 preNode = pNode;
1552 QuestionScope = 0;
1553 continue;
1554 } else {
1555 //
1556 // not found matched question id, report error
1557 //
1558 sprintf (ErrorMsg, "QuestionId required by Inconsistent OpCode is not found. QuestionId is 0x%X", QuestionId);
1559 gCVfrErrorHandle.PrintMsg (0, NULL, "Error", ErrorMsg);
1560 Status = VFR_RETURN_MISMATCHED;
1561 break;
1562 }
1563 } else if (OpHead->OpCode == EFI_IFR_VARSTORE_OP ||
1564 OpHead->OpCode == EFI_IFR_VARSTORE_EFI_OP) {
1565 //
1566 // for new added group of varstore opcode
1567 //
1568 tNode = pNode;
1569 while (tNode->mNext != NULL) {
1570 tOpHead = (EFI_IFR_OP_HEADER *) tNode->mNext->mIfrBinBuf;
1571 if (tOpHead->OpCode != EFI_IFR_VARSTORE_OP &&
1572 tOpHead->OpCode != EFI_IFR_VARSTORE_EFI_OP) {
1573 break;
1574 }
1575 tNode = tNode->mNext;
1576 }
1577
1578 if (tNode->mNext == NULL) {
1579 //
1580 // invalid IfrCode, IfrCode end by EndOpCode
1581 //
1582 gCVfrErrorHandle.PrintMsg (0, NULL, "Error", "No found End Opcode in the end");
1583 Status = VFR_RETURN_MISMATCHED;
1584 break;
1585 }
1586
1587 if (tOpHead->OpCode != EFI_IFR_END_OP) {
1588 //
1589 // not new added varstore, which are not needed to be adjust.
1590 //
1591 preNode = tNode;
1592 pNode = tNode->mNext;
1593 continue;
1594 } else {
1595 //
1596 // move new added varstore opcode to the position befor form opcode
1597 // varstore opcode between pNode and tNode
1598 //
1599
1600 //
1601 // search form opcode from begin
1602 //
1603 for (uNode = mIfrRecordListHead; uNode->mNext != NULL; uNode = uNode->mNext) {
1604 tOpHead = (EFI_IFR_OP_HEADER *) uNode->mNext->mIfrBinBuf;
1605 if (tOpHead->OpCode == EFI_IFR_FORM_OP) {
1606 break;
1607 }
1608 }
1609 //
1610 // Insert varstore opcode beform form opcode if form opcode is found
1611 //
1612 if (uNode->mNext != NULL) {
1613 preNode->mNext = tNode->mNext;
1614 tNode->mNext = uNode->mNext;
1615 uNode->mNext = pNode;
1616 //
1617 // reset pNode to head list, scan the whole list again.
1618 //
1619 pNode = mIfrRecordListHead;
1620 preNode = pNode;
1621 QuestionScope = 0;
1622 continue;
1623 } else {
1624 //
1625 // not found form, continue scan IfrRecord list
1626 //
1627 preNode = tNode;
1628 pNode = tNode->mNext;
1629 continue;
1630 }
1631 }
1632 }
1633 //
1634 // next node
1635 //
1636 preNode = pNode;
1637 pNode = pNode->mNext;
1638 }
1639
1640 //
1641 // Update Ifr Opcode Offset
1642 //
1643 if (Status == VFR_RETURN_SUCCESS) {
1644 IfrAdjustOffsetForRecord ();
1645 }
1646 return Status;
1647 }
1648
1649 /**
1650 When the Varstore of the question is EFI_VFR_VARSTORE_BUFFER and the default value is not
1651 given by expression, should save the default info for the Buffer VarStore.
1652
1653 @param DefaultId The default id.
1654 @param pQuestionNode Point to the question opcode node.
1655 @param Value The default value.
1656 **/
1657 VOID
1658 CIfrRecordInfoDB::IfrAddDefaultToBufferConfig (
1659 IN UINT16 DefaultId,
1660 IN SIfrRecord *pQuestionNode,
1661 IN EFI_IFR_TYPE_VALUE Value
1662 )
1663 {
1664 CHAR8 *VarStoreName = NULL;
1665 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
1666 EFI_GUID *VarGuid = NULL;
1667 EFI_VARSTORE_INFO VarInfo;
1668 EFI_IFR_QUESTION_HEADER *QuestionHead;
1669 EFI_IFR_OP_HEADER *pQuestionOpHead;
1670
1671 pQuestionOpHead = (EFI_IFR_OP_HEADER *) pQuestionNode->mIfrBinBuf;
1672 QuestionHead = (EFI_IFR_QUESTION_HEADER *) (pQuestionOpHead + 1);
1673
1674 //
1675 // Get the Var Store name and type.
1676 //
1677 gCVfrDataStorage.GetVarStoreName (QuestionHead->VarStoreId, &VarStoreName);
1678 VarGuid= gCVfrDataStorage.GetVarStoreGuid (QuestionHead->VarStoreId);
1679 VarStoreType = gCVfrDataStorage.GetVarStoreType (QuestionHead->VarStoreId);
1680
1681 //
1682 // Only for Buffer storage need to save the default info in the storage.
1683 // Other type storage, just return.
1684 //
1685 if (VarStoreType != EFI_VFR_VARSTORE_BUFFER) {
1686 return;
1687 } else {
1688 VarInfo.mInfo.mVarOffset = QuestionHead->VarStoreInfo.VarOffset;
1689 VarInfo.mVarStoreId = QuestionHead->VarStoreId;
1690 }
1691
1692 //
1693 // Get the buffer storage info about this question.
1694 //
1695 gCVfrDataStorage.GetBufferVarStoreFieldInfo (&VarInfo);
1696
1697 //
1698 // Add action.
1699 //
1700 gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
1701 DefaultId,
1702 VarInfo,
1703 VarStoreName,
1704 VarGuid,
1705 VarInfo.mVarType,
1706 Value
1707 );
1708 }
1709
1710 /**
1711 Record the number and default id of all defaultstore opcode.
1712
1713 **/
1714 VOID
1715 CIfrRecordInfoDB::IfrGetDefaultStoreInfo (
1716 VOID
1717 )
1718 {
1719 SIfrRecord *pNode;
1720 EFI_IFR_OP_HEADER *pOpHead;
1721 EFI_IFR_DEFAULTSTORE *DefaultStore;
1722
1723 pNode = mIfrRecordListHead;
1724 mAllDefaultTypeCount = 0;
1725
1726 while (pNode != NULL) {
1727 pOpHead = (EFI_IFR_OP_HEADER *) pNode->mIfrBinBuf;
1728
1729 if (pOpHead->OpCode == EFI_IFR_DEFAULTSTORE_OP){
1730 DefaultStore = (EFI_IFR_DEFAULTSTORE *) pNode->mIfrBinBuf;
1731 mAllDefaultIdArray[mAllDefaultTypeCount++] = DefaultStore->DefaultId;
1732 }
1733 pNode = pNode->mNext;
1734 }
1735 }
1736
1737 /**
1738 Create new default opcode record.
1739
1740 @param Size The new default opcode size.
1741 @param DefaultId The new default id.
1742 @param Type The new default type.
1743 @param LineNo The line number of the new record.
1744 @param Value The new default value.
1745
1746 **/
1747 VOID
1748 CIfrRecordInfoDB::IfrCreateDefaultRecord(
1749 IN UINT8 Size,
1750 IN UINT16 DefaultId,
1751 IN UINT8 Type,
1752 IN UINT32 LineNo,
1753 IN EFI_IFR_TYPE_VALUE Value
1754 )
1755 {
1756 CIfrDefault *DObj;
1757 CIfrDefault2 *DObj2;
1758
1759 DObj = NULL;
1760 DObj2 = NULL;
1761
1762 if (Type == EFI_IFR_TYPE_OTHER) {
1763 DObj2 = new CIfrDefault2 (Size);
1764 DObj2->SetDefaultId(DefaultId);
1765 DObj2->SetType(Type);
1766 DObj2->SetLineNo(LineNo);
1767 DObj2->SetScope (1);
1768 delete DObj2;
1769 } else {
1770 DObj = new CIfrDefault (Size);
1771 DObj->SetDefaultId(DefaultId);
1772 DObj->SetType(Type);
1773 DObj->SetLineNo(LineNo);
1774 DObj->SetValue (Value);
1775 delete DObj;
1776 }
1777 }
1778
1779 /**
1780 Create new default opcode for question base on the QuestionDefaultInfo.
1781
1782 @param pQuestionNode Point to the question opcode Node.
1783 @param QuestionDefaultInfo Point to the QuestionDefaultInfo for current question.
1784
1785 **/
1786 VOID
1787 CIfrRecordInfoDB::IfrCreateDefaultForQuestion (
1788 IN SIfrRecord *pQuestionNode,
1789 IN QuestionDefaultRecord *QuestionDefaultInfo
1790 )
1791 {
1792 EFI_IFR_OP_HEADER *pOpHead;
1793 EFI_IFR_DEFAULT *Default;
1794 SIfrRecord *pSNode;
1795 SIfrRecord *pENode;
1796 SIfrRecord *pDefaultNode;
1797 CIfrObj *Obj;
1798 CHAR8 *ObjBinBuf;
1799 UINT8 ScopeCount;
1800 UINT8 OpcodeNumber;
1801 UINT8 OpcodeCount;
1802 UINT8 DefaultSize;
1803 EFI_IFR_ONE_OF_OPTION *DefaultOptionOpcode;
1804 EFI_IFR_TYPE_VALUE CheckBoxDefaultValue;
1805
1806 CheckBoxDefaultValue.b = 1;
1807 pOpHead = (EFI_IFR_OP_HEADER *) pQuestionNode->mIfrBinBuf;
1808 ScopeCount = 0;
1809 OpcodeCount = 0;
1810 Obj = NULL;
1811
1812 //
1813 // Record the offset of node which need to be adjust, will move the new created default opcode to this offset.
1814 //
1815 gAdjustOpcodeOffset = pQuestionNode->mNext->mOffset;
1816 //
1817 // Case 1:
1818 // For oneof, the default with smallest default id is given by the option flag.
1819 // So create the missing defaults base on the oneof option value(mDefaultValueRecord).
1820 //
1821 if (pOpHead->OpCode == EFI_IFR_ONE_OF_OP && !QuestionDefaultInfo->mIsDefaultOpcode) {
1822 DefaultOptionOpcode = (EFI_IFR_ONE_OF_OPTION *)QuestionDefaultInfo->mDefaultValueRecord->mIfrBinBuf;
1823 DefaultSize = QuestionDefaultInfo->mDefaultValueRecord->mBinBufLen - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value);
1824 DefaultSize += OFFSET_OF (EFI_IFR_DEFAULT, Value);
1825 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
1826 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
1827 IfrCreateDefaultRecord (DefaultSize, mAllDefaultIdArray[i], DefaultOptionOpcode->Type, pQuestionNode->mLineNo, DefaultOptionOpcode->Value);
1828 //
1829 // Save the new created default in the buffer storage.
1830 //
1831 IfrAddDefaultToBufferConfig (mAllDefaultIdArray[i], pQuestionNode, DefaultOptionOpcode->Value);
1832 }
1833 }
1834 return;
1835 }
1836
1837 //
1838 // Case2:
1839 // For checkbox, the default with smallest default id is given by the question flag.
1840 // And create the missing defaults with true value.
1841 //
1842 if (pOpHead-> OpCode == EFI_IFR_CHECKBOX_OP && !QuestionDefaultInfo->mIsDefaultOpcode) {
1843 DefaultSize = OFFSET_OF (EFI_IFR_DEFAULT, Value) + sizeof (BOOLEAN);
1844 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
1845 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
1846 IfrCreateDefaultRecord (DefaultSize, mAllDefaultIdArray[i], EFI_IFR_TYPE_BOOLEAN, pQuestionNode->mLineNo, CheckBoxDefaultValue);
1847 //
1848 // Save the new created default.
1849 //
1850 IfrAddDefaultToBufferConfig (mAllDefaultIdArray[i], pQuestionNode, CheckBoxDefaultValue);
1851 }
1852 }
1853 return;
1854 }
1855
1856 //
1857 // Case3:
1858 // The default with smallest default id is given by the default opcode.
1859 // So create the missing defaults base on the value in the default opcode.
1860 //
1861
1862 //
1863 // pDefaultNode point to the mDefaultValueRecord in QuestionDefaultInfo.
1864 //
1865 pDefaultNode = QuestionDefaultInfo->mDefaultValueRecord;
1866 Default = (EFI_IFR_DEFAULT *)pDefaultNode->mIfrBinBuf;
1867 //
1868 // Record the offset of node which need to be adjust, will move the new created default opcode to this offset.
1869 //
1870 gAdjustOpcodeOffset = pDefaultNode->mNext->mOffset;
1871
1872 if (Default->Type == EFI_IFR_TYPE_OTHER) {
1873 //
1874 // EFI_IFR_DEFAULT_2 opcode.
1875 //
1876 // Point to the first expression opcode.
1877 //
1878 pSNode = pDefaultNode->mNext;
1879 pENode = NULL;
1880 ScopeCount++;
1881 //
1882 // Get opcode number behind the EFI_IFR_DEFAULT_2 until reach its END opcode (including the END opcode of EFI_IFR_DEFAULT_2)
1883 //
1884 while (pSNode != NULL && pSNode->mNext != NULL && ScopeCount != 0) {
1885 pOpHead = (EFI_IFR_OP_HEADER *) pSNode->mIfrBinBuf;
1886 if (pOpHead->Scope == 1) {
1887 ScopeCount++;
1888 }
1889 if (pOpHead->OpCode == EFI_IFR_END_OP) {
1890 ScopeCount--;
1891 }
1892 pENode = pSNode;
1893 pSNode = pSNode->mNext;
1894 OpcodeCount++;
1895 }
1896
1897 assert (pSNode);
1898 assert (pENode);
1899
1900 //
1901 // Record the offset of node which need to be adjust, will move the new created default opcode to this offset.
1902 //
1903 gAdjustOpcodeOffset = pSNode->mOffset;
1904 //
1905 // Create new default opcode node for missing default.
1906 //
1907 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
1908 OpcodeNumber = OpcodeCount;
1909 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
1910 IfrCreateDefaultRecord (Default->Header.Length, mAllDefaultIdArray[i], Default->Type, pENode->mLineNo, Default->Value);
1911 //
1912 // Point to the first expression opcode node.
1913 //
1914 pSNode = pDefaultNode->mNext;
1915 //
1916 // Create the expression opcode and end opcode for the new created EFI_IFR_DEFAULT_2 opcode.
1917 //
1918 while (pSNode != NULL && pSNode->mNext != NULL && OpcodeNumber-- != 0) {
1919 pOpHead = (EFI_IFR_OP_HEADER *) pSNode->mIfrBinBuf;
1920 Obj = new CIfrObj (pOpHead->OpCode, NULL, pSNode->mBinBufLen, FALSE);
1921 assert (Obj != NULL);
1922 Obj->SetLineNo (pSNode->mLineNo);
1923 ObjBinBuf = Obj->GetObjBinAddr();
1924 memcpy (ObjBinBuf, pSNode->mIfrBinBuf, (UINTN)pSNode->mBinBufLen);
1925 delete Obj;
1926 pSNode = pSNode->mNext;
1927 }
1928 }
1929 }
1930 } else {
1931 //
1932 // EFI_IFR_DEFAULT opcode.
1933 //
1934 // Create new default opcode node for missing default.
1935 //
1936 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
1937 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
1938 IfrCreateDefaultRecord (Default->Header.Length, mAllDefaultIdArray[i], Default->Type, pDefaultNode->mLineNo, Default->Value);
1939 //
1940 // Save the new created default in the buffer storage..
1941 //
1942 IfrAddDefaultToBufferConfig (mAllDefaultIdArray[i], pQuestionNode, Default->Value);
1943 }
1944 }
1945 }
1946 }
1947
1948 /**
1949 Parse the default information in a question, get the QuestionDefaultInfo.
1950
1951 @param pQuestionNode Point to the question record Node.
1952 @param QuestionDefaultInfo On return, point to the QuestionDefaultInfo.
1953 **/
1954 VOID
1955 CIfrRecordInfoDB::IfrParseDefaulInfoInQuestion(
1956 IN SIfrRecord *pQuestionNode,
1957 OUT QuestionDefaultRecord *QuestionDefaultInfo
1958 )
1959 {
1960 SIfrRecord *pSNode;
1961 EFI_IFR_ONE_OF_OPTION *OneofOptionOpcode;
1962 EFI_IFR_OP_HEADER *pSOpHead;
1963 EFI_IFR_CHECKBOX *CheckBoxOpcode;
1964 EFI_IFR_DEFAULT *DefaultOpcode;
1965 BOOLEAN IsOneOfOpcode;
1966 UINT16 SmallestDefaultId;
1967 UINT8 ScopeCount;
1968
1969 SmallestDefaultId = 0xffff;
1970 IsOneOfOpcode = FALSE;
1971 ScopeCount = 0;
1972 pSNode = pQuestionNode;
1973
1974 //
1975 // Parse all the opcodes in the Question.
1976 //
1977 while (pSNode != NULL) {
1978 pSOpHead = (EFI_IFR_OP_HEADER *) pSNode->mIfrBinBuf;
1979 //
1980 // For a question, its scope bit must be set, the scope exists until it reaches a corresponding EFI_IFR_END_OP.
1981 // Scopes may be nested within other scopes.
1982 // When finishing parsing a question, the scope count must be zero.
1983 //
1984 if (pSOpHead->Scope == 1) {
1985 ScopeCount++;
1986 }
1987 if (pSOpHead->OpCode == EFI_IFR_END_OP) {
1988 ScopeCount--;
1989 }
1990 //
1991 // Check whether finishing parsing a question.
1992 //
1993 if (ScopeCount == 0) {
1994 break;
1995 }
1996
1997 //
1998 // Record the default information in the question.
1999 //
2000 switch (pSOpHead->OpCode) {
2001 case EFI_IFR_ONE_OF_OP:
2002 IsOneOfOpcode = TRUE;
2003 break;
2004 case EFI_IFR_CHECKBOX_OP:
2005 //
2006 // The default info of check box may be given by flag.
2007 // So need to check the flag of check box.
2008 //
2009 CheckBoxOpcode = (EFI_IFR_CHECKBOX *)pSNode->mIfrBinBuf;
2010 if ((CheckBoxOpcode->Flags & EFI_IFR_CHECKBOX_DEFAULT) != 0) {
2011 //
2012 // Check whether need to update the smallest default id.
2013 //
2014 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_STANDARD) {
2015 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
2016 }
2017 //
2018 // Update the QuestionDefaultInfo.
2019 //
2020 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
2021 if (mAllDefaultIdArray[i] == EFI_HII_DEFAULT_CLASS_STANDARD) {
2022 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
2023 QuestionDefaultInfo->mDefaultNumber ++;
2024 QuestionDefaultInfo->mIsDefaultIdExist[i] = TRUE;
2025 }
2026 break;
2027 }
2028 }
2029 }
2030 if ((CheckBoxOpcode->Flags & EFI_IFR_CHECKBOX_DEFAULT_MFG) != 0) {
2031 //
2032 // Check whether need to update the smallest default id.
2033 //
2034 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
2035 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING;
2036 }
2037 //
2038 // Update the QuestionDefaultInfo.
2039 //
2040 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
2041 if (mAllDefaultIdArray[i] == EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
2042 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
2043 QuestionDefaultInfo->mDefaultNumber ++;
2044 QuestionDefaultInfo->mIsDefaultIdExist[i] = TRUE;
2045 }
2046 break;
2047 }
2048 }
2049 }
2050 break;
2051 case EFI_IFR_ONE_OF_OPTION_OP:
2052 if (!IsOneOfOpcode) {
2053 //
2054 // Only check the option in oneof.
2055 //
2056 break;
2057 }
2058 OneofOptionOpcode = (EFI_IFR_ONE_OF_OPTION *)pSNode->mIfrBinBuf;
2059 if ((OneofOptionOpcode->Flags & EFI_IFR_OPTION_DEFAULT) != 0) {
2060 //
2061 // The option is used as the standard default.
2062 // Check whether need to update the smallest default id and QuestionDefaultInfo.
2063 //
2064 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_STANDARD) {
2065 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
2066 QuestionDefaultInfo->mDefaultValueRecord = pSNode;
2067 }
2068 //
2069 // Update the IsDefaultIdExist array in QuestionDefaultInfo.
2070 //
2071 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
2072 if (mAllDefaultIdArray[i] == EFI_HII_DEFAULT_CLASS_STANDARD) {
2073 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
2074 QuestionDefaultInfo->mDefaultNumber ++;
2075 QuestionDefaultInfo->mIsDefaultIdExist[i] = TRUE;
2076 }
2077 break;
2078 }
2079 }
2080 }
2081 if ((OneofOptionOpcode->Flags & EFI_IFR_OPTION_DEFAULT_MFG) != 0) {
2082 //
2083 // This option is used as the manufacture default.
2084 // Check whether need to update the smallest default id and QuestionDefaultInfo.
2085 //
2086 if (SmallestDefaultId > EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
2087 SmallestDefaultId = EFI_HII_DEFAULT_CLASS_MANUFACTURING;
2088 QuestionDefaultInfo->mDefaultValueRecord = pSNode;
2089 }
2090 //
2091 // Update the QuestionDefaultInfo.
2092 //
2093 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++) {
2094 if (mAllDefaultIdArray[i] == EFI_HII_DEFAULT_CLASS_MANUFACTURING) {
2095 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
2096 QuestionDefaultInfo->mDefaultNumber ++;
2097 QuestionDefaultInfo->mIsDefaultIdExist[i] = TRUE;
2098 }
2099 break;
2100 }
2101 }
2102 }
2103 break;
2104 case EFI_IFR_DEFAULT_OP:
2105 DefaultOpcode = (EFI_IFR_DEFAULT *) pSNode->mIfrBinBuf;
2106 //
2107 // Check whether need to update the smallest default id and QuestionDefaultInfo.
2108 //
2109 if (SmallestDefaultId >= DefaultOpcode->DefaultId ) {
2110 SmallestDefaultId = DefaultOpcode->DefaultId;
2111 QuestionDefaultInfo->mDefaultValueRecord= pSNode;
2112 QuestionDefaultInfo->mIsDefaultOpcode= TRUE;
2113 }
2114 //
2115 // Update the QuestionDefaultInfo.
2116 //
2117 for (UINT8 i = 0; i < mAllDefaultTypeCount; i++){
2118 if (mAllDefaultIdArray[i] == ((EFI_IFR_DEFAULT *)pSNode->mIfrBinBuf)->DefaultId) {
2119 if (!QuestionDefaultInfo->mIsDefaultIdExist[i]) {
2120 QuestionDefaultInfo->mDefaultNumber ++;
2121 QuestionDefaultInfo->mIsDefaultIdExist[i] = TRUE;
2122 }
2123 break;
2124 }
2125 }
2126 break;
2127 default:
2128 break;
2129 }
2130 //
2131 // Parse next opcode in this question.
2132 //
2133 pSNode = pSNode->mNext;
2134 }
2135 }
2136
2137 /**
2138 Check or add default for question if need.
2139
2140 This function will check the default info for question.
2141 If the question has default, but the default number < defaultstore opcode number.
2142 will do following two action :
2143
2144 1. if (AutoDefault) will add default for question to support all kinds of defaults.
2145 2. if (CheckDefault) will generate an error to tell user the question misses some default value.
2146
2147 We assume that the two options can not be TRUE at same time.
2148 If they are TRUE at same time, only do the action corresponding to AutoDefault option.
2149
2150 @param AutoDefault Add default for question if needed
2151 @param CheckDefault Check the default info, if missing default, generates an error.
2152
2153 **/
2154 VOID
2155 CIfrRecordInfoDB::IfrCheckAddDefaultRecord (
2156 BOOLEAN AutoDefault,
2157 BOOLEAN CheckDefault
2158 )
2159 {
2160 SIfrRecord *pNode;
2161 SIfrRecord *pTailNode;
2162 SIfrRecord *pStartAdjustNode;
2163 EFI_IFR_OP_HEADER *pOpHead;
2164 QuestionDefaultRecord QuestionDefaultInfo;
2165 UINT8 MissingDefaultCount;
2166 CHAR8 Msg[MAX_STRING_LEN] = {0, };
2167
2168 pNode = mIfrRecordListHead;
2169
2170 //
2171 // Record the number and default id of all defaultstore opcode.
2172 //
2173 IfrGetDefaultStoreInfo ();
2174
2175 while (pNode != NULL) {
2176 pOpHead = (EFI_IFR_OP_HEADER *) pNode->mIfrBinBuf;
2177 //
2178 // Check whether is question opcode.
2179 //
2180 if (CheckQuestionOpCode (pOpHead->OpCode)) {
2181 //
2182 // Initialize some local variables here, because they vary with question.
2183 // Record the mIfrRecordListTail for each question, because may create default node for question after mIfrRecordListTail.
2184 //
2185 memset (&QuestionDefaultInfo, 0, sizeof (QuestionDefaultRecord));
2186 pTailNode = mIfrRecordListTail;
2187 //
2188 // Get the QuestionDefaultInfo for current question.
2189 //
2190 IfrParseDefaulInfoInQuestion (pNode, &QuestionDefaultInfo);
2191
2192 if (QuestionDefaultInfo.mDefaultNumber != mAllDefaultTypeCount && QuestionDefaultInfo.mDefaultNumber != 0) {
2193 if (AutoDefault) {
2194 //
2195 // Create default for question which misses default.
2196 //
2197 IfrCreateDefaultForQuestion (pNode, &QuestionDefaultInfo);
2198
2199 //
2200 // Adjust the buffer content.
2201 // pStartAdjustNode->mIfrBinBuf points to the insert position.
2202 // pTailNode->mNext->mIfrBinBuf points to the inset opcodes.
2203 //
2204 pStartAdjustNode =GetRecordInfoFromOffset (gAdjustOpcodeOffset);
2205 gCFormPkg.AdjustDynamicInsertOpcode (pStartAdjustNode->mIfrBinBuf, pTailNode->mNext->mIfrBinBuf, TRUE);
2206
2207 //
2208 // Update the record info.
2209 //
2210 IfrUpdateRecordInfoForDynamicOpcode (TRUE);
2211 } else if (CheckDefault) {
2212 //
2213 // Generate an error for question which misses default.
2214 //
2215 MissingDefaultCount = mAllDefaultTypeCount - QuestionDefaultInfo.mDefaultNumber;
2216 sprintf (Msg, "The question misses %d default, the question's opcode is %d", MissingDefaultCount, pOpHead->OpCode);
2217 gCVfrErrorHandle.PrintMsg (pNode->mLineNo, NULL, "Error", Msg);
2218 }
2219 }
2220 }
2221 //
2222 // parse next opcode.
2223 //
2224 pNode = pNode->mNext;
2225 }
2226 }
2227
2228 CIfrRecordInfoDB gCIfrRecordInfoDB;
2229
2230 VOID
2231 CIfrObj::_EMIT_PENDING_OBJ (
2232 VOID
2233 )
2234 {
2235 CHAR8 *ObjBinBuf = NULL;
2236
2237 //
2238 // do nothing
2239 //
2240 if (!mDelayEmit || !gCreateOp) {
2241 return;
2242 }
2243
2244 mPkgOffset = gCFormPkg.GetPkgLength ();
2245 //
2246 // update data buffer to package data
2247 //
2248 ObjBinBuf = gCFormPkg.IfrBinBufferGet (mObjBinLen);
2249 if (ObjBinBuf != NULL) {
2250 memmove (ObjBinBuf, mObjBinBuf, mObjBinLen);
2251 }
2252
2253 //
2254 // update bin buffer to package data buffer
2255 //
2256 if (mObjBinBuf != NULL) {
2257 delete mObjBinBuf;
2258 mObjBinBuf = ObjBinBuf;
2259 }
2260
2261 mDelayEmit = FALSE;
2262 }
2263
2264 /*
2265 * The definition of CIfrObj's member function
2266 */
2267 static struct {
2268 UINT8 mSize;
2269 UINT8 mScope;
2270 } gOpcodeSizesScopeTable[] = {
2271 { 0, 0 }, // EFI_IFR_INVALID - 0x00
2272 { sizeof (EFI_IFR_FORM), 1 }, // EFI_IFR_FORM_OP
2273 { sizeof (EFI_IFR_SUBTITLE), 1 }, // EFI_IFR_SUBTITLE_OP
2274 { sizeof (EFI_IFR_TEXT), 0 }, // EFI_IFR_TEXT_OP
2275 { sizeof (EFI_IFR_IMAGE), 0 }, // EFI_IFR_IMAGE_OP
2276 { sizeof (EFI_IFR_ONE_OF), 1 }, // EFI_IFR_ONE_OF_OP - 0x05
2277 { sizeof (EFI_IFR_CHECKBOX), 1}, // EFI_IFR_CHECKBOX_OP
2278 { sizeof (EFI_IFR_NUMERIC), 1 }, // EFI_IFR_NUMERIC_OP
2279 { sizeof (EFI_IFR_PASSWORD), 1 }, // EFI_IFR_PASSWORD_OP
2280 { sizeof (EFI_IFR_ONE_OF_OPTION), 0 }, // EFI_IFR_ONE_OF_OPTION_OP
2281 { sizeof (EFI_IFR_SUPPRESS_IF), 1 }, // EFI_IFR_SUPPRESS_IF - 0x0A
2282 { sizeof (EFI_IFR_LOCKED), 0 }, // EFI_IFR_LOCKED_OP
2283 { sizeof (EFI_IFR_ACTION), 1 }, // EFI_IFR_ACTION_OP
2284 { sizeof (EFI_IFR_RESET_BUTTON), 1 }, // EFI_IFR_RESET_BUTTON_OP
2285 { sizeof (EFI_IFR_FORM_SET), 1 }, // EFI_IFR_FORM_SET_OP -0xE
2286 { sizeof (EFI_IFR_REF), 0 }, // EFI_IFR_REF_OP
2287 { sizeof (EFI_IFR_NO_SUBMIT_IF), 1}, // EFI_IFR_NO_SUBMIT_IF_OP -0x10
2288 { sizeof (EFI_IFR_INCONSISTENT_IF), 1 }, // EFI_IFR_INCONSISTENT_IF_OP
2289 { sizeof (EFI_IFR_EQ_ID_VAL), 0 }, // EFI_IFR_EQ_ID_VAL_OP
2290 { sizeof (EFI_IFR_EQ_ID_ID), 0 }, // EFI_IFR_EQ_ID_ID_OP
2291 { sizeof (EFI_IFR_EQ_ID_VAL_LIST), 0 }, // EFI_IFR_EQ_ID_LIST_OP - 0x14
2292 { sizeof (EFI_IFR_AND), 0 }, // EFI_IFR_AND_OP
2293 { sizeof (EFI_IFR_OR), 0 }, // EFI_IFR_OR_OP
2294 { sizeof (EFI_IFR_NOT), 0 }, // EFI_IFR_NOT_OP
2295 { sizeof (EFI_IFR_RULE), 1 }, // EFI_IFR_RULE_OP
2296 { sizeof (EFI_IFR_GRAY_OUT_IF), 1 }, // EFI_IFR_GRAYOUT_IF_OP - 0x19
2297 { sizeof (EFI_IFR_DATE), 1 }, // EFI_IFR_DATE_OP
2298 { sizeof (EFI_IFR_TIME), 1 }, // EFI_IFR_TIME_OP
2299 { sizeof (EFI_IFR_STRING), 1 }, // EFI_IFR_STRING_OP
2300 { sizeof (EFI_IFR_REFRESH), 0 }, // EFI_IFR_REFRESH_OP
2301 { sizeof (EFI_IFR_DISABLE_IF), 1 }, // EFI_IFR_DISABLE_IF_OP - 0x1E
2302 { 0, 0 }, // 0x1F
2303 { sizeof (EFI_IFR_TO_LOWER), 0 }, // EFI_IFR_TO_LOWER_OP - 0x20
2304 { sizeof (EFI_IFR_TO_UPPER), 0 }, // EFI_IFR_TO_UPPER_OP - 0x21
2305 { sizeof (EFI_IFR_MAP), 1 }, // EFI_IFR_MAP - 0x22
2306 { sizeof (EFI_IFR_ORDERED_LIST), 1 }, // EFI_IFR_ORDERED_LIST_OP - 0x23
2307 { sizeof (EFI_IFR_VARSTORE), 0 }, // EFI_IFR_VARSTORE_OP
2308 { sizeof (EFI_IFR_VARSTORE_NAME_VALUE), 0 }, // EFI_IFR_VARSTORE_NAME_VALUE_OP
2309 { sizeof (EFI_IFR_VARSTORE_EFI), 0 }, // EFI_IFR_VARSTORE_EFI_OP
2310 { sizeof (EFI_IFR_VARSTORE_DEVICE), 1 }, // EFI_IFR_VARSTORE_DEVICE_OP
2311 { sizeof (EFI_IFR_VERSION), 0 }, // EFI_IFR_VERSION_OP - 0x28
2312 { sizeof (EFI_IFR_END), 0 }, // EFI_IFR_END_OP
2313 { sizeof (EFI_IFR_MATCH), 0 }, // EFI_IFR_MATCH_OP - 0x2A
2314 { sizeof (EFI_IFR_GET), 0 }, // EFI_IFR_GET - 0x2B
2315 { sizeof (EFI_IFR_SET), 0 }, // EFI_IFR_SET - 0x2C
2316 { sizeof (EFI_IFR_READ), 0 }, // EFI_IFR_READ - 0x2D
2317 { sizeof (EFI_IFR_WRITE), 0 }, // EFI_IFR_WRITE - 0x2E
2318 { sizeof (EFI_IFR_EQUAL), 0 }, // EFI_IFR_EQUAL_OP - 0x2F
2319 { sizeof (EFI_IFR_NOT_EQUAL), 0 }, // EFI_IFR_NOT_EQUAL_OP
2320 { sizeof (EFI_IFR_GREATER_THAN), 0 }, // EFI_IFR_GREATER_THAN_OP
2321 { sizeof (EFI_IFR_GREATER_EQUAL), 0 }, // EFI_IFR_GREATER_EQUAL_OP
2322 { sizeof (EFI_IFR_LESS_THAN), 0 }, // EFI_IFR_LESS_THAN_OP
2323 { sizeof (EFI_IFR_LESS_EQUAL), 0 }, // EFI_IFR_LESS_EQUAL_OP - 0x34
2324 { sizeof (EFI_IFR_BITWISE_AND), 0 }, // EFI_IFR_BITWISE_AND_OP
2325 { sizeof (EFI_IFR_BITWISE_OR), 0 }, // EFI_IFR_BITWISE_OR_OP
2326 { sizeof (EFI_IFR_BITWISE_NOT), 0 }, // EFI_IFR_BITWISE_NOT_OP
2327 { sizeof (EFI_IFR_SHIFT_LEFT), 0 }, // EFI_IFR_SHIFT_LEFT_OP
2328 { sizeof (EFI_IFR_SHIFT_RIGHT), 0 }, // EFI_IFR_SHIFT_RIGHT_OP
2329 { sizeof (EFI_IFR_ADD), 0 }, // EFI_IFR_ADD_OP - 0x3A
2330 { sizeof (EFI_IFR_SUBTRACT), 0 }, // EFI_IFR_SUBTRACT_OP
2331 { sizeof (EFI_IFR_MULTIPLY), 0 }, // EFI_IFR_MULTIPLY_OP
2332 { sizeof (EFI_IFR_DIVIDE), 0 }, // EFI_IFR_DIVIDE_OP
2333 { sizeof (EFI_IFR_MODULO), 0 }, // EFI_IFR_MODULO_OP - 0x3E
2334 { sizeof (EFI_IFR_RULE_REF), 0 }, // EFI_IFR_RULE_REF_OP
2335 { sizeof (EFI_IFR_QUESTION_REF1), 0 }, // EFI_IFR_QUESTION_REF1_OP
2336 { sizeof (EFI_IFR_QUESTION_REF2), 0 }, // EFI_IFR_QUESTION_REF2_OP - 0x41
2337 { sizeof (EFI_IFR_UINT8), 0}, // EFI_IFR_UINT8
2338 { sizeof (EFI_IFR_UINT16), 0}, // EFI_IFR_UINT16
2339 { sizeof (EFI_IFR_UINT32), 0}, // EFI_IFR_UINT32
2340 { sizeof (EFI_IFR_UINT64), 0}, // EFI_IFR_UTNT64
2341 { sizeof (EFI_IFR_TRUE), 0 }, // EFI_IFR_TRUE_OP - 0x46
2342 { sizeof (EFI_IFR_FALSE), 0 }, // EFI_IFR_FALSE_OP
2343 { sizeof (EFI_IFR_TO_UINT), 0 }, // EFI_IFR_TO_UINT_OP
2344 { sizeof (EFI_IFR_TO_STRING), 0 }, // EFI_IFR_TO_STRING_OP
2345 { sizeof (EFI_IFR_TO_BOOLEAN), 0 }, // EFI_IFR_TO_BOOLEAN_OP
2346 { sizeof (EFI_IFR_MID), 0 }, // EFI_IFR_MID_OP
2347 { sizeof (EFI_IFR_FIND), 0 }, // EFI_IFR_FIND_OP
2348 { sizeof (EFI_IFR_TOKEN), 0 }, // EFI_IFR_TOKEN_OP
2349 { sizeof (EFI_IFR_STRING_REF1), 0 }, // EFI_IFR_STRING_REF1_OP - 0x4E
2350 { sizeof (EFI_IFR_STRING_REF2), 0 }, // EFI_IFR_STRING_REF2_OP
2351 { sizeof (EFI_IFR_CONDITIONAL), 0 }, // EFI_IFR_CONDITIONAL_OP
2352 { sizeof (EFI_IFR_QUESTION_REF3), 0 }, // EFI_IFR_QUESTION_REF3_OP
2353 { sizeof (EFI_IFR_ZERO), 0 }, // EFI_IFR_ZERO_OP
2354 { sizeof (EFI_IFR_ONE), 0 }, // EFI_IFR_ONE_OP
2355 { sizeof (EFI_IFR_ONES), 0 }, // EFI_IFR_ONES_OP
2356 { sizeof (EFI_IFR_UNDEFINED), 0 }, // EFI_IFR_UNDEFINED_OP
2357 { sizeof (EFI_IFR_LENGTH), 0 }, // EFI_IFR_LENGTH_OP
2358 { sizeof (EFI_IFR_DUP), 0 }, // EFI_IFR_DUP_OP - 0x57
2359 { sizeof (EFI_IFR_THIS), 0 }, // EFI_IFR_THIS_OP
2360 { sizeof (EFI_IFR_SPAN), 0 }, // EFI_IFR_SPAN_OP
2361 { sizeof (EFI_IFR_VALUE), 1 }, // EFI_IFR_VALUE_OP
2362 { sizeof (EFI_IFR_DEFAULT), 0 }, // EFI_IFR_DEFAULT_OP
2363 { sizeof (EFI_IFR_DEFAULTSTORE), 0 }, // EFI_IFR_DEFAULTSTORE_OP - 0x5C
2364 { sizeof (EFI_IFR_FORM_MAP), 1}, // EFI_IFR_FORM_MAP_OP - 0x5D
2365 { sizeof (EFI_IFR_CATENATE), 0 }, // EFI_IFR_CATENATE_OP
2366 { sizeof (EFI_IFR_GUID), 0 }, // EFI_IFR_GUID_OP
2367 { sizeof (EFI_IFR_SECURITY), 0 }, // EFI_IFR_SECURITY_OP - 0x60
2368 { sizeof (EFI_IFR_MODAL_TAG), 0}, // EFI_IFR_MODAL_TAG_OP - 0x61
2369 { sizeof (EFI_IFR_REFRESH_ID), 0}, // EFI_IFR_REFRESH_ID_OP - 0x62
2370 { sizeof (EFI_IFR_WARNING_IF), 1}, // EFI_IFR_WARNING_IF_OP - 0x63
2371 { sizeof (EFI_IFR_MATCH2), 0 }, // EFI_IFR_MATCH2_OP - 0x64
2372 };
2373
2374 #ifdef CIFROBJ_DEUBG
2375 static struct {
2376 CHAR8 *mIfrName;
2377 } gIfrObjPrintDebugTable[] = {
2378 "EFI_IFR_INVALID", "EFI_IFR_FORM", "EFI_IFR_SUBTITLE", "EFI_IFR_TEXT", "EFI_IFR_IMAGE", "EFI_IFR_ONE_OF",
2379 "EFI_IFR_CHECKBOX", "EFI_IFR_NUMERIC", "EFI_IFR_PASSWORD", "EFI_IFR_ONE_OF_OPTION", "EFI_IFR_SUPPRESS_IF", "EFI_IFR_LOCKED",
2380 "EFI_IFR_ACTION", "EFI_IFR_RESET_BUTTON", "EFI_IFR_FORM_SET", "EFI_IFR_REF", "EFI_IFR_NO_SUBMIT_IF", "EFI_IFR_INCONSISTENT_IF",
2381 "EFI_IFR_EQ_ID_VAL", "EFI_IFR_EQ_ID_ID", "EFI_IFR_EQ_ID_LIST", "EFI_IFR_AND", "EFI_IFR_OR", "EFI_IFR_NOT",
2382 "EFI_IFR_RULE", "EFI_IFR_GRAY_OUT_IF", "EFI_IFR_DATE", "EFI_IFR_TIME", "EFI_IFR_STRING", "EFI_IFR_REFRESH",
2383 "EFI_IFR_DISABLE_IF", "EFI_IFR_INVALID", "EFI_IFR_TO_LOWER", "EFI_IFR_TO_UPPER", "EFI_IFR_MAP", "EFI_IFR_ORDERED_LIST",
2384 "EFI_IFR_VARSTORE", "EFI_IFR_VARSTORE_NAME_VALUE", "EFI_IFR_VARSTORE_EFI", "EFI_IFR_VARSTORE_DEVICE", "EFI_IFR_VERSION", "EFI_IFR_END",
2385 "EFI_IFR_MATCH", "EFI_IFR_GET", "EFI_IFR_SET", "EFI_IFR_READ", "EFI_IFR_WRITE", "EFI_IFR_EQUAL",
2386 "EFI_IFR_NOT_EQUAL", "EFI_IFR_GREATER_THAN", "EFI_IFR_GREATER_EQUAL", "EFI_IFR_LESS_THAN", "EFI_IFR_LESS_EQUAL", "EFI_IFR_BITWISE_AND",
2387 "EFI_IFR_BITWISE_OR", "EFI_IFR_BITWISE_NOT", "EFI_IFR_SHIFT_LEFT", "EFI_IFR_SHIFT_RIGHT", "EFI_IFR_ADD", "EFI_IFR_SUBTRACT",
2388 "EFI_IFR_MULTIPLY", "EFI_IFR_DIVIDE", "EFI_IFR_MODULO", "EFI_IFR_RULE_REF", "EFI_IFR_QUESTION_REF1", "EFI_IFR_QUESTION_REF2",
2389 "EFI_IFR_UINT8", "EFI_IFR_UINT16", "EFI_IFR_UINT32", "EFI_IFR_UINT64", "EFI_IFR_TRUE", "EFI_IFR_FALSE",
2390 "EFI_IFR_TO_UINT", "EFI_IFR_TO_STRING", "EFI_IFR_TO_BOOLEAN", "EFI_IFR_MID", "EFI_IFR_FIND", "EFI_IFR_TOKEN",
2391 "EFI_IFR_STRING_REF1","EFI_IFR_STRING_REF2", "EFI_IFR_CONDITIONAL", "EFI_IFR_QUESTION_REF3", "EFI_IFR_ZERO", "EFI_IFR_ONE",
2392 "EFI_IFR_ONES", "EFI_IFR_UNDEFINED", "EFI_IFR_LENGTH", "EFI_IFR_DUP", "EFI_IFR_THIS", "EFI_IFR_SPAN",
2393 "EFI_IFR_VALUE", "EFI_IFR_DEFAULT", "EFI_IFR_DEFAULTSTORE", "EFI_IFR_FORM_MAP", "EFI_IFR_CATENATE", "EFI_IFR_GUID",
2394 "EFI_IFR_SECURITY", "EFI_IFR_MODAL_TAG", "EFI_IFR_REFRESH_ID", "EFI_IFR_WARNING_IF", "EFI_IFR_MATCH2",
2395 };
2396
2397 VOID
2398 CIFROBJ_DEBUG_PRINT (
2399 IN UINT8 OpCode
2400 )
2401 {
2402 printf ("======Create IFR [%s]\n", gIfrObjPrintDebugTable[OpCode].mIfrName);
2403 }
2404 #else
2405
2406 #define CIFROBJ_DEBUG_PRINT(OpCode)
2407
2408 #endif
2409
2410 BOOLEAN gCreateOp = TRUE;
2411
2412 CIfrObj::CIfrObj (
2413 IN UINT8 OpCode,
2414 OUT CHAR8 **IfrObj,
2415 IN UINT8 ObjBinLen,
2416 IN BOOLEAN DelayEmit
2417 )
2418 {
2419 mDelayEmit = DelayEmit;
2420 mPkgOffset = gCFormPkg.GetPkgLength ();
2421 mObjBinLen = (ObjBinLen == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : ObjBinLen;
2422 mObjBinBuf = ((DelayEmit == FALSE) && (gCreateOp == TRUE)) ? gCFormPkg.IfrBinBufferGet (mObjBinLen) : new CHAR8[EFI_IFR_MAX_LENGTH];
2423 mRecordIdx = (gCreateOp == TRUE) ? gCIfrRecordInfoDB.IfrRecordRegister (0xFFFFFFFF, mObjBinBuf, mObjBinLen, mPkgOffset) : EFI_IFR_RECORDINFO_IDX_INVALUD;
2424
2425 assert (mObjBinBuf != NULL);
2426
2427 if (IfrObj != NULL) {
2428 *IfrObj = mObjBinBuf;
2429 }
2430
2431 CIFROBJ_DEBUG_PRINT (OpCode);
2432 }
2433
2434 CIfrObj::~CIfrObj (
2435 VOID
2436 )
2437 {
2438 if ((mDelayEmit == TRUE) && ((gCreateOp == TRUE))) {
2439 _EMIT_PENDING_OBJ ();
2440 }
2441
2442 gCIfrRecordInfoDB.IfrRecordInfoUpdate (mRecordIdx, mLineNo, mObjBinBuf, mObjBinLen, mPkgOffset);
2443 }
2444
2445 /*
2446 * The definition of CIfrObj's member function
2447 */
2448 UINT8 gScopeCount = 0;
2449
2450 CIfrOpHeader::CIfrOpHeader (
2451 IN UINT8 OpCode,
2452 IN VOID *StartAddr,
2453 IN UINT8 Length
2454 ) : mHeader ((EFI_IFR_OP_HEADER *)StartAddr)
2455 {
2456 mHeader->OpCode = OpCode;
2457 mHeader->Length = (Length == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : Length;
2458 mHeader->Scope = (gOpcodeSizesScopeTable[OpCode].mScope + gScopeCount > 0) ? 1 : 0;
2459 }
2460
2461 CIfrOpHeader::CIfrOpHeader (
2462 IN CIfrOpHeader &OpHdr
2463 )
2464 {
2465 mHeader = OpHdr.mHeader;
2466 }
2467
2468 UINT32 CIfrFormId::FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE] = {0, };
EFI Development Kit II mirror for PVE