]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/SetupBrowserDxe/IfrParse.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
1. Support inconsistent if opcode used in string/password opcode.
[mirror_edk2.git] / MdeModulePkg / Universal / SetupBrowserDxe / IfrParse.c
1 /** @file
2 Parser for IFR binary encoding.
3
4 Copyright (c) 2007 - 2010, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "Setup.h"
16
17 UINT16 mStatementIndex;
18 UINT16 mExpressionOpCodeIndex;
19
20 BOOLEAN mInScopeSubtitle;
21 BOOLEAN mInScopeSuppress;
22 BOOLEAN mInScopeGrayOut;
23 BOOLEAN mInScopeDisable;
24 FORM_EXPRESSION *mSuppressExpression;
25 FORM_EXPRESSION *mGrayOutExpression;
26 FORM_EXPRESSION *mDisableExpression;
27
28 /**
29 Initialize Statement header members.
30
31 @param OpCodeData Pointer of the raw OpCode data.
32 @param FormSet Pointer of the current FormSe.
33 @param Form Pointer of the current Form.
34
35 @return The Statement.
36
37 **/
38 FORM_BROWSER_STATEMENT *
39 CreateStatement (
40 IN UINT8 *OpCodeData,
41 IN OUT FORM_BROWSER_FORMSET *FormSet,
42 IN OUT FORM_BROWSER_FORM *Form
43 )
44 {
45 FORM_BROWSER_STATEMENT *Statement;
46 EFI_IFR_STATEMENT_HEADER *StatementHdr;
47
48 if (Form == NULL) {
49 //
50 // We are currently not in a Form Scope, so just skip this Statement
51 //
52 return NULL;
53 }
54
55 Statement = &FormSet->StatementBuffer[mStatementIndex];
56 mStatementIndex++;
57
58 InitializeListHead (&Statement->DefaultListHead);
59 InitializeListHead (&Statement->OptionListHead);
60 InitializeListHead (&Statement->InconsistentListHead);
61 InitializeListHead (&Statement->NoSubmitListHead);
62
63 Statement->Signature = FORM_BROWSER_STATEMENT_SIGNATURE;
64
65 Statement->Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
66
67 StatementHdr = (EFI_IFR_STATEMENT_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
68 CopyMem (&Statement->Prompt, &StatementHdr->Prompt, sizeof (EFI_STRING_ID));
69 CopyMem (&Statement->Help, &StatementHdr->Help, sizeof (EFI_STRING_ID));
70
71 if (mInScopeSuppress) {
72 Statement->SuppressExpression = mSuppressExpression;
73 }
74
75 if (mInScopeGrayOut) {
76 Statement->GrayOutExpression = mGrayOutExpression;
77 }
78
79
80 if (mInScopeDisable) {
81 Statement->DisableExpression = mDisableExpression;
82 }
83
84 Statement->InSubtitle = mInScopeSubtitle;
85
86 //
87 // Insert this Statement into current Form
88 //
89 InsertTailList (&Form->StatementListHead, &Statement->Link);
90
91 return Statement;
92 }
93
94 /**
95 Convert a numeric value to a Unicode String and insert it to String Package.
96 This string is used as the Unicode Name for the EFI Variable. This is to support
97 the deprecated vareqval opcode.
98
99 @param FormSet The FormSet.
100 @param Statement The numeric question whose VarStoreInfo.VarName is the
101 numeric value which is used to produce the Unicode Name
102 for the EFI Variable.
103
104 If the Statement is NULL, the ASSERT.
105 If the opcode is not Numeric, then ASSERT.
106
107 @retval EFI_SUCCESS The funtion always succeeds.
108 **/
109 EFI_STATUS
110 UpdateCheckBoxStringToken (
111 IN CONST FORM_BROWSER_FORMSET *FormSet,
112 IN FORM_BROWSER_STATEMENT *Statement
113 )
114 {
115 CHAR16 Str[MAXIMUM_VALUE_CHARACTERS];
116 EFI_STRING_ID Id;
117
118 ASSERT (Statement != NULL);
119 ASSERT (Statement->Operand == EFI_IFR_NUMERIC_OP);
120
121 UnicodeValueToString (Str, 0, Statement->VarStoreInfo.VarName, MAXIMUM_VALUE_CHARACTERS - 1);
122
123 Id = HiiSetString (FormSet->HiiHandle, 0, Str, NULL);
124 if (Id == 0) {
125 return EFI_OUT_OF_RESOURCES;
126 }
127
128 Statement->VarStoreInfo.VarName = Id;
129
130 return EFI_SUCCESS;
131 }
132
133 /**
134 Check if the next opcode is the EFI_IFR_EXTEND_OP_VAREQNAME.
135
136 @param OpCodeData The current opcode.
137
138 @retval TRUE Yes.
139 @retval FALSE No.
140 **/
141 BOOLEAN
142 IsNextOpCodeGuidedVarEqName (
143 IN UINT8 *OpCodeData
144 )
145 {
146 //
147 // Get next opcode
148 //
149 OpCodeData += ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
150 if (*OpCodeData == EFI_IFR_GUID_OP) {
151 if (CompareGuid (&gEfiIfrFrameworkGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
152 //
153 // Specific GUIDed opcodes to support IFR generated from Framework HII VFR
154 //
155 if ((((EFI_IFR_GUID_VAREQNAME *) OpCodeData)->ExtendOpCode) == EFI_IFR_EXTEND_OP_VAREQNAME) {
156 return TRUE;
157 }
158 }
159 }
160
161 return FALSE;
162 }
163
164 /**
165 Initialize Question's members.
166
167 @param OpCodeData Pointer of the raw OpCode data.
168 @param FormSet Pointer of the current FormSet.
169 @param Form Pointer of the current Form.
170
171 @return The Question.
172
173 **/
174 FORM_BROWSER_STATEMENT *
175 CreateQuestion (
176 IN UINT8 *OpCodeData,
177 IN OUT FORM_BROWSER_FORMSET *FormSet,
178 IN OUT FORM_BROWSER_FORM *Form
179 )
180 {
181 FORM_BROWSER_STATEMENT *Statement;
182 EFI_IFR_QUESTION_HEADER *QuestionHdr;
183 LIST_ENTRY *Link;
184 FORMSET_STORAGE *Storage;
185 NAME_VALUE_NODE *NameValueNode;
186 EFI_STATUS Status;
187
188 Statement = CreateStatement (OpCodeData, FormSet, Form);
189 if (Statement == NULL) {
190 return NULL;
191 }
192
193 QuestionHdr = (EFI_IFR_QUESTION_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
194 CopyMem (&Statement->QuestionId, &QuestionHdr->QuestionId, sizeof (EFI_QUESTION_ID));
195 CopyMem (&Statement->VarStoreId, &QuestionHdr->VarStoreId, sizeof (EFI_VARSTORE_ID));
196 CopyMem (&Statement->VarStoreInfo.VarOffset, &QuestionHdr->VarStoreInfo.VarOffset, sizeof (UINT16));
197
198 Statement->QuestionFlags = QuestionHdr->Flags;
199
200 if (Statement->VarStoreId == 0) {
201 //
202 // VarStoreId of zero indicates no variable storage
203 //
204 return Statement;
205 }
206
207 //
208 // Take a look at next OpCode to see whether it is a GUIDed opcode to support
209 // Framework Compatibility
210 //
211 if (FeaturePcdGet (PcdFrameworkCompatibilitySupport)) {
212 if ((*OpCodeData == EFI_IFR_NUMERIC_OP) && IsNextOpCodeGuidedVarEqName (OpCodeData)) {
213 Status = UpdateCheckBoxStringToken (FormSet, Statement);
214 if (EFI_ERROR (Status)) {
215 return NULL;
216 }
217 }
218 }
219
220 //
221 // Find Storage for this Question
222 //
223 Link = GetFirstNode (&FormSet->StorageListHead);
224 while (!IsNull (&FormSet->StorageListHead, Link)) {
225 Storage = FORMSET_STORAGE_FROM_LINK (Link);
226
227 if (Storage->VarStoreId == Statement->VarStoreId) {
228 Statement->Storage = Storage;
229 break;
230 }
231
232 Link = GetNextNode (&FormSet->StorageListHead, Link);
233 }
234 ASSERT (Statement->Storage != NULL);
235
236 //
237 // Initialilze varname for Name/Value or EFI Variable
238 //
239 if ((Statement->Storage->Type == EFI_HII_VARSTORE_NAME_VALUE) ||
240 (Statement->Storage->Type == EFI_HII_VARSTORE_EFI_VARIABLE)) {
241 Statement->VariableName = GetToken (Statement->VarStoreInfo.VarName, FormSet->HiiHandle);
242 ASSERT (Statement->VariableName != NULL);
243
244 if (Statement->Storage->Type == EFI_HII_VARSTORE_NAME_VALUE) {
245 //
246 // Insert to Name/Value varstore list
247 //
248 NameValueNode = AllocateZeroPool (sizeof (NAME_VALUE_NODE));
249 ASSERT (NameValueNode != NULL);
250 NameValueNode->Signature = NAME_VALUE_NODE_SIGNATURE;
251 NameValueNode->Name = AllocateCopyPool (StrSize (Statement->VariableName), Statement->VariableName);
252 ASSERT (NameValueNode->Name != NULL);
253 NameValueNode->Value = AllocateZeroPool (0x10);
254 ASSERT (NameValueNode->Value != NULL);
255 NameValueNode->EditValue = AllocateZeroPool (0x10);
256 ASSERT (NameValueNode->EditValue != NULL);
257
258 InsertTailList (&Statement->Storage->NameValueListHead, &NameValueNode->Link);
259 }
260 }
261
262 return Statement;
263 }
264
265
266 /**
267 Allocate a FORM_EXPRESSION node.
268
269 @param Form The Form associated with this Expression
270
271 @return Pointer to a FORM_EXPRESSION data structure.
272
273 **/
274 FORM_EXPRESSION *
275 CreateExpression (
276 IN OUT FORM_BROWSER_FORM *Form
277 )
278 {
279 FORM_EXPRESSION *Expression;
280
281 Expression = AllocateZeroPool (sizeof (FORM_EXPRESSION));
282 ASSERT (Expression != NULL);
283 Expression->Signature = FORM_EXPRESSION_SIGNATURE;
284 InitializeListHead (&Expression->OpCodeListHead);
285
286 return Expression;
287 }
288
289
290 /**
291 Allocate a FORMSET_STORAGE data structure and insert to FormSet Storage List.
292
293 @param FormSet Pointer of the current FormSet
294
295 @return Pointer to a FORMSET_STORAGE data structure.
296
297 **/
298 FORMSET_STORAGE *
299 CreateStorage (
300 IN FORM_BROWSER_FORMSET *FormSet
301 )
302 {
303 FORMSET_STORAGE *Storage;
304
305 Storage = AllocateZeroPool (sizeof (FORMSET_STORAGE));
306 ASSERT (Storage != NULL);
307 Storage->Signature = FORMSET_STORAGE_SIGNATURE;
308 InitializeListHead (&Storage->NameValueListHead);
309 InsertTailList (&FormSet->StorageListHead, &Storage->Link);
310
311 return Storage;
312 }
313
314
315 /**
316 Create ConfigHdr string for a storage.
317
318 @param FormSet Pointer of the current FormSet
319 @param Storage Pointer of the storage
320
321 @retval EFI_SUCCESS Initialize ConfigHdr success
322
323 **/
324 EFI_STATUS
325 InitializeConfigHdr (
326 IN FORM_BROWSER_FORMSET *FormSet,
327 IN OUT FORMSET_STORAGE *Storage
328 )
329 {
330 CHAR16 *Name;
331
332 if (Storage->Type == EFI_HII_VARSTORE_BUFFER) {
333 Name = Storage->Name;
334 } else {
335 Name = NULL;
336 }
337
338 Storage->ConfigHdr = HiiConstructConfigHdr (
339 &Storage->Guid,
340 Name,
341 FormSet->DriverHandle
342 );
343
344 if (Storage->ConfigHdr == NULL) {
345 return EFI_NOT_FOUND;
346 }
347
348 Storage->ConfigRequest = AllocateCopyPool (StrSize (Storage->ConfigHdr), Storage->ConfigHdr);
349 Storage->SpareStrLen = 0;
350
351 return EFI_SUCCESS;
352 }
353
354
355 /**
356 Initialize Request Element of a Question. <RequestElement> ::= '&'<BlockName> | '&'<Label>
357
358 @param FormSet Pointer of the current FormSet.
359 @param Question The Question to be initialized.
360
361 @retval EFI_SUCCESS Function success.
362 @retval EFI_INVALID_PARAMETER No storage associated with the Question.
363
364 **/
365 EFI_STATUS
366 InitializeRequestElement (
367 IN OUT FORM_BROWSER_FORMSET *FormSet,
368 IN OUT FORM_BROWSER_STATEMENT *Question
369 )
370 {
371 FORMSET_STORAGE *Storage;
372 UINTN StrLen;
373 UINTN StringSize;
374 CHAR16 *NewStr;
375 CHAR16 RequestElement[30];
376
377 Storage = Question->Storage;
378 if (Storage == NULL) {
379 return EFI_INVALID_PARAMETER;
380 }
381
382 if (Storage->Type == EFI_HII_VARSTORE_EFI_VARIABLE) {
383 //
384 // <ConfigRequest> is unnecessary for EFI variable storage,
385 // GetVariable()/SetVariable() will be used to retrieve/save values
386 //
387 return EFI_SUCCESS;
388 }
389
390 //
391 // Prepare <RequestElement>
392 //
393 if (Storage->Type == EFI_HII_VARSTORE_BUFFER) {
394 StrLen = UnicodeSPrint (
395 RequestElement,
396 30 * sizeof (CHAR16),
397 L"&OFFSET=%x&WIDTH=%x",
398 Question->VarStoreInfo.VarOffset,
399 Question->StorageWidth
400 );
401 Question->BlockName = AllocateCopyPool ((StrLen + 1) * sizeof (CHAR16), RequestElement);
402 } else {
403 StrLen = UnicodeSPrint (RequestElement, 30 * sizeof (CHAR16), L"&%s", Question->VariableName);
404 }
405
406 if ((Question->Operand == EFI_IFR_PASSWORD_OP) && ((Question->QuestionFlags & EFI_IFR_FLAG_CALLBACK) == EFI_IFR_FLAG_CALLBACK)) {
407 //
408 // Password with CALLBACK flag is stored in encoded format,
409 // so don't need to append it to <ConfigRequest>
410 //
411 return EFI_SUCCESS;
412 }
413
414 //
415 // Append <RequestElement> to <ConfigRequest>
416 //
417 if (StrLen > Storage->SpareStrLen) {
418 //
419 // Old String buffer is not sufficient for RequestElement, allocate a new one
420 //
421 StringSize = (Storage->ConfigRequest != NULL) ? StrSize (Storage->ConfigRequest) : sizeof (CHAR16);
422 NewStr = AllocateZeroPool (StringSize + CONFIG_REQUEST_STRING_INCREMENTAL * sizeof (CHAR16));
423 ASSERT (NewStr != NULL);
424 if (Storage->ConfigRequest != NULL) {
425 CopyMem (NewStr, Storage->ConfigRequest, StringSize);
426 FreePool (Storage->ConfigRequest);
427 }
428 Storage->ConfigRequest = NewStr;
429 Storage->SpareStrLen = CONFIG_REQUEST_STRING_INCREMENTAL;
430 }
431
432 StrCat (Storage->ConfigRequest, RequestElement);
433 Storage->ElementCount++;
434 Storage->SpareStrLen -= StrLen;
435
436 return EFI_SUCCESS;
437 }
438
439
440 /**
441 Free resources of a Expression.
442
443 @param FormSet Pointer of the Expression
444
445 **/
446 VOID
447 DestroyExpression (
448 IN FORM_EXPRESSION *Expression
449 )
450 {
451 LIST_ENTRY *Link;
452 EXPRESSION_OPCODE *OpCode;
453 LIST_ENTRY *SubExpressionLink;
454 FORM_EXPRESSION *SubExpression;
455
456 while (!IsListEmpty (&Expression->OpCodeListHead)) {
457 Link = GetFirstNode (&Expression->OpCodeListHead);
458 OpCode = EXPRESSION_OPCODE_FROM_LINK (Link);
459 RemoveEntryList (&OpCode->Link);
460
461 if (OpCode->ValueList != NULL) {
462 FreePool (OpCode->ValueList);
463 }
464
465 if (OpCode->ValueName != NULL) {
466 FreePool (OpCode->ValueName);
467 }
468
469 if (OpCode->MapExpressionList.ForwardLink != NULL) {
470 while (!IsListEmpty (&OpCode->MapExpressionList)) {
471 SubExpressionLink = GetFirstNode(&OpCode->MapExpressionList);
472 SubExpression = FORM_EXPRESSION_FROM_LINK (SubExpressionLink);
473 RemoveEntryList(&SubExpression->Link);
474 DestroyExpression (SubExpression);
475 }
476 }
477 }
478
479 //
480 // Free this Expression
481 //
482 FreePool (Expression);
483 }
484
485
486 /**
487 Free resources of a storage.
488
489 @param Storage Pointer of the storage
490
491 **/
492 VOID
493 DestroyStorage (
494 IN FORMSET_STORAGE *Storage
495 )
496 {
497 LIST_ENTRY *Link;
498 NAME_VALUE_NODE *NameValueNode;
499
500 if (Storage == NULL) {
501 return;
502 }
503
504 if (Storage->Name != NULL) {
505 FreePool (Storage->Name);
506 }
507 if (Storage->Buffer != NULL) {
508 FreePool (Storage->Buffer);
509 }
510 if (Storage->EditBuffer != NULL) {
511 FreePool (Storage->EditBuffer);
512 }
513
514 while (!IsListEmpty (&Storage->NameValueListHead)) {
515 Link = GetFirstNode (&Storage->NameValueListHead);
516 NameValueNode = NAME_VALUE_NODE_FROM_LINK (Link);
517 RemoveEntryList (&NameValueNode->Link);
518
519 if (NameValueNode->Name != NULL) {
520 FreePool (NameValueNode->Name);
521 }
522 if (NameValueNode->Value != NULL) {
523 FreePool (NameValueNode->Value);
524 }
525 if (NameValueNode->EditValue != NULL) {
526 FreePool (NameValueNode->EditValue);
527 }
528 FreePool (NameValueNode);
529 }
530
531 if (Storage->ConfigHdr != NULL) {
532 FreePool (Storage->ConfigHdr);
533 }
534 if (Storage->ConfigRequest != NULL) {
535 FreePool (Storage->ConfigRequest);
536 }
537
538 FreePool (Storage);
539 }
540
541
542 /**
543 Free resources of a Statement.
544
545 @param FormSet Pointer of the FormSet
546 @param Statement Pointer of the Statement
547
548 **/
549 VOID
550 DestroyStatement (
551 IN FORM_BROWSER_FORMSET *FormSet,
552 IN OUT FORM_BROWSER_STATEMENT *Statement
553 )
554 {
555 LIST_ENTRY *Link;
556 QUESTION_DEFAULT *Default;
557 QUESTION_OPTION *Option;
558 FORM_EXPRESSION *Expression;
559
560 //
561 // Free Default value List
562 //
563 while (!IsListEmpty (&Statement->DefaultListHead)) {
564 Link = GetFirstNode (&Statement->DefaultListHead);
565 Default = QUESTION_DEFAULT_FROM_LINK (Link);
566 RemoveEntryList (&Default->Link);
567
568 FreePool (Default);
569 }
570
571 //
572 // Free Options List
573 //
574 while (!IsListEmpty (&Statement->OptionListHead)) {
575 Link = GetFirstNode (&Statement->OptionListHead);
576 Option = QUESTION_OPTION_FROM_LINK (Link);
577 RemoveEntryList (&Option->Link);
578
579 FreePool (Option);
580 }
581
582 //
583 // Free Inconsistent List
584 //
585 while (!IsListEmpty (&Statement->InconsistentListHead)) {
586 Link = GetFirstNode (&Statement->InconsistentListHead);
587 Expression = FORM_EXPRESSION_FROM_LINK (Link);
588 RemoveEntryList (&Expression->Link);
589
590 DestroyExpression (Expression);
591 }
592
593 //
594 // Free NoSubmit List
595 //
596 while (!IsListEmpty (&Statement->NoSubmitListHead)) {
597 Link = GetFirstNode (&Statement->NoSubmitListHead);
598 Expression = FORM_EXPRESSION_FROM_LINK (Link);
599 RemoveEntryList (&Expression->Link);
600
601 DestroyExpression (Expression);
602 }
603
604 if (Statement->VariableName != NULL) {
605 FreePool (Statement->VariableName);
606 }
607 if (Statement->BlockName != NULL) {
608 FreePool (Statement->BlockName);
609 }
610 if (Statement->BufferValue != NULL) {
611 FreePool (Statement->BufferValue);
612 }
613 if (Statement->Operand == EFI_IFR_STRING_OP || Statement->Operand == EFI_IFR_PASSWORD_OP) {
614 DeleteString(Statement->HiiValue.Value.string, FormSet->HiiHandle);
615 }
616 }
617
618
619 /**
620 Free resources of a Form.
621
622 @param FormSet Pointer of the FormSet
623 @param Form Pointer of the Form.
624
625 **/
626 VOID
627 DestroyForm (
628 IN FORM_BROWSER_FORMSET *FormSet,
629 IN OUT FORM_BROWSER_FORM *Form
630 )
631 {
632 LIST_ENTRY *Link;
633 FORM_EXPRESSION *Expression;
634 FORM_BROWSER_STATEMENT *Statement;
635
636 //
637 // Free Form Expressions
638 //
639 while (!IsListEmpty (&Form->ExpressionListHead)) {
640 Link = GetFirstNode (&Form->ExpressionListHead);
641 Expression = FORM_EXPRESSION_FROM_LINK (Link);
642 RemoveEntryList (&Expression->Link);
643
644 DestroyExpression (Expression);
645 }
646
647 //
648 // Free Statements/Questions
649 //
650 while (!IsListEmpty (&Form->StatementListHead)) {
651 Link = GetFirstNode (&Form->StatementListHead);
652 Statement = FORM_BROWSER_STATEMENT_FROM_LINK (Link);
653 RemoveEntryList (&Statement->Link);
654
655 DestroyStatement (FormSet, Statement);
656 }
657
658 //
659 // Free this Form
660 //
661 FreePool (Form);
662 }
663
664
665 /**
666 Free resources allocated for a FormSet.
667
668 @param FormSet Pointer of the FormSet
669
670 **/
671 VOID
672 DestroyFormSet (
673 IN OUT FORM_BROWSER_FORMSET *FormSet
674 )
675 {
676 LIST_ENTRY *Link;
677 FORMSET_STORAGE *Storage;
678 FORMSET_DEFAULTSTORE *DefaultStore;
679 FORM_EXPRESSION *Expression;
680 FORM_BROWSER_FORM *Form;
681
682 if (FormSet->IfrBinaryData == NULL) {
683 //
684 // Uninitialized FormSet
685 //
686 FreePool (FormSet);
687 return;
688 }
689
690 //
691 // Free IFR binary buffer
692 //
693 FreePool (FormSet->IfrBinaryData);
694
695 //
696 // Free FormSet Storage
697 //
698 if (FormSet->StorageListHead.ForwardLink != NULL) {
699 while (!IsListEmpty (&FormSet->StorageListHead)) {
700 Link = GetFirstNode (&FormSet->StorageListHead);
701 Storage = FORMSET_STORAGE_FROM_LINK (Link);
702 RemoveEntryList (&Storage->Link);
703
704 DestroyStorage (Storage);
705 }
706 }
707
708 //
709 // Free FormSet Default Store
710 //
711 if (FormSet->DefaultStoreListHead.ForwardLink != NULL) {
712 while (!IsListEmpty (&FormSet->DefaultStoreListHead)) {
713 Link = GetFirstNode (&FormSet->DefaultStoreListHead);
714 DefaultStore = FORMSET_DEFAULTSTORE_FROM_LINK (Link);
715 RemoveEntryList (&DefaultStore->Link);
716
717 FreePool (DefaultStore);
718 }
719 }
720
721 //
722 // Free Formset Expressions
723 //
724 while (!IsListEmpty (&FormSet->ExpressionListHead)) {
725 Link = GetFirstNode (&FormSet->ExpressionListHead);
726 Expression = FORM_EXPRESSION_FROM_LINK (Link);
727 RemoveEntryList (&Expression->Link);
728
729 DestroyExpression (Expression);
730 }
731
732 //
733 // Free Forms
734 //
735 if (FormSet->FormListHead.ForwardLink != NULL) {
736 while (!IsListEmpty (&FormSet->FormListHead)) {
737 Link = GetFirstNode (&FormSet->FormListHead);
738 Form = FORM_BROWSER_FORM_FROM_LINK (Link);
739 RemoveEntryList (&Form->Link);
740
741 DestroyForm (FormSet, Form);
742 }
743 }
744
745 if (FormSet->StatementBuffer != NULL) {
746 FreePool (FormSet->StatementBuffer);
747 }
748 if (FormSet->ExpressionBuffer != NULL) {
749 FreePool (FormSet->ExpressionBuffer);
750 }
751
752 FreePool (FormSet);
753 }
754
755
756 /**
757 Tell whether this Operand is an Expression OpCode or not
758
759 @param Operand Operand of an IFR OpCode.
760
761 @retval TRUE This is an Expression OpCode.
762 @retval FALSE Not an Expression OpCode.
763
764 **/
765 BOOLEAN
766 IsExpressionOpCode (
767 IN UINT8 Operand
768 )
769 {
770 if (((Operand >= EFI_IFR_EQ_ID_VAL_OP) && (Operand <= EFI_IFR_NOT_OP)) ||
771 ((Operand >= EFI_IFR_MATCH_OP) && (Operand <= EFI_IFR_SET_OP)) ||
772 ((Operand >= EFI_IFR_EQUAL_OP) && (Operand <= EFI_IFR_SPAN_OP)) ||
773 (Operand == EFI_IFR_CATENATE_OP) ||
774 (Operand == EFI_IFR_TO_LOWER_OP) ||
775 (Operand == EFI_IFR_TO_UPPER_OP) ||
776 (Operand == EFI_IFR_MAP_OP) ||
777 (Operand == EFI_IFR_VERSION_OP) ||
778 (Operand == EFI_IFR_SECURITY_OP)) {
779 return TRUE;
780 } else {
781 return FALSE;
782 }
783 }
784
785
786 /**
787 Calculate number of Statemens(Questions) and Expression OpCodes.
788
789 @param FormSet The FormSet to be counted.
790 @param NumberOfStatement Number of Statemens(Questions)
791 @param NumberOfExpression Number of Expression OpCodes
792
793 **/
794 VOID
795 CountOpCodes (
796 IN FORM_BROWSER_FORMSET *FormSet,
797 IN OUT UINT16 *NumberOfStatement,
798 IN OUT UINT16 *NumberOfExpression
799 )
800 {
801 UINT16 StatementCount;
802 UINT16 ExpressionCount;
803 UINT8 *OpCodeData;
804 UINTN Offset;
805 UINTN OpCodeLen;
806
807 Offset = 0;
808 StatementCount = 0;
809 ExpressionCount = 0;
810
811 while (Offset < FormSet->IfrBinaryLength) {
812 OpCodeData = FormSet->IfrBinaryData + Offset;
813 OpCodeLen = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
814 Offset += OpCodeLen;
815
816 if (IsExpressionOpCode (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode)) {
817 ExpressionCount++;
818 } else {
819 StatementCount++;
820 }
821 }
822
823 *NumberOfStatement = StatementCount;
824 *NumberOfExpression = ExpressionCount;
825 }
826
827
828
829 /**
830 Parse opcodes in the formset IFR binary.
831
832 @param FormSet Pointer of the FormSet data structure.
833
834 @retval EFI_SUCCESS Opcode parse success.
835 @retval Other Opcode parse fail.
836
837 **/
838 EFI_STATUS
839 ParseOpCodes (
840 IN FORM_BROWSER_FORMSET *FormSet
841 )
842 {
843 EFI_STATUS Status;
844 UINT16 Index;
845 FORM_BROWSER_FORM *CurrentForm;
846 FORM_BROWSER_STATEMENT *CurrentStatement;
847 EXPRESSION_OPCODE *ExpressionOpCode;
848 FORM_EXPRESSION *CurrentExpression;
849 UINT8 Operand;
850 UINT8 Scope;
851 UINTN OpCodeOffset;
852 UINTN OpCodeLength;
853 UINT8 *OpCodeData;
854 UINT8 ScopeOpCode;
855 FORMSET_STORAGE *Storage;
856 FORMSET_DEFAULTSTORE *DefaultStore;
857 QUESTION_DEFAULT *CurrentDefault;
858 QUESTION_OPTION *CurrentOption;
859 UINT8 Width;
860 CHAR8 *AsciiString;
861 UINT16 NumberOfStatement;
862 UINT16 NumberOfExpression;
863 EFI_IMAGE_ID *ImageId;
864 BOOLEAN SuppressForQuestion;
865 BOOLEAN SuppressForOption;
866 BOOLEAN InScopeOptionSuppress;
867 FORM_EXPRESSION *OptionSuppressExpression;
868 BOOLEAN InScopeFormSuppress;
869 FORM_EXPRESSION *FormSuppressExpression;
870 UINT16 DepthOfDisable;
871 BOOLEAN OpCodeDisabled;
872 BOOLEAN SingleOpCodeExpression;
873 BOOLEAN InScopeDefault;
874 EFI_HII_VALUE *Value;
875 EFI_IFR_FORM_MAP_METHOD *MapMethod;
876 UINT8 MapScopeDepth;
877 LIST_ENTRY *Link;
878 FORMSET_STORAGE *VarStorage;
879 LIST_ENTRY *MapExpressionList;
880 EFI_VARSTORE_ID TempVarstoreId;
881
882 mInScopeSubtitle = FALSE;
883 SuppressForQuestion = FALSE;
884 SuppressForOption = FALSE;
885 InScopeFormSuppress = FALSE;
886 mInScopeSuppress = FALSE;
887 InScopeOptionSuppress = FALSE;
888 mInScopeGrayOut = FALSE;
889 mInScopeDisable = FALSE;
890 DepthOfDisable = 0;
891 OpCodeDisabled = FALSE;
892 SingleOpCodeExpression = FALSE;
893 InScopeDefault = FALSE;
894 CurrentExpression = NULL;
895 CurrentDefault = NULL;
896 CurrentOption = NULL;
897 OptionSuppressExpression = NULL;
898 FormSuppressExpression = NULL;
899 ImageId = NULL;
900 MapMethod = NULL;
901 MapScopeDepth = 0;
902 Link = NULL;
903 VarStorage = NULL;
904 MapExpressionList = NULL;
905 TempVarstoreId = 0;
906
907 //
908 // Get the number of Statements and Expressions
909 //
910 CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression);
911
912 mStatementIndex = 0;
913 FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT));
914 if (FormSet->StatementBuffer == NULL) {
915 return EFI_OUT_OF_RESOURCES;
916 }
917
918 mExpressionOpCodeIndex = 0;
919 FormSet->ExpressionBuffer = AllocateZeroPool (NumberOfExpression * sizeof (EXPRESSION_OPCODE));
920 if (FormSet->ExpressionBuffer == NULL) {
921 return EFI_OUT_OF_RESOURCES;
922 }
923
924 InitializeListHead (&FormSet->StorageListHead);
925 InitializeListHead (&FormSet->DefaultStoreListHead);
926 InitializeListHead (&FormSet->FormListHead);
927 ResetCurrentExpressionStack ();
928 ResetMapExpressionListStack ();
929
930 CurrentForm = NULL;
931 CurrentStatement = NULL;
932
933 ResetScopeStack ();
934
935 OpCodeOffset = 0;
936 while (OpCodeOffset < FormSet->IfrBinaryLength) {
937 OpCodeData = FormSet->IfrBinaryData + OpCodeOffset;
938
939 OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
940 OpCodeOffset += OpCodeLength;
941 Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
942 Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope;
943
944 //
945 // If scope bit set, push onto scope stack
946 //
947 if (Scope != 0) {
948 PushScope (Operand);
949 }
950
951 if (OpCodeDisabled) {
952 //
953 // DisableIf Expression is evaluated to be TRUE, try to find its end.
954 // Here only cares the EFI_IFR_DISABLE_IF and EFI_IFR_END
955 //
956 if (Operand == EFI_IFR_DISABLE_IF_OP) {
957 DepthOfDisable++;
958 } else if (Operand == EFI_IFR_END_OP) {
959 Status = PopScope (&ScopeOpCode);
960 if (EFI_ERROR (Status)) {
961 return Status;
962 }
963
964 if (ScopeOpCode == EFI_IFR_DISABLE_IF_OP) {
965 if (DepthOfDisable == 0) {
966 mInScopeDisable = FALSE;
967 OpCodeDisabled = FALSE;
968 } else {
969 DepthOfDisable--;
970 }
971 }
972 }
973 continue;
974 }
975
976 if (IsExpressionOpCode (Operand)) {
977 ExpressionOpCode = &FormSet->ExpressionBuffer[mExpressionOpCodeIndex];
978 mExpressionOpCodeIndex++;
979
980 ExpressionOpCode->Signature = EXPRESSION_OPCODE_SIGNATURE;
981 ExpressionOpCode->Operand = Operand;
982 Value = &ExpressionOpCode->Value;
983
984 switch (Operand) {
985 case EFI_IFR_EQ_ID_VAL_OP:
986 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_VAL *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
987
988 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
989 CopyMem (&Value->Value.u16, &((EFI_IFR_EQ_ID_VAL *) OpCodeData)->Value, sizeof (UINT16));
990 break;
991
992 case EFI_IFR_EQ_ID_ID_OP:
993 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_ID *) OpCodeData)->QuestionId1, sizeof (EFI_QUESTION_ID));
994 CopyMem (&ExpressionOpCode->QuestionId2, &((EFI_IFR_EQ_ID_ID *) OpCodeData)->QuestionId2, sizeof (EFI_QUESTION_ID));
995 break;
996
997 case EFI_IFR_EQ_ID_LIST_OP:
998 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_VAL_LIST *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
999 CopyMem (&ExpressionOpCode->ListLength, &((EFI_IFR_EQ_ID_VAL_LIST *) OpCodeData)->ListLength, sizeof (UINT16));
1000 ExpressionOpCode->ValueList = AllocateCopyPool (ExpressionOpCode->ListLength * sizeof (UINT16), &((EFI_IFR_EQ_ID_VAL_LIST *) OpCodeData)->ValueList);
1001 break;
1002
1003 case EFI_IFR_TO_STRING_OP:
1004 case EFI_IFR_FIND_OP:
1005 ExpressionOpCode->Format = (( EFI_IFR_TO_STRING *) OpCodeData)->Format;
1006 break;
1007
1008 case EFI_IFR_STRING_REF1_OP:
1009 Value->Type = EFI_IFR_TYPE_STRING;
1010 CopyMem (&Value->Value.string, &(( EFI_IFR_STRING_REF1 *) OpCodeData)->StringId, sizeof (EFI_STRING_ID));
1011 break;
1012
1013 case EFI_IFR_RULE_REF_OP:
1014 ExpressionOpCode->RuleId = (( EFI_IFR_RULE_REF *) OpCodeData)->RuleId;
1015 break;
1016
1017 case EFI_IFR_SPAN_OP:
1018 ExpressionOpCode->Flags = (( EFI_IFR_SPAN *) OpCodeData)->Flags;
1019 break;
1020
1021 case EFI_IFR_THIS_OP:
1022 ASSERT (CurrentStatement != NULL);
1023 ExpressionOpCode->QuestionId = CurrentStatement->QuestionId;
1024 break;
1025
1026 case EFI_IFR_SECURITY_OP:
1027 CopyMem (&ExpressionOpCode->Guid, &((EFI_IFR_SECURITY *) OpCodeData)->Permissions, sizeof (EFI_GUID));
1028 break;
1029
1030 case EFI_IFR_GET_OP:
1031 case EFI_IFR_SET_OP:
1032 CopyMem (&TempVarstoreId, &((EFI_IFR_GET *) OpCodeData)->VarStoreId, sizeof (TempVarstoreId));
1033 if (TempVarstoreId != 0) {
1034 if (FormSet->StorageListHead.ForwardLink != NULL) {
1035 Link = GetFirstNode (&FormSet->StorageListHead);
1036 while (!IsNull (&FormSet->StorageListHead, Link)) {
1037 VarStorage = FORMSET_STORAGE_FROM_LINK (Link);
1038 if (VarStorage->VarStoreId == ((EFI_IFR_GET *) OpCodeData)->VarStoreId) {
1039 ExpressionOpCode->VarStorage = VarStorage;
1040 break;
1041 }
1042 Link = GetNextNode (&FormSet->StorageListHead, Link);
1043 }
1044 }
1045 if (ExpressionOpCode->VarStorage == NULL) {
1046 //
1047 // VarStorage is not found.
1048 //
1049 return EFI_INVALID_PARAMETER;
1050 }
1051 }
1052 ExpressionOpCode->ValueType = ((EFI_IFR_GET *) OpCodeData)->VarStoreType;
1053 switch (ExpressionOpCode->ValueType) {
1054 case EFI_IFR_TYPE_BOOLEAN:
1055 case EFI_IFR_TYPE_NUM_SIZE_8:
1056 ExpressionOpCode->ValueWidth = 1;
1057 break;
1058
1059 case EFI_IFR_TYPE_NUM_SIZE_16:
1060 case EFI_IFR_TYPE_STRING:
1061 ExpressionOpCode->ValueWidth = 2;
1062 break;
1063
1064 case EFI_IFR_TYPE_NUM_SIZE_32:
1065 ExpressionOpCode->ValueWidth = 4;
1066 break;
1067
1068 case EFI_IFR_TYPE_NUM_SIZE_64:
1069 ExpressionOpCode->ValueWidth = 8;
1070 break;
1071
1072 case EFI_IFR_TYPE_DATE:
1073 ExpressionOpCode->ValueWidth = (UINT8) sizeof (EFI_IFR_DATE);
1074 break;
1075
1076 case EFI_IFR_TYPE_TIME:
1077 ExpressionOpCode->ValueWidth = (UINT8) sizeof (EFI_IFR_TIME);
1078 break;
1079
1080 case EFI_IFR_TYPE_OTHER:
1081 case EFI_IFR_TYPE_UNDEFINED:
1082 case EFI_IFR_TYPE_ACTION:
1083 case EFI_IFR_TYPE_BUFFER:
1084 default:
1085 //
1086 // Invalid value type for Get/Set opcode.
1087 //
1088 return EFI_INVALID_PARAMETER;
1089 }
1090 CopyMem (&ExpressionOpCode->VarStoreInfo.VarName, &((EFI_IFR_GET *) OpCodeData)->VarStoreInfo.VarName, sizeof (EFI_STRING_ID));
1091 CopyMem (&ExpressionOpCode->VarStoreInfo.VarOffset, &((EFI_IFR_GET *) OpCodeData)->VarStoreInfo.VarOffset, sizeof (UINT16));
1092 if ((ExpressionOpCode->VarStorage != NULL) &&
1093 (ExpressionOpCode->VarStorage->Type == EFI_HII_VARSTORE_NAME_VALUE ||
1094 ExpressionOpCode->VarStorage->Type == EFI_HII_VARSTORE_EFI_VARIABLE)) {
1095 ExpressionOpCode->ValueName = GetToken (ExpressionOpCode->VarStoreInfo.VarName, FormSet->HiiHandle);
1096 if (ExpressionOpCode->ValueName == NULL) {
1097 //
1098 // String ID is invalid.
1099 //
1100 return EFI_INVALID_PARAMETER;
1101 }
1102 }
1103 break;
1104
1105 case EFI_IFR_QUESTION_REF1_OP:
1106 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_VAL_LIST *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
1107 break;
1108
1109 case EFI_IFR_QUESTION_REF3_OP:
1110 if (OpCodeLength >= sizeof (EFI_IFR_QUESTION_REF3_2)) {
1111 CopyMem (&ExpressionOpCode->DevicePath, &(( EFI_IFR_QUESTION_REF3_2 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
1112
1113 if (OpCodeLength >= sizeof (EFI_IFR_QUESTION_REF3_3)) {
1114 CopyMem (&ExpressionOpCode->Guid, &(( EFI_IFR_QUESTION_REF3_3 *) OpCodeData)->Guid, sizeof (EFI_GUID));
1115 }
1116 }
1117 break;
1118
1119 //
1120 // constant
1121 //
1122 case EFI_IFR_TRUE_OP:
1123 Value->Type = EFI_IFR_TYPE_BOOLEAN;
1124 Value->Value.b = TRUE;
1125 break;
1126
1127 case EFI_IFR_FALSE_OP:
1128 Value->Type = EFI_IFR_TYPE_BOOLEAN;
1129 Value->Value.b = FALSE;
1130 break;
1131
1132 case EFI_IFR_ONE_OP:
1133 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1134 Value->Value.u8 = 1;
1135 break;
1136
1137 case EFI_IFR_ZERO_OP:
1138 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1139 Value->Value.u8 = 0;
1140 break;
1141
1142 case EFI_IFR_ONES_OP:
1143 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
1144 Value->Value.u64 = 0xffffffffffffffffULL;
1145 break;
1146
1147 case EFI_IFR_UINT8_OP:
1148 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1149 Value->Value.u8 = (( EFI_IFR_UINT8 *) OpCodeData)->Value;
1150 break;
1151
1152 case EFI_IFR_UINT16_OP:
1153 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
1154 CopyMem (&Value->Value.u16, &(( EFI_IFR_UINT16 *) OpCodeData)->Value, sizeof (UINT16));
1155 break;
1156
1157 case EFI_IFR_UINT32_OP:
1158 Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
1159 CopyMem (&Value->Value.u32, &(( EFI_IFR_UINT32 *) OpCodeData)->Value, sizeof (UINT32));
1160 break;
1161
1162 case EFI_IFR_UINT64_OP:
1163 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
1164 CopyMem (&Value->Value.u64, &(( EFI_IFR_UINT64 *) OpCodeData)->Value, sizeof (UINT64));
1165 break;
1166
1167 case EFI_IFR_UNDEFINED_OP:
1168 Value->Type = EFI_IFR_TYPE_UNDEFINED;
1169 break;
1170
1171 case EFI_IFR_VERSION_OP:
1172 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
1173 Value->Value.u16 = EFI_IFR_SPECIFICATION_VERSION;
1174 break;
1175
1176 default:
1177 break;
1178 }
1179 //
1180 // Create sub expression nested in MAP opcode
1181 //
1182 if (CurrentExpression == NULL && MapScopeDepth > 0) {
1183 CurrentExpression = CreateExpression (CurrentForm);
1184 ASSERT (MapExpressionList != NULL);
1185 InsertTailList (MapExpressionList, &CurrentExpression->Link);
1186 if (Scope == 0) {
1187 SingleOpCodeExpression = TRUE;
1188 }
1189 }
1190 ASSERT (CurrentExpression != NULL);
1191 InsertTailList (&CurrentExpression->OpCodeListHead, &ExpressionOpCode->Link);
1192 if (Operand == EFI_IFR_MAP_OP) {
1193 //
1194 // Store current Map Expression List.
1195 //
1196 if (MapExpressionList != NULL) {
1197 PushMapExpressionList (MapExpressionList);
1198 }
1199 //
1200 // Initialize new Map Expression List.
1201 //
1202 MapExpressionList = &ExpressionOpCode->MapExpressionList;
1203 InitializeListHead (MapExpressionList);
1204 //
1205 // Store current expression.
1206 //
1207 PushCurrentExpression (CurrentExpression);
1208 CurrentExpression = NULL;
1209 MapScopeDepth ++;
1210 } else if (SingleOpCodeExpression) {
1211 //
1212 // There are two cases to indicate the end of an Expression:
1213 // for single OpCode expression: one Expression OpCode
1214 // for expression consists of more than one OpCode: EFI_IFR_END
1215 //
1216 SingleOpCodeExpression = FALSE;
1217
1218 if (mInScopeDisable && CurrentForm == NULL) {
1219 //
1220 // This is DisableIf expression for Form, it should be a constant expression
1221 //
1222 Status = EvaluateExpression (FormSet, CurrentForm, CurrentExpression);
1223 if (EFI_ERROR (Status)) {
1224 return Status;
1225 }
1226
1227 if (CurrentExpression->Result.Type != EFI_IFR_TYPE_BOOLEAN) {
1228 return EFI_INVALID_PARAMETER;
1229 }
1230
1231 OpCodeDisabled = CurrentExpression->Result.Value.b;
1232 }
1233
1234 CurrentExpression = NULL;
1235 }
1236
1237 continue;
1238 }
1239
1240 //
1241 // Parse the Opcode
1242 //
1243 switch (Operand) {
1244
1245 case EFI_IFR_FORM_SET_OP:
1246 //
1247 // Check the formset GUID
1248 //
1249 if (CompareMem (&FormSet->Guid, &((EFI_IFR_FORM_SET *) OpCodeData)->Guid, sizeof (EFI_GUID)) != 0) {
1250 return EFI_INVALID_PARAMETER;
1251 }
1252
1253 CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
1254 CopyMem (&FormSet->Help, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
1255
1256 if (OpCodeLength > OFFSET_OF (EFI_IFR_FORM_SET, Flags)) {
1257 //
1258 // The formset OpCode contains ClassGuid
1259 //
1260 FormSet->NumberOfClassGuid = (UINT8) (((EFI_IFR_FORM_SET *) OpCodeData)->Flags & 0x3);
1261 CopyMem (FormSet->ClassGuid, OpCodeData + sizeof (EFI_IFR_FORM_SET), FormSet->NumberOfClassGuid * sizeof (EFI_GUID));
1262 }
1263
1264 InitializeListHead (&FormSet->ExpressionListHead);
1265 break;
1266
1267 case EFI_IFR_FORM_OP:
1268 //
1269 // Create a new Form for this FormSet
1270 //
1271 CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
1272 ASSERT (CurrentForm != NULL);
1273 CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
1274 InitializeListHead (&CurrentForm->ExpressionListHead);
1275 InitializeListHead (&CurrentForm->StatementListHead);
1276
1277 CurrentForm->FormType = STANDARD_MAP_FORM_TYPE;
1278 CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16));
1279 CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID));
1280
1281 if (InScopeFormSuppress) {
1282 //
1283 // Form is inside of suppressif
1284 //
1285 CurrentForm->SuppressExpression = FormSuppressExpression;
1286 }
1287
1288 if (Scope != 0) {
1289 //
1290 // Enter scope of a Form, suppressif will be used for Question or Option
1291 //
1292 SuppressForQuestion = TRUE;
1293 }
1294
1295 //
1296 // Insert into Form list of this FormSet
1297 //
1298 InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
1299 break;
1300
1301 case EFI_IFR_FORM_MAP_OP:
1302 //
1303 // Create a new Form for this FormSet
1304 //
1305 CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
1306 ASSERT (CurrentForm != NULL);
1307 CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
1308 InitializeListHead (&CurrentForm->ExpressionListHead);
1309 InitializeListHead (&CurrentForm->StatementListHead);
1310 CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16));
1311
1312 MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP));
1313 //
1314 // FormMap Form must contain at least one Map Method.
1315 //
1316 if (((EFI_IFR_OP_HEADER *) OpCodeData)->Length < ((UINTN) (UINT8 *) (MapMethod + 1) - (UINTN) OpCodeData)) {
1317 return EFI_INVALID_PARAMETER;
1318 }
1319 //
1320 // Try to find the standard form map method.
1321 //
1322 while (((UINTN) (UINT8 *) MapMethod - (UINTN) OpCodeData) < ((EFI_IFR_OP_HEADER *) OpCodeData)->Length) {
1323 if (CompareGuid ((EFI_GUID *) (VOID *) &MapMethod->MethodIdentifier, &gEfiHiiStandardFormGuid)) {
1324 CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID));
1325 CurrentForm->FormType = STANDARD_MAP_FORM_TYPE;
1326 break;
1327 }
1328 MapMethod ++;
1329 }
1330 //
1331 // If the standard form map method is not found, the first map method title will be used.
1332 //
1333 if (CurrentForm->FormTitle == 0) {
1334 MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP));
1335 CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID));
1336 }
1337
1338 if (InScopeFormSuppress) {
1339 //
1340 // Form is inside of suppressif
1341 //
1342 CurrentForm->SuppressExpression = FormSuppressExpression;
1343 }
1344
1345 if (Scope != 0) {
1346 //
1347 // Enter scope of a Form, suppressif will be used for Question or Option
1348 //
1349 SuppressForQuestion = TRUE;
1350 }
1351
1352 //
1353 // Insert into Form list of this FormSet
1354 //
1355 InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
1356 break;
1357
1358 //
1359 // Storage
1360 //
1361 case EFI_IFR_VARSTORE_OP:
1362 //
1363 // Create a buffer Storage for this FormSet
1364 //
1365 Storage = CreateStorage (FormSet);
1366 Storage->Type = EFI_HII_VARSTORE_BUFFER;
1367
1368 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
1369 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE *) OpCodeData)->Guid, sizeof (EFI_GUID));
1370 CopyMem (&Storage->Size, &((EFI_IFR_VARSTORE *) OpCodeData)->Size, sizeof (UINT16));
1371
1372 Storage->Buffer = AllocateZeroPool (Storage->Size);
1373 Storage->EditBuffer = AllocateZeroPool (Storage->Size);
1374
1375 AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name;
1376 Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2);
1377 ASSERT (Storage->Name != NULL);
1378 for (Index = 0; AsciiString[Index] != 0; Index++) {
1379 Storage->Name[Index] = (CHAR16) AsciiString[Index];
1380 }
1381
1382 //
1383 // Initialize <ConfigHdr>
1384 //
1385 InitializeConfigHdr (FormSet, Storage);
1386 break;
1387
1388 case EFI_IFR_VARSTORE_NAME_VALUE_OP:
1389 //
1390 // Create a name/value Storage for this FormSet
1391 //
1392 Storage = CreateStorage (FormSet);
1393 Storage->Type = EFI_HII_VARSTORE_NAME_VALUE;
1394
1395 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
1396 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->Guid, sizeof (EFI_GUID));
1397
1398 //
1399 // Initialize <ConfigHdr>
1400 //
1401 InitializeConfigHdr (FormSet, Storage);
1402 break;
1403
1404 case EFI_IFR_VARSTORE_EFI_OP:
1405 //
1406 // Create a EFI variable Storage for this FormSet
1407 //
1408 Storage = CreateStorage (FormSet);
1409 Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE;
1410
1411 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
1412 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid, sizeof (EFI_GUID));
1413 CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32));
1414 break;
1415
1416 //
1417 // DefaultStore
1418 //
1419 case EFI_IFR_DEFAULTSTORE_OP:
1420 DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE));
1421 ASSERT (DefaultStore != NULL);
1422 DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE;
1423
1424 CopyMem (&DefaultStore->DefaultId, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId, sizeof (UINT16));
1425 CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID));
1426
1427 //
1428 // Insert to DefaultStore list of this Formset
1429 //
1430 InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link);
1431 break;
1432
1433 //
1434 // Statements
1435 //
1436 case EFI_IFR_SUBTITLE_OP:
1437 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
1438 ASSERT (CurrentStatement != NULL);
1439
1440 CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags;
1441
1442 if (Scope != 0) {
1443 mInScopeSubtitle = TRUE;
1444 }
1445 break;
1446
1447 case EFI_IFR_TEXT_OP:
1448 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
1449 ASSERT (CurrentStatement != NULL);
1450
1451 CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID));
1452 break;
1453
1454 case EFI_IFR_RESET_BUTTON_OP:
1455 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
1456 ASSERT (CurrentStatement != NULL);
1457 CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID));
1458 break;
1459
1460 //
1461 // Questions
1462 //
1463 case EFI_IFR_ACTION_OP:
1464 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1465 ASSERT (CurrentStatement != NULL);
1466 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_ACTION;
1467
1468 if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) {
1469 //
1470 // No QuestionConfig present, so no configuration string will be processed
1471 //
1472 CurrentStatement->QuestionConfig = 0;
1473 } else {
1474 CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID));
1475 }
1476 break;
1477
1478 case EFI_IFR_REF_OP:
1479 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1480 ASSERT (CurrentStatement != NULL);
1481 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_UNDEFINED;
1482 CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID));
1483 if (OpCodeLength >= sizeof (EFI_IFR_REF2)) {
1484 CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
1485
1486 if (OpCodeLength >= sizeof (EFI_IFR_REF3)) {
1487 CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID));
1488
1489 if (OpCodeLength >= sizeof (EFI_IFR_REF4)) {
1490 CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
1491 }
1492 }
1493 }
1494 break;
1495
1496 case EFI_IFR_ONE_OF_OP:
1497 case EFI_IFR_NUMERIC_OP:
1498 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1499 ASSERT(CurrentStatement != NULL);
1500
1501 CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags;
1502 Value = &CurrentStatement->HiiValue;
1503
1504 switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) {
1505 case EFI_IFR_NUMERIC_SIZE_1:
1506 CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue;
1507 CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue;
1508 CurrentStatement->Step = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step;
1509 CurrentStatement->StorageWidth = (UINT16) sizeof (UINT8);
1510 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1511 break;
1512
1513 case EFI_IFR_NUMERIC_SIZE_2:
1514 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16));
1515 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16));
1516 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step, sizeof (UINT16));
1517 CurrentStatement->StorageWidth = (UINT16) sizeof (UINT16);
1518 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
1519 break;
1520
1521 case EFI_IFR_NUMERIC_SIZE_4:
1522 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32));
1523 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32));
1524 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step, sizeof (UINT32));
1525 CurrentStatement->StorageWidth = (UINT16) sizeof (UINT32);
1526 Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
1527 break;
1528
1529 case EFI_IFR_NUMERIC_SIZE_8:
1530 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64));
1531 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64));
1532 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step, sizeof (UINT64));
1533 CurrentStatement->StorageWidth = (UINT16) sizeof (UINT64);
1534 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
1535 break;
1536
1537 default:
1538 break;
1539 }
1540
1541 InitializeRequestElement (FormSet, CurrentStatement);
1542
1543 if ((Operand == EFI_IFR_ONE_OF_OP) && Scope != 0) {
1544 SuppressForOption = TRUE;
1545 }
1546 break;
1547
1548 case EFI_IFR_ORDERED_LIST_OP:
1549 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1550 ASSERT(CurrentStatement != NULL);
1551
1552 CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags;
1553 CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers;
1554
1555 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BUFFER;
1556 CurrentStatement->BufferValue = NULL;
1557
1558 if (Scope != 0) {
1559 SuppressForOption = TRUE;
1560 }
1561 break;
1562
1563 case EFI_IFR_CHECKBOX_OP:
1564 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1565 ASSERT(CurrentStatement != NULL);
1566
1567 CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags;
1568 CurrentStatement->StorageWidth = (UINT16) sizeof (BOOLEAN);
1569 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN;
1570
1571 InitializeRequestElement (FormSet, CurrentStatement);
1572
1573 break;
1574
1575 case EFI_IFR_STRING_OP:
1576 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1577 ASSERT (CurrentStatement != NULL);
1578 //
1579 // MinSize is the minimum number of characters that can be accepted for this opcode,
1580 // MaxSize is the maximum number of characters that can be accepted for this opcode.
1581 // The characters are stored as Unicode, so the storage width should multiply 2.
1582 //
1583 CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize;
1584 CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize;
1585 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (CHAR16));
1586 CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags;
1587
1588 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
1589 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth + sizeof (CHAR16));
1590 CurrentStatement->HiiValue.Value.string = NewString ((CHAR16*) CurrentStatement->BufferValue, FormSet->HiiHandle);
1591
1592 InitializeRequestElement (FormSet, CurrentStatement);
1593 break;
1594
1595 case EFI_IFR_PASSWORD_OP:
1596 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1597 ASSERT (CurrentStatement != NULL);
1598 //
1599 // MinSize is the minimum number of characters that can be accepted for this opcode,
1600 // MaxSize is the maximum number of characters that can be accepted for this opcode.
1601 // The characters are stored as Unicode, so the storage width should multiply 2.
1602 //
1603 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16));
1604 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16));
1605 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (CHAR16));
1606
1607 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
1608 CurrentStatement->BufferValue = AllocateZeroPool ((CurrentStatement->StorageWidth + sizeof (CHAR16)));
1609 CurrentStatement->HiiValue.Value.string = NewString ((CHAR16*) CurrentStatement->BufferValue, FormSet->HiiHandle);
1610
1611 InitializeRequestElement (FormSet, CurrentStatement);
1612 break;
1613
1614 case EFI_IFR_DATE_OP:
1615 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1616 ASSERT(CurrentStatement != NULL);
1617
1618 CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags;
1619 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE;
1620
1621 if ((CurrentStatement->Flags & EFI_QF_DATE_STORAGE) == QF_DATE_STORAGE_NORMAL) {
1622 CurrentStatement->StorageWidth = (UINT16) sizeof (EFI_HII_DATE);
1623
1624 InitializeRequestElement (FormSet, CurrentStatement);
1625 } else {
1626 //
1627 // Don't assign storage for RTC type of date/time
1628 //
1629 CurrentStatement->Storage = NULL;
1630 CurrentStatement->StorageWidth = 0;
1631 }
1632 break;
1633
1634 case EFI_IFR_TIME_OP:
1635 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1636 ASSERT(CurrentStatement != NULL);
1637
1638 CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags;
1639 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME;
1640
1641 if ((CurrentStatement->Flags & QF_TIME_STORAGE) == QF_TIME_STORAGE_NORMAL) {
1642 CurrentStatement->StorageWidth = (UINT16) sizeof (EFI_IFR_TIME);
1643
1644 InitializeRequestElement (FormSet, CurrentStatement);
1645 } else {
1646 //
1647 // Don't assign storage for RTC type of date/time
1648 //
1649 CurrentStatement->Storage = NULL;
1650 CurrentStatement->StorageWidth = 0;
1651 }
1652 break;
1653
1654 //
1655 // Default
1656 //
1657 case EFI_IFR_DEFAULT_OP:
1658 //
1659 // EFI_IFR_DEFAULT appear in scope of a Question,
1660 // It creates a default value for the current question.
1661 // A Question may have more than one Default value which have different default types.
1662 //
1663 CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT));
1664 ASSERT (CurrentDefault != NULL);
1665 CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE;
1666
1667 CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type;
1668 CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16));
1669 CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
1670 ExtendValueToU64 (&CurrentDefault->Value);
1671
1672 //
1673 // Insert to Default Value list of current Question
1674 //
1675 InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link);
1676
1677 if (Scope != 0) {
1678 InScopeDefault = TRUE;
1679 }
1680 break;
1681
1682 //
1683 // Option
1684 //
1685 case EFI_IFR_ONE_OF_OPTION_OP:
1686 //
1687 // EFI_IFR_ONE_OF_OPTION appear in scope of a Question.
1688 // It create a selection for use in current Question.
1689 //
1690 CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION));
1691 ASSERT (CurrentOption != NULL);
1692 CurrentOption->Signature = QUESTION_OPTION_SIGNATURE;
1693
1694 CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags;
1695 CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type;
1696 CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID));
1697 CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
1698 ExtendValueToU64 (&CurrentOption->Value);
1699
1700 if (InScopeOptionSuppress) {
1701 CurrentOption->SuppressExpression = OptionSuppressExpression;
1702 }
1703
1704 //
1705 // Insert to Option list of current Question
1706 //
1707 InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link);
1708
1709 //
1710 // Now we know the Storage width of nested Ordered List
1711 //
1712 ASSERT (CurrentStatement != NULL);
1713 if ((CurrentStatement->Operand == EFI_IFR_ORDERED_LIST_OP) && (CurrentStatement->BufferValue == NULL)) {
1714 Width = 1;
1715 switch (CurrentOption->Value.Type) {
1716 case EFI_IFR_TYPE_NUM_SIZE_8:
1717 Width = 1;
1718 break;
1719
1720 case EFI_IFR_TYPE_NUM_SIZE_16:
1721 Width = 2;
1722 break;
1723
1724 case EFI_IFR_TYPE_NUM_SIZE_32:
1725 Width = 4;
1726 break;
1727
1728 case EFI_IFR_TYPE_NUM_SIZE_64:
1729 Width = 8;
1730 break;
1731
1732 default:
1733 //
1734 // Invalid type for Ordered List
1735 //
1736 break;
1737 }
1738
1739 CurrentStatement->StorageWidth = (UINT16) (CurrentStatement->MaxContainers * Width);
1740 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
1741 CurrentStatement->ValueType = CurrentOption->Value.Type;
1742
1743 InitializeRequestElement (FormSet, CurrentStatement);
1744 }
1745 break;
1746
1747 //
1748 // Conditional
1749 //
1750 case EFI_IFR_NO_SUBMIT_IF_OP:
1751 case EFI_IFR_INCONSISTENT_IF_OP:
1752 //
1753 // Create an Expression node
1754 //
1755 CurrentExpression = CreateExpression (CurrentForm);
1756 CopyMem (&CurrentExpression->Error, &((EFI_IFR_INCONSISTENT_IF *) OpCodeData)->Error, sizeof (EFI_STRING_ID));
1757
1758 if (Operand == EFI_IFR_NO_SUBMIT_IF_OP) {
1759 CurrentExpression->Type = EFI_HII_EXPRESSION_NO_SUBMIT_IF;
1760 InsertTailList (&CurrentStatement->NoSubmitListHead, &CurrentExpression->Link);
1761 } else {
1762 CurrentExpression->Type = EFI_HII_EXPRESSION_INCONSISTENT_IF;
1763 InsertTailList (&CurrentStatement->InconsistentListHead, &CurrentExpression->Link);
1764 }
1765
1766 //
1767 // Take a look at next OpCode to see whether current expression consists
1768 // of single OpCode
1769 //
1770 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1771 SingleOpCodeExpression = TRUE;
1772 }
1773 break;
1774
1775 case EFI_IFR_SUPPRESS_IF_OP:
1776 //
1777 // Question and Option will appear in scope of this OpCode
1778 //
1779 CurrentExpression = CreateExpression (CurrentForm);
1780 CurrentExpression->Type = EFI_HII_EXPRESSION_SUPPRESS_IF;
1781
1782 if (CurrentForm == NULL) {
1783 InsertTailList (&FormSet->ExpressionListHead, &CurrentExpression->Link);
1784 } else {
1785 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1786 }
1787
1788 if (SuppressForOption) {
1789 InScopeOptionSuppress = TRUE;
1790 OptionSuppressExpression = CurrentExpression;
1791 } else if (SuppressForQuestion) {
1792 mInScopeSuppress = TRUE;
1793 mSuppressExpression = CurrentExpression;
1794 } else {
1795 InScopeFormSuppress = TRUE;
1796 FormSuppressExpression = CurrentExpression;
1797 }
1798
1799 //
1800 // Take a look at next OpCode to see whether current expression consists
1801 // of single OpCode
1802 //
1803 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1804 SingleOpCodeExpression = TRUE;
1805 }
1806 break;
1807
1808 case EFI_IFR_GRAY_OUT_IF_OP:
1809 //
1810 // Questions will appear in scope of this OpCode
1811 //
1812 CurrentExpression = CreateExpression (CurrentForm);
1813 CurrentExpression->Type = EFI_HII_EXPRESSION_GRAY_OUT_IF;
1814 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1815
1816 mInScopeGrayOut = TRUE;
1817 mGrayOutExpression = CurrentExpression;
1818
1819 //
1820 // Take a look at next OpCode to see whether current expression consists
1821 // of single OpCode
1822 //
1823 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1824 SingleOpCodeExpression = TRUE;
1825 }
1826 break;
1827
1828 case EFI_IFR_DISABLE_IF_OP:
1829 //
1830 // The DisableIf expression should only rely on constant, so it could be
1831 // evaluated at initialization and it will not be queued
1832 //
1833 CurrentExpression = AllocateZeroPool (sizeof (FORM_EXPRESSION));
1834 ASSERT (CurrentExpression != NULL);
1835 CurrentExpression->Signature = FORM_EXPRESSION_SIGNATURE;
1836 CurrentExpression->Type = EFI_HII_EXPRESSION_DISABLE_IF;
1837 InitializeListHead (&CurrentExpression->OpCodeListHead);
1838
1839 if (CurrentForm != NULL) {
1840 //
1841 // This is DisableIf for Question, enqueue it to Form expression list
1842 //
1843 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1844 }
1845
1846 mDisableExpression = CurrentExpression;
1847 mInScopeDisable = TRUE;
1848 OpCodeDisabled = FALSE;
1849
1850 //
1851 // Take a look at next OpCode to see whether current expression consists
1852 // of single OpCode
1853 //
1854 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1855 SingleOpCodeExpression = TRUE;
1856 }
1857 break;
1858
1859 //
1860 // Expression
1861 //
1862 case EFI_IFR_VALUE_OP:
1863 CurrentExpression = CreateExpression (CurrentForm);
1864 CurrentExpression->Type = EFI_HII_EXPRESSION_VALUE;
1865 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1866
1867 if (InScopeDefault) {
1868 //
1869 // Used for default (EFI_IFR_DEFAULT)
1870 //
1871 CurrentDefault->ValueExpression = CurrentExpression;
1872 } else {
1873 //
1874 // If used for a question, then the question will be read-only
1875 //
1876 //
1877 // Make sure CurrentStatement is not NULL.
1878 // If it is NULL, 1) ParseOpCodes functions may parse the IFR wrongly. Or 2) the IFR
1879 // file is wrongly generated by tools such as VFR Compiler. There may be a bug in VFR Compiler.
1880 //
1881 ASSERT (CurrentStatement != NULL);
1882 CurrentStatement->ValueExpression = CurrentExpression;
1883 }
1884
1885 //
1886 // Take a look at next OpCode to see whether current expression consists
1887 // of single OpCode
1888 //
1889 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1890 SingleOpCodeExpression = TRUE;
1891 }
1892 break;
1893
1894 case EFI_IFR_RULE_OP:
1895 CurrentExpression = CreateExpression (CurrentForm);
1896 CurrentExpression->Type = EFI_HII_EXPRESSION_RULE;
1897
1898 CurrentExpression->RuleId = ((EFI_IFR_RULE *) OpCodeData)->RuleId;
1899 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1900
1901 //
1902 // Take a look at next OpCode to see whether current expression consists
1903 // of single OpCode
1904 //
1905 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1906 SingleOpCodeExpression = TRUE;
1907 }
1908 break;
1909
1910 case EFI_IFR_READ_OP:
1911 CurrentExpression = CreateExpression (CurrentForm);
1912 CurrentExpression->Type = EFI_HII_EXPRESSION_READ;
1913 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1914
1915 //
1916 // Make sure CurrentStatement is not NULL.
1917 // If it is NULL, 1) ParseOpCodes functions may parse the IFR wrongly. Or 2) the IFR
1918 // file is wrongly generated by tools such as VFR Compiler. There may be a bug in VFR Compiler.
1919 //
1920 ASSERT (CurrentStatement != NULL);
1921 CurrentStatement->ReadExpression = CurrentExpression;
1922
1923 //
1924 // Take a look at next OpCode to see whether current expression consists
1925 // of single OpCode
1926 //
1927 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1928 SingleOpCodeExpression = TRUE;
1929 }
1930 break;
1931
1932 case EFI_IFR_WRITE_OP:
1933 CurrentExpression = CreateExpression (CurrentForm);
1934 CurrentExpression->Type = EFI_HII_EXPRESSION_WRITE;
1935 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1936
1937 //
1938 // Make sure CurrentStatement is not NULL.
1939 // If it is NULL, 1) ParseOpCodes functions may parse the IFR wrongly. Or 2) the IFR
1940 // file is wrongly generated by tools such as VFR Compiler. There may be a bug in VFR Compiler.
1941 //
1942 ASSERT (CurrentStatement != NULL);
1943 CurrentStatement->WriteExpression = CurrentExpression;
1944
1945 //
1946 // Take a look at next OpCode to see whether current expression consists
1947 // of single OpCode
1948 //
1949 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1950 SingleOpCodeExpression = TRUE;
1951 }
1952 break;
1953
1954 //
1955 // Image
1956 //
1957 case EFI_IFR_IMAGE_OP:
1958 //
1959 // Get ScopeOpcode from top of stack
1960 //
1961 PopScope (&ScopeOpCode);
1962 PushScope (ScopeOpCode);
1963
1964 switch (ScopeOpCode) {
1965 case EFI_IFR_FORM_SET_OP:
1966 ImageId = &FormSet->ImageId;
1967 break;
1968
1969 case EFI_IFR_FORM_OP:
1970 case EFI_IFR_FORM_MAP_OP:
1971 ASSERT (CurrentForm != NULL);
1972 ImageId = &CurrentForm->ImageId;
1973 break;
1974
1975 case EFI_IFR_ONE_OF_OPTION_OP:
1976 ImageId = &CurrentOption->ImageId;
1977 break;
1978
1979 default:
1980 //
1981 // Make sure CurrentStatement is not NULL.
1982 // If it is NULL, 1) ParseOpCodes functions may parse the IFR wrongly. Or 2) the IFR
1983 // file is wrongly generated by tools such as VFR Compiler.
1984 //
1985 ASSERT (CurrentStatement != NULL);
1986 ImageId = &CurrentStatement->ImageId;
1987 break;
1988 }
1989
1990 ASSERT (ImageId != NULL);
1991 CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID));
1992 break;
1993
1994 //
1995 // Refresh
1996 //
1997 case EFI_IFR_REFRESH_OP:
1998 ASSERT (CurrentStatement != NULL);
1999 CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval;
2000 break;
2001
2002 //
2003 // Vendor specific
2004 //
2005 case EFI_IFR_GUID_OP:
2006 if (CompareGuid (&gEfiIfrTianoGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
2007 //
2008 // Tiano specific GUIDed opcodes
2009 //
2010 switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) {
2011 case EFI_IFR_EXTEND_OP_LABEL:
2012 //
2013 // just ignore label
2014 //
2015 break;
2016
2017 case EFI_IFR_EXTEND_OP_BANNER:
2018 //
2019 // By SubClass to get Banner Data from Front Page
2020 //
2021 if (FormSet->SubClass == EFI_FRONT_PAGE_SUBCLASS) {
2022 CopyMem (
2023 &gBannerData->Banner[((EFI_IFR_GUID_BANNER *) OpCodeData)->LineNumber][
2024 ((EFI_IFR_GUID_BANNER *) OpCodeData)->Alignment],
2025 &((EFI_IFR_GUID_BANNER *) OpCodeData)->Title,
2026 sizeof (EFI_STRING_ID)
2027 );
2028 }
2029 break;
2030
2031 case EFI_IFR_EXTEND_OP_CLASS:
2032 CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16));
2033 break;
2034
2035 case EFI_IFR_EXTEND_OP_SUBCLASS:
2036 CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16));
2037 break;
2038
2039 default:
2040 break;
2041 }
2042 }
2043
2044 break;
2045
2046 //
2047 // Scope End
2048 //
2049 case EFI_IFR_END_OP:
2050 Status = PopScope (&ScopeOpCode);
2051 if (EFI_ERROR (Status)) {
2052 ResetScopeStack ();
2053 return Status;
2054 }
2055
2056 switch (ScopeOpCode) {
2057 case EFI_IFR_FORM_SET_OP:
2058 //
2059 // End of FormSet, update FormSet IFR binary length
2060 // to stop parsing substantial OpCodes
2061 //
2062 FormSet->IfrBinaryLength = OpCodeOffset;
2063 break;
2064
2065 case EFI_IFR_FORM_OP:
2066 case EFI_IFR_FORM_MAP_OP:
2067 //
2068 // End of Form
2069 //
2070 CurrentForm = NULL;
2071 SuppressForQuestion = FALSE;
2072 break;
2073
2074 case EFI_IFR_ONE_OF_OPTION_OP:
2075 //
2076 // End of Option
2077 //
2078 CurrentOption = NULL;
2079 break;
2080
2081 case EFI_IFR_SUBTITLE_OP:
2082 mInScopeSubtitle = FALSE;
2083 break;
2084
2085 case EFI_IFR_NO_SUBMIT_IF_OP:
2086 case EFI_IFR_INCONSISTENT_IF_OP:
2087 //
2088 // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF
2089 //
2090 break;
2091
2092 case EFI_IFR_SUPPRESS_IF_OP:
2093 if (SuppressForOption) {
2094 InScopeOptionSuppress = FALSE;
2095 } else if (SuppressForQuestion) {
2096 mInScopeSuppress = FALSE;
2097 } else {
2098 InScopeFormSuppress = FALSE;
2099 }
2100 break;
2101
2102 case EFI_IFR_GRAY_OUT_IF_OP:
2103 mInScopeGrayOut = FALSE;
2104 break;
2105
2106 case EFI_IFR_DISABLE_IF_OP:
2107 mInScopeDisable = FALSE;
2108 OpCodeDisabled = FALSE;
2109 break;
2110
2111 case EFI_IFR_ONE_OF_OP:
2112 case EFI_IFR_ORDERED_LIST_OP:
2113 SuppressForOption = FALSE;
2114 break;
2115
2116 case EFI_IFR_DEFAULT_OP:
2117 InScopeDefault = FALSE;
2118 break;
2119
2120 case EFI_IFR_MAP_OP:
2121 //
2122 // Get current Map Expression List.
2123 //
2124 Status = PopMapExpressionList ((VOID **) &MapExpressionList);
2125 if (Status == EFI_ACCESS_DENIED) {
2126 MapExpressionList = NULL;
2127 }
2128 //
2129 // Get current expression.
2130 //
2131 Status = PopCurrentExpression ((VOID **) &CurrentExpression);
2132 ASSERT_EFI_ERROR (Status);
2133 ASSERT (MapScopeDepth > 0);
2134 MapScopeDepth --;
2135 break;
2136
2137 default:
2138 if (IsExpressionOpCode (ScopeOpCode)) {
2139 if (mInScopeDisable && CurrentForm == NULL) {
2140 //
2141 // This is DisableIf expression for Form, it should be a constant expression
2142 //
2143 ASSERT (CurrentExpression != NULL);
2144 Status = EvaluateExpression (FormSet, CurrentForm, CurrentExpression);
2145 if (EFI_ERROR (Status)) {
2146 return Status;
2147 }
2148
2149 if (CurrentExpression->Result.Type != EFI_IFR_TYPE_BOOLEAN) {
2150 return EFI_INVALID_PARAMETER;
2151 }
2152
2153 OpCodeDisabled = CurrentExpression->Result.Value.b;
2154 //
2155 // DisableIf Expression is only used once and not queued, free it
2156 //
2157 DestroyExpression (CurrentExpression);
2158 }
2159
2160 //
2161 // End of current Expression
2162 //
2163 CurrentExpression = NULL;
2164 }
2165 break;
2166 }
2167 break;
2168
2169 default:
2170 break;
2171 }
2172 }
2173
2174 return EFI_SUCCESS;
2175 }
EFI Development Kit II mirror for PVE