]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/SetupBrowserDxe/IfrParse.c
projects / mirror_edk2.git / blob
? search:


35ed197a960ba7c7a0165ab44b3e9e535f7c7f95
[mirror_edk2.git] / MdeModulePkg / Universal / SetupBrowserDxe / IfrParse.c
1 /** @file
2 Parser for IFR binary encoding.
3
4 Copyright (c) 2007 - 2008, Intel Corporation
5 All rights reserved. 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 #include "Ui.h"
17
18 UINT16 mStatementIndex;
19 UINT16 mExpressionOpCodeIndex;
20
21 BOOLEAN mInScopeSubtitle;
22 BOOLEAN mInScopeSuppress;
23 BOOLEAN mInScopeGrayOut;
24 FORM_EXPRESSION *mSuppressExpression;
25 FORM_EXPRESSION *mGrayOutExpression;
26
27 EFI_GUID gTianoHiiIfrGuid = EFI_IFR_TIANO_GUID;
28 GLOBAL_REMOVE_IF_UNREFERENCED EFI_GUID mFrameworkHiiCompatibilityGuid = EFI_IFR_FRAMEWORK_GUID;
29
30
31 /**
32 Initialize Statement header members.
33
34 @param OpCodeData Pointer of the raw OpCode data.
35 @param FormSet Pointer of the current FormSe.
36 @param Form Pointer of the current Form.
37
38 @return The Statement.
39
40 **/
41 FORM_BROWSER_STATEMENT *
42 CreateStatement (
43 IN UINT8 *OpCodeData,
44 IN OUT FORM_BROWSER_FORMSET *FormSet,
45 IN OUT FORM_BROWSER_FORM *Form
46 )
47 {
48 FORM_BROWSER_STATEMENT *Statement;
49 EFI_IFR_STATEMENT_HEADER *StatementHdr;
50
51 if (Form == NULL) {
52 //
53 // We are currently not in a Form Scope, so just skip this Statement
54 //
55 return NULL;
56 }
57
58 Statement = &FormSet->StatementBuffer[mStatementIndex];
59 mStatementIndex++;
60
61 InitializeListHead (&Statement->DefaultListHead);
62 InitializeListHead (&Statement->OptionListHead);
63 InitializeListHead (&Statement->InconsistentListHead);
64 InitializeListHead (&Statement->NoSubmitListHead);
65
66 Statement->Signature = FORM_BROWSER_STATEMENT_SIGNATURE;
67
68 Statement->Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
69
70 StatementHdr = (EFI_IFR_STATEMENT_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
71 CopyMem (&Statement->Prompt, &StatementHdr->Prompt, sizeof (EFI_STRING_ID));
72 CopyMem (&Statement->Help, &StatementHdr->Help, sizeof (EFI_STRING_ID));
73
74 if (mInScopeSuppress) {
75 Statement->SuppressExpression = mSuppressExpression;
76 }
77
78 if (mInScopeGrayOut) {
79 Statement->GrayOutExpression = mGrayOutExpression;
80 }
81
82 Statement->InSubtitle = mInScopeSubtitle;
83
84 //
85 // Insert this Statement into current Form
86 //
87 InsertTailList (&Form->StatementListHead, &Statement->Link);
88
89 return Statement;
90 }
91
92 /**
93 Convert a numeric value to a Unicode String and insert it to String Package.
94 This string is used as the Unicode Name for the EFI Variable. This is to support
95 the deprecated vareqval opcode.
96
97 @param FormSet The FormSet.
98 @param Statement The numeric question whose VarStoreInfo.VarName is the
99 numeric value which is used to produce the Unicode Name
100 for the EFI Variable.
101
102 If the Statement is NULL, the ASSERT.
103 If the opcode is not Numeric, then ASSERT.
104
105 @retval EFI_SUCCESS The funtion always succeeds.
106 **/
107 EFI_STATUS
108 UpdateCheckBoxStringToken (
109 IN CONST FORM_BROWSER_FORMSET *FormSet,
110 IN FORM_BROWSER_STATEMENT *Statement
111 )
112 {
113 CHAR16 Str[MAXIMUM_VALUE_CHARACTERS];
114 EFI_STRING_ID Id;
115 EFI_STATUS Status;
116
117 ASSERT (Statement != NULL);
118 ASSERT (Statement->Operand == EFI_IFR_NUMERIC_OP);
119
120 UnicodeValueToString (Str, 0, Statement->VarStoreInfo.VarName, MAXIMUM_VALUE_CHARACTERS - 1);
121
122 Status = HiiLibNewString (FormSet->HiiHandle, &Id, Str);
123
124 if (EFI_ERROR (Status)) {
125 return Status;
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 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 (&mFrameworkHiiCompatibilityGuid, (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 (PcdFrameworkHiiCompatibilitySupport)) {
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 EFI_STATUS Status;
331 UINTN StrBufferLen;
332 CHAR16 *Name;
333
334 if (Storage->Type == EFI_HII_VARSTORE_BUFFER) {
335 Name = Storage->Name;
336 } else {
337 Name = NULL;
338 }
339
340 StrBufferLen = 0;
341 Status = ConstructConfigHdr (
342 Storage->ConfigHdr,
343 &StrBufferLen,
344 &Storage->Guid,
345 Name,
346 FormSet->DriverHandle
347 );
348 if (Status == EFI_BUFFER_TOO_SMALL) {
349 Storage->ConfigHdr = AllocateZeroPool (StrBufferLen);
350 Status = ConstructConfigHdr (
351 Storage->ConfigHdr,
352 &StrBufferLen,
353 &Storage->Guid,
354 Name,
355 FormSet->DriverHandle
356 );
357 }
358
359 if (EFI_ERROR (Status)) {
360 return Status;
361 }
362
363 Storage->ConfigRequest = AllocateCopyPool (StrBufferLen, Storage->ConfigHdr);
364 Storage->SpareStrLen = 0;
365
366 return EFI_SUCCESS;
367 }
368
369
370 /**
371 Initialize Request Element of a Question. <RequestElement> ::= '&'<BlockName> | '&'<Label>
372
373 @param FormSet Pointer of the current FormSet.
374 @param Question The Question to be initialized.
375
376 @retval EFI_SUCCESS Function success.
377 @retval EFI_INVALID_PARAMETER No storage associated with the Question.
378
379 **/
380 EFI_STATUS
381 InitializeRequestElement (
382 IN OUT FORM_BROWSER_FORMSET *FormSet,
383 IN OUT FORM_BROWSER_STATEMENT *Question
384 )
385 {
386 FORMSET_STORAGE *Storage;
387 UINTN StrLen;
388 UINTN StringSize;
389 CHAR16 *NewStr;
390 CHAR16 RequestElement[30];
391
392 Storage = Question->Storage;
393 if (Storage == NULL) {
394 return EFI_INVALID_PARAMETER;
395 }
396
397 if (Storage->Type == EFI_HII_VARSTORE_EFI_VARIABLE) {
398 //
399 // <ConfigRequest> is unnecessary for EFI variable storage,
400 // GetVariable()/SetVariable() will be used to retrieve/save values
401 //
402 return EFI_SUCCESS;
403 }
404
405 //
406 // Prepare <RequestElement>
407 //
408 if (Storage->Type == EFI_HII_VARSTORE_BUFFER) {
409 StrLen = UnicodeSPrint (
410 RequestElement,
411 30 * sizeof (CHAR16),
412 L"&OFFSET=%x&WIDTH=%x",
413 Question->VarStoreInfo.VarOffset,
414 Question->StorageWidth
415 );
416 Question->BlockName = AllocateCopyPool ((StrLen + 1) * sizeof (CHAR16), RequestElement);
417 } else {
418 StrLen = UnicodeSPrint (RequestElement, 30 * sizeof (CHAR16), L"&%s", Question->VariableName);
419 }
420
421 if ((Question->Operand == EFI_IFR_PASSWORD_OP) && ((Question->QuestionFlags & EFI_IFR_FLAG_CALLBACK) == EFI_IFR_FLAG_CALLBACK)) {
422 //
423 // Password with CALLBACK flag is stored in encoded format,
424 // so don't need to append it to <ConfigRequest>
425 //
426 return EFI_SUCCESS;
427 }
428
429 //
430 // Append <RequestElement> to <ConfigRequest>
431 //
432 if (StrLen > Storage->SpareStrLen) {
433 //
434 // Old String buffer is not sufficient for RequestElement, allocate a new one
435 //
436 StringSize = (Storage->ConfigRequest != NULL) ? StrSize (Storage->ConfigRequest) : sizeof (CHAR16);
437 NewStr = AllocateZeroPool (StringSize + CONFIG_REQUEST_STRING_INCREMENTAL * sizeof (CHAR16));
438 ASSERT (NewStr != NULL);
439 if (Storage->ConfigRequest != NULL) {
440 CopyMem (NewStr, Storage->ConfigRequest, StringSize);
441 FreePool (Storage->ConfigRequest);
442 }
443 Storage->ConfigRequest = NewStr;
444 Storage->SpareStrLen = CONFIG_REQUEST_STRING_INCREMENTAL;
445 }
446
447 StrCat (Storage->ConfigRequest, RequestElement);
448 Storage->ElementCount++;
449 Storage->SpareStrLen -= StrLen;
450
451 return EFI_SUCCESS;
452 }
453
454
455 /**
456 Free resources of a Expression.
457
458 @param FormSet Pointer of the Expression
459
460 **/
461 VOID
462 DestroyExpression (
463 IN FORM_EXPRESSION *Expression
464 )
465 {
466 LIST_ENTRY *Link;
467 EXPRESSION_OPCODE *OpCode;
468
469 while (!IsListEmpty (&Expression->OpCodeListHead)) {
470 Link = GetFirstNode (&Expression->OpCodeListHead);
471 OpCode = EXPRESSION_OPCODE_FROM_LINK (Link);
472 RemoveEntryList (&OpCode->Link);
473
474 if (OpCode->ValueList != NULL) {
475 FreePool (OpCode->ValueList);
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 Statement Pointer of the Statement
546
547 **/
548 VOID
549 DestroyStatement (
550 IN OUT FORM_BROWSER_STATEMENT *Statement
551 )
552 {
553 LIST_ENTRY *Link;
554 QUESTION_DEFAULT *Default;
555 QUESTION_OPTION *Option;
556 FORM_EXPRESSION *Expression;
557
558 //
559 // Free Default value List
560 //
561 while (!IsListEmpty (&Statement->DefaultListHead)) {
562 Link = GetFirstNode (&Statement->DefaultListHead);
563 Default = QUESTION_DEFAULT_FROM_LINK (Link);
564 RemoveEntryList (&Default->Link);
565
566 FreePool (Default);
567 }
568
569 //
570 // Free Options List
571 //
572 while (!IsListEmpty (&Statement->OptionListHead)) {
573 Link = GetFirstNode (&Statement->OptionListHead);
574 Option = QUESTION_OPTION_FROM_LINK (Link);
575 RemoveEntryList (&Option->Link);
576
577 FreePool (Option);
578 }
579
580 //
581 // Free Inconsistent List
582 //
583 while (!IsListEmpty (&Statement->InconsistentListHead)) {
584 Link = GetFirstNode (&Statement->InconsistentListHead);
585 Expression = FORM_EXPRESSION_FROM_LINK (Link);
586 RemoveEntryList (&Expression->Link);
587
588 DestroyExpression (Expression);
589 }
590
591 //
592 // Free NoSubmit List
593 //
594 while (!IsListEmpty (&Statement->NoSubmitListHead)) {
595 Link = GetFirstNode (&Statement->NoSubmitListHead);
596 Expression = FORM_EXPRESSION_FROM_LINK (Link);
597 RemoveEntryList (&Expression->Link);
598
599 DestroyExpression (Expression);
600 }
601
602 if (Statement->VariableName != NULL) {
603 FreePool (Statement->VariableName);
604 }
605 if (Statement->BlockName != NULL) {
606 FreePool (Statement->BlockName);
607 }
608 }
609
610
611 /**
612 Free resources of a Form.
613
614 @param Form Pointer of the Form.
615
616 **/
617 VOID
618 DestroyForm (
619 IN OUT FORM_BROWSER_FORM *Form
620 )
621 {
622 LIST_ENTRY *Link;
623 FORM_EXPRESSION *Expression;
624 FORM_BROWSER_STATEMENT *Statement;
625
626 //
627 // Free Form Expressions
628 //
629 while (!IsListEmpty (&Form->ExpressionListHead)) {
630 Link = GetFirstNode (&Form->ExpressionListHead);
631 Expression = FORM_EXPRESSION_FROM_LINK (Link);
632 RemoveEntryList (&Expression->Link);
633
634 DestroyExpression (Expression);
635 }
636
637 //
638 // Free Statements/Questions
639 //
640 while (!IsListEmpty (&Form->StatementListHead)) {
641 Link = GetFirstNode (&Form->StatementListHead);
642 Statement = FORM_BROWSER_STATEMENT_FROM_LINK (Link);
643 RemoveEntryList (&Statement->Link);
644
645 DestroyStatement (Statement);
646 }
647
648 //
649 // Free this Form
650 //
651 FreePool (Form);
652 }
653
654
655 /**
656 Free resources allocated for a FormSet.
657
658 @param FormSet Pointer of the FormSet
659
660 **/
661 VOID
662 DestroyFormSet (
663 IN OUT FORM_BROWSER_FORMSET *FormSet
664 )
665 {
666 LIST_ENTRY *Link;
667 FORMSET_STORAGE *Storage;
668 FORMSET_DEFAULTSTORE *DefaultStore;
669 FORM_BROWSER_FORM *Form;
670
671 //
672 // Free IFR binary buffer
673 //
674 FreePool (FormSet->IfrBinaryData);
675
676 //
677 // Free FormSet Storage
678 //
679 if (FormSet->StorageListHead.ForwardLink != NULL) {
680 while (!IsListEmpty (&FormSet->StorageListHead)) {
681 Link = GetFirstNode (&FormSet->StorageListHead);
682 Storage = FORMSET_STORAGE_FROM_LINK (Link);
683 RemoveEntryList (&Storage->Link);
684
685 DestroyStorage (Storage);
686 }
687 }
688
689 //
690 // Free FormSet Default Store
691 //
692 if (FormSet->DefaultStoreListHead.ForwardLink != NULL) {
693 while (!IsListEmpty (&FormSet->DefaultStoreListHead)) {
694 Link = GetFirstNode (&FormSet->DefaultStoreListHead);
695 DefaultStore = FORMSET_DEFAULTSTORE_FROM_LINK (Link);
696 RemoveEntryList (&DefaultStore->Link);
697
698 FreePool (DefaultStore);
699 }
700 }
701
702 //
703 // Free Forms
704 //
705 if (FormSet->FormListHead.ForwardLink != NULL) {
706 while (!IsListEmpty (&FormSet->FormListHead)) {
707 Link = GetFirstNode (&FormSet->FormListHead);
708 Form = FORM_BROWSER_FORM_FROM_LINK (Link);
709 RemoveEntryList (&Form->Link);
710
711 DestroyForm (Form);
712 }
713 }
714
715 if (FormSet->StatementBuffer != NULL) {
716 FreePool (FormSet->StatementBuffer);
717 }
718 if (FormSet->ExpressionBuffer != NULL) {
719 FreePool (FormSet->ExpressionBuffer);
720 }
721
722 FreePool (FormSet);
723 }
724
725
726 /**
727 Tell whether this Operand is an Expression OpCode or not
728
729 @param Operand Operand of an IFR OpCode.
730
731 @retval TRUE This is an Expression OpCode.
732 @retval FALSE Not an Expression OpCode.
733
734 **/
735 BOOLEAN
736 IsExpressionOpCode (
737 IN UINT8 Operand
738 )
739 {
740 if (((Operand >= EFI_IFR_EQ_ID_VAL_OP) && (Operand <= EFI_IFR_NOT_OP)) ||
741 ((Operand >= EFI_IFR_MATCH_OP) && (Operand <= EFI_IFR_SPAN_OP)) ||
742 (Operand == EFI_IFR_CATENATE_OP) ||
743 (Operand == EFI_IFR_TO_LOWER_OP) ||
744 (Operand == EFI_IFR_TO_UPPER_OP) ||
745 (Operand == EFI_IFR_VERSION_OP)
746 ) {
747 return TRUE;
748 } else {
749 return FALSE;
750 }
751 }
752
753
754 /**
755 Calculate number of Statemens(Questions) and Expression OpCodes.
756
757 @param FormSet The FormSet to be counted.
758 @param NumberOfStatement Number of Statemens(Questions)
759 @param NumberOfExpression Number of Expression OpCodes
760
761 **/
762 VOID
763 CountOpCodes (
764 IN FORM_BROWSER_FORMSET *FormSet,
765 IN OUT UINT16 *NumberOfStatement,
766 IN OUT UINT16 *NumberOfExpression
767 )
768 {
769 UINT16 StatementCount;
770 UINT16 ExpressionCount;
771 UINT8 *OpCodeData;
772 UINTN Offset;
773 UINTN OpCodeLen;
774
775 Offset = 0;
776 StatementCount = 0;
777 ExpressionCount = 0;
778
779 while (Offset < FormSet->IfrBinaryLength) {
780 OpCodeData = FormSet->IfrBinaryData + Offset;
781 OpCodeLen = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
782 Offset += OpCodeLen;
783
784 if (IsExpressionOpCode (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode)) {
785 ExpressionCount++;
786 } else {
787 StatementCount++;
788 }
789 }
790
791 *NumberOfStatement = StatementCount;
792 *NumberOfExpression = ExpressionCount;
793 }
794
795
796
797 /**
798 Parse opcodes in the formset IFR binary.
799
800 @param FormSet Pointer of the FormSet data structure.
801
802 @retval EFI_SUCCESS Opcode parse success.
803 @retval Other Opcode parse fail.
804
805 **/
806 EFI_STATUS
807 ParseOpCodes (
808 IN FORM_BROWSER_FORMSET *FormSet
809 )
810 {
811 EFI_STATUS Status;
812 UINT16 Index;
813 FORM_BROWSER_FORM *CurrentForm;
814 FORM_BROWSER_STATEMENT *CurrentStatement;
815 EXPRESSION_OPCODE *ExpressionOpCode;
816 FORM_EXPRESSION *CurrentExpression;
817 UINT8 Operand;
818 UINT8 Scope;
819 UINTN OpCodeOffset;
820 UINTN OpCodeLength;
821 UINT8 *OpCodeData;
822 UINT8 ScopeOpCode;
823 FORMSET_STORAGE *Storage;
824 FORMSET_DEFAULTSTORE *DefaultStore;
825 QUESTION_DEFAULT *CurrentDefault;
826 QUESTION_OPTION *CurrentOption;
827 CHAR8 *AsciiString;
828 UINT16 NumberOfStatement;
829 UINT16 NumberOfExpression;
830 EFI_IMAGE_ID *ImageId;
831 BOOLEAN SuppressForOption;
832 BOOLEAN InScopeOptionSuppress;
833 FORM_EXPRESSION *OptionSuppressExpression;
834 BOOLEAN InScopeDisable;
835 UINT16 DepthOfDisable;
836 BOOLEAN OpCodeDisabled;
837 BOOLEAN SingleOpCodeExpression;
838 BOOLEAN InScopeDefault;
839 EFI_HII_VALUE *Value;
840
841 mInScopeSubtitle = FALSE;
842 SuppressForOption = FALSE;
843 mInScopeSuppress = FALSE;
844 InScopeOptionSuppress = FALSE;
845 mInScopeGrayOut = FALSE;
846 InScopeDisable = FALSE;
847 DepthOfDisable = 0;
848 OpCodeDisabled = FALSE;
849 SingleOpCodeExpression = FALSE;
850 InScopeDefault = FALSE;
851 CurrentExpression = NULL;
852 CurrentDefault = NULL;
853 CurrentOption = NULL;
854 OptionSuppressExpression = NULL;
855
856 //
857 // Get the number of Statements and Expressions
858 //
859 CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression);
860
861 mStatementIndex = 0;
862 FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT));
863 if (FormSet->StatementBuffer == NULL) {
864 return EFI_OUT_OF_RESOURCES;
865 }
866
867 mExpressionOpCodeIndex = 0;
868 FormSet->ExpressionBuffer = AllocateZeroPool (NumberOfExpression * sizeof (EXPRESSION_OPCODE));
869 if (FormSet->ExpressionBuffer == NULL) {
870 return EFI_OUT_OF_RESOURCES;
871 }
872
873 InitializeListHead (&FormSet->StorageListHead);
874 InitializeListHead (&FormSet->DefaultStoreListHead);
875 InitializeListHead (&FormSet->FormListHead);
876
877 CurrentForm = NULL;
878 CurrentStatement = NULL;
879
880 ResetScopeStack ();
881
882 OpCodeOffset = 0;
883 while (OpCodeOffset < FormSet->IfrBinaryLength) {
884 OpCodeData = FormSet->IfrBinaryData + OpCodeOffset;
885
886 OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
887 OpCodeOffset += OpCodeLength;
888 Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
889 Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope;
890
891 //
892 // If scope bit set, push onto scope stack
893 //
894 if (Scope != 0) {
895 PushScope (Operand);
896 }
897
898 if (OpCodeDisabled) {
899 //
900 // DisableIf Expression is evaluated to be TRUE, try to find its end.
901 // Here only cares the EFI_IFR_DISABLE_IF and EFI_IFR_END
902 //
903 if (Operand == EFI_IFR_DISABLE_IF_OP) {
904 DepthOfDisable++;
905 } else if (Operand == EFI_IFR_END_OP) {
906 Status = PopScope (&ScopeOpCode);
907 if (EFI_ERROR (Status)) {
908 return Status;
909 }
910
911 if (ScopeOpCode == EFI_IFR_DISABLE_IF_OP) {
912 if (DepthOfDisable == 0) {
913 InScopeDisable = FALSE;
914 OpCodeDisabled = FALSE;
915 } else {
916 DepthOfDisable--;
917 }
918 }
919 }
920 continue;
921 }
922
923 if (IsExpressionOpCode (Operand)) {
924 ExpressionOpCode = &FormSet->ExpressionBuffer[mExpressionOpCodeIndex];
925 mExpressionOpCodeIndex++;
926
927 ExpressionOpCode->Signature = EXPRESSION_OPCODE_SIGNATURE;
928 ExpressionOpCode->Operand = Operand;
929 Value = &ExpressionOpCode->Value;
930
931 switch (Operand) {
932 case EFI_IFR_EQ_ID_VAL_OP:
933 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_VAL *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
934
935 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
936 CopyMem (&Value->Value.u16, &((EFI_IFR_EQ_ID_VAL *) OpCodeData)->Value, sizeof (UINT16));
937 break;
938
939 case EFI_IFR_EQ_ID_ID_OP:
940 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_ID *) OpCodeData)->QuestionId1, sizeof (EFI_QUESTION_ID));
941 CopyMem (&ExpressionOpCode->QuestionId2, &((EFI_IFR_EQ_ID_ID *) OpCodeData)->QuestionId2, sizeof (EFI_QUESTION_ID));
942 break;
943
944 case EFI_IFR_EQ_ID_LIST_OP:
945 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_LIST *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
946 CopyMem (&ExpressionOpCode->ListLength, &((EFI_IFR_EQ_ID_LIST *) OpCodeData)->ListLength, sizeof (UINT16));
947 ExpressionOpCode->ValueList = AllocateCopyPool (ExpressionOpCode->ListLength * sizeof (UINT16), &((EFI_IFR_EQ_ID_LIST *) OpCodeData)->ValueList);
948 break;
949
950 case EFI_IFR_TO_STRING_OP:
951 case EFI_IFR_FIND_OP:
952 ExpressionOpCode->Format = (( EFI_IFR_TO_STRING *) OpCodeData)->Format;
953 break;
954
955 case EFI_IFR_STRING_REF1_OP:
956 Value->Type = EFI_IFR_TYPE_STRING;
957 CopyMem (&Value->Value.string, &(( EFI_IFR_STRING_REF1 *) OpCodeData)->StringId, sizeof (EFI_STRING_ID));
958 break;
959
960 case EFI_IFR_RULE_REF_OP:
961 ExpressionOpCode->RuleId = (( EFI_IFR_RULE_REF *) OpCodeData)->RuleId;
962 break;
963
964 case EFI_IFR_SPAN_OP:
965 ExpressionOpCode->Flags = (( EFI_IFR_SPAN *) OpCodeData)->Flags;
966 break;
967
968 case EFI_IFR_THIS_OP:
969 ExpressionOpCode->QuestionId = CurrentStatement->QuestionId;
970 break;
971
972 case EFI_IFR_QUESTION_REF1_OP:
973 CopyMem (&ExpressionOpCode->QuestionId, &((EFI_IFR_EQ_ID_LIST *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
974 break;
975
976 case EFI_IFR_QUESTION_REF3_OP:
977 if (OpCodeLength >= sizeof (EFI_IFR_QUESTION_REF3_2)) {
978 CopyMem (&ExpressionOpCode->DevicePath, &(( EFI_IFR_QUESTION_REF3_2 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
979
980 if (OpCodeLength >= sizeof (EFI_IFR_QUESTION_REF3_3)) {
981 CopyMem (&ExpressionOpCode->Guid, &(( EFI_IFR_QUESTION_REF3_3 *) OpCodeData)->Guid, sizeof (EFI_GUID));
982 }
983 }
984 break;
985
986 //
987 // constant
988 //
989 case EFI_IFR_TRUE_OP:
990 Value->Type = EFI_IFR_TYPE_BOOLEAN;
991 Value->Value.b = TRUE;
992 break;
993
994 case EFI_IFR_FALSE_OP:
995 Value->Type = EFI_IFR_TYPE_BOOLEAN;
996 Value->Value.b = FALSE;
997 break;
998
999 case EFI_IFR_ONE_OP:
1000 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1001 Value->Value.u8 = 1;
1002 break;
1003
1004 case EFI_IFR_ZERO_OP:
1005 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1006 Value->Value.u8 = 0;
1007 break;
1008
1009 case EFI_IFR_ONES_OP:
1010 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
1011 Value->Value.u64 = 0xffffffffffffffffULL;
1012 break;
1013
1014 case EFI_IFR_UINT8_OP:
1015 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1016 Value->Value.u8 = (( EFI_IFR_UINT8 *) OpCodeData)->Value;
1017 break;
1018
1019 case EFI_IFR_UINT16_OP:
1020 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
1021 CopyMem (&Value->Value.u16, &(( EFI_IFR_UINT16 *) OpCodeData)->Value, sizeof (UINT16));
1022 break;
1023
1024 case EFI_IFR_UINT32_OP:
1025 Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
1026 CopyMem (&Value->Value.u32, &(( EFI_IFR_UINT32 *) OpCodeData)->Value, sizeof (UINT32));
1027 break;
1028
1029 case EFI_IFR_UINT64_OP:
1030 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
1031 CopyMem (&Value->Value.u64, &(( EFI_IFR_UINT64 *) OpCodeData)->Value, sizeof (UINT64));
1032 break;
1033
1034 case EFI_IFR_UNDEFINED_OP:
1035 Value->Type = EFI_IFR_TYPE_OTHER;
1036 break;
1037
1038 case EFI_IFR_VERSION_OP:
1039 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
1040 Value->Value.u16 = EFI_IFR_SPECIFICATION_VERSION;
1041 break;
1042
1043 default:
1044 break;
1045 }
1046
1047 InsertTailList (&CurrentExpression->OpCodeListHead, &ExpressionOpCode->Link);
1048
1049 if (SingleOpCodeExpression) {
1050 //
1051 // There are two cases to indicate the end of an Expression:
1052 // for single OpCode expression: one Expression OpCode
1053 // for expression consists of more than one OpCode: EFI_IFR_END
1054 //
1055 SingleOpCodeExpression = FALSE;
1056
1057 if (InScopeDisable) {
1058 //
1059 // Evaluate DisableIf expression
1060 //
1061 Status = EvaluateExpression (FormSet, CurrentForm, CurrentExpression);
1062 if (EFI_ERROR (Status)) {
1063 return Status;
1064 }
1065 if (CurrentExpression->Result.Type != EFI_IFR_TYPE_BOOLEAN) {
1066 return EFI_INVALID_PARAMETER;
1067 }
1068
1069 OpCodeDisabled = CurrentExpression->Result.Value.b;
1070 }
1071
1072 CurrentExpression = NULL;
1073 }
1074
1075 continue;
1076 }
1077
1078 //
1079 // Parse the Opcode
1080 //
1081 switch (Operand) {
1082
1083 case EFI_IFR_FORM_SET_OP:
1084 //
1085 // check the formset GUID
1086 //
1087 if (CompareMem (&FormSet->Guid, &((EFI_IFR_FORM_SET *) OpCodeData)->Guid, sizeof (EFI_GUID)) != 0) {
1088 return EFI_INVALID_PARAMETER;
1089 }
1090
1091 CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
1092 CopyMem (&FormSet->Help, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
1093 break;
1094
1095 case EFI_IFR_FORM_OP:
1096 //
1097 // Create a new Form for this FormSet
1098 //
1099 CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
1100 ASSERT (CurrentForm != NULL);
1101 CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
1102 InitializeListHead (&CurrentForm->ExpressionListHead);
1103 InitializeListHead (&CurrentForm->StatementListHead);
1104
1105 CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16));
1106 CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID));
1107
1108 //
1109 // Insert into Form list of this FormSet
1110 //
1111 InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
1112 break;
1113
1114 //
1115 // Storage
1116 //
1117 case EFI_IFR_VARSTORE_OP:
1118 //
1119 // Create a buffer Storage for this FormSet
1120 //
1121 Storage = CreateStorage (FormSet);
1122 Storage->Type = EFI_HII_VARSTORE_BUFFER;
1123
1124 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
1125 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE *) OpCodeData)->Guid, sizeof (EFI_GUID));
1126 CopyMem (&Storage->Size, &((EFI_IFR_VARSTORE *) OpCodeData)->Size, sizeof (UINT16));
1127
1128 Storage->Buffer = AllocateZeroPool (Storage->Size);
1129 Storage->EditBuffer = AllocateZeroPool (Storage->Size);
1130
1131 AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name;
1132 Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2);
1133 ASSERT (Storage->Name != NULL);
1134 for (Index = 0; AsciiString[Index] != 0; Index++) {
1135 Storage->Name[Index] = (CHAR16) AsciiString[Index];
1136 }
1137
1138 //
1139 // Initialize <ConfigHdr>
1140 //
1141 InitializeConfigHdr (FormSet, Storage);
1142 break;
1143
1144 case EFI_IFR_VARSTORE_NAME_VALUE_OP:
1145 //
1146 // Create a name/value Storage for this FormSet
1147 //
1148 Storage = CreateStorage (FormSet);
1149 Storage->Type = EFI_HII_VARSTORE_NAME_VALUE;
1150
1151 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
1152 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->Guid, sizeof (EFI_GUID));
1153
1154 //
1155 // Initialize <ConfigHdr>
1156 //
1157 InitializeConfigHdr (FormSet, Storage);
1158 break;
1159
1160 case EFI_IFR_VARSTORE_EFI_OP:
1161 //
1162 // Create a EFI variable Storage for this FormSet
1163 //
1164 Storage = CreateStorage (FormSet);
1165 Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE;
1166
1167 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
1168 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid, sizeof (EFI_GUID));
1169 CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32));
1170 break;
1171
1172 //
1173 // DefaultStore
1174 //
1175 case EFI_IFR_DEFAULTSTORE_OP:
1176 DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE));
1177 ASSERT (DefaultStore != NULL);
1178 DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE;
1179
1180 CopyMem (&DefaultStore->DefaultId, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId, sizeof (UINT16));
1181 CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID));
1182
1183 //
1184 // Insert to DefaultStore list of this Formset
1185 //
1186 InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link);
1187 break;
1188
1189 //
1190 // Statements
1191 //
1192 case EFI_IFR_SUBTITLE_OP:
1193 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
1194 CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags;
1195
1196 if (Scope != 0) {
1197 mInScopeSubtitle = TRUE;
1198 }
1199 break;
1200
1201 case EFI_IFR_TEXT_OP:
1202 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
1203
1204 CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID));
1205 break;
1206
1207 //
1208 // Questions
1209 //
1210 case EFI_IFR_ACTION_OP:
1211 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1212
1213 if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) {
1214 //
1215 // No QuestionConfig present, so no configuration string will be processed
1216 //
1217 CurrentStatement->QuestionConfig = 0;
1218 } else {
1219 CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID));
1220 }
1221 break;
1222
1223 case EFI_IFR_RESET_BUTTON_OP:
1224 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1225
1226 CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID));
1227 break;
1228
1229 case EFI_IFR_REF_OP:
1230 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1231
1232 CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID));
1233 if (OpCodeLength >= sizeof (EFI_IFR_REF2)) {
1234 CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
1235
1236 if (OpCodeLength >= sizeof (EFI_IFR_REF3)) {
1237 CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID));
1238
1239 if (OpCodeLength >= sizeof (EFI_IFR_REF4)) {
1240 CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
1241 }
1242 }
1243 }
1244 break;
1245
1246 case EFI_IFR_ONE_OF_OP:
1247 case EFI_IFR_NUMERIC_OP:
1248 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1249
1250 CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags;
1251 Value = &CurrentStatement->HiiValue;
1252
1253 switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) {
1254 case EFI_IFR_NUMERIC_SIZE_1:
1255 CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue;
1256 CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue;
1257 CurrentStatement->Step = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step;
1258 CurrentStatement->StorageWidth = sizeof (UINT8);
1259 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
1260 break;
1261
1262 case EFI_IFR_NUMERIC_SIZE_2:
1263 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16));
1264 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16));
1265 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step, sizeof (UINT16));
1266 CurrentStatement->StorageWidth = sizeof (UINT16);
1267 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
1268 break;
1269
1270 case EFI_IFR_NUMERIC_SIZE_4:
1271 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32));
1272 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32));
1273 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step, sizeof (UINT32));
1274 CurrentStatement->StorageWidth = sizeof (UINT32);
1275 Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
1276 break;
1277
1278 case EFI_IFR_NUMERIC_SIZE_8:
1279 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64));
1280 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64));
1281 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step, sizeof (UINT64));
1282 CurrentStatement->StorageWidth = sizeof (UINT64);
1283 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
1284 break;
1285
1286 default:
1287 break;
1288 }
1289
1290 InitializeRequestElement (FormSet, CurrentStatement);
1291
1292 if ((Operand == EFI_IFR_ONE_OF_OP) && Scope != 0) {
1293 SuppressForOption = TRUE;
1294 }
1295 break;
1296
1297 case EFI_IFR_ORDERED_LIST_OP:
1298 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1299
1300 CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags;
1301 CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers;
1302 CurrentStatement->StorageWidth = (UINT16)(CurrentStatement->MaxContainers * sizeof (UINT8));
1303 InitializeRequestElement (FormSet, CurrentStatement);
1304
1305 //
1306 // No buffer type is defined in EFI_IFR_TYPE_VALUE, so a Configuration Driver
1307 // has to use FormBrowser2.Callback() to retrieve the uncommited data for
1308 // an interactive orderedlist (i.e. with EFI_IFR_FLAG_CALLBACK flag set).
1309 //
1310 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_OTHER;
1311 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
1312
1313 if (Scope != 0) {
1314 SuppressForOption = TRUE;
1315 }
1316 break;
1317
1318 case EFI_IFR_CHECKBOX_OP:
1319 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1320
1321 CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags;
1322 CurrentStatement->StorageWidth = sizeof (BOOLEAN);
1323 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN;
1324
1325 InitializeRequestElement (FormSet, CurrentStatement);
1326
1327 break;
1328
1329 case EFI_IFR_STRING_OP:
1330 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1331
1332 //
1333 // MinSize is the minimum number of characters that can be accepted for this opcode,
1334 // MaxSize is the maximum number of characters that can be accepted for this opcode.
1335 // The characters are stored as Unicode, so the storage width should multiply 2.
1336 //
1337 CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize;
1338 CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize;
1339 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (CHAR16));
1340 CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags;
1341
1342 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
1343 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth + sizeof (CHAR16));
1344
1345 InitializeRequestElement (FormSet, CurrentStatement);
1346 break;
1347
1348 case EFI_IFR_PASSWORD_OP:
1349 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1350
1351 //
1352 // MinSize is the minimum number of characters that can be accepted for this opcode,
1353 // MaxSize is the maximum number of characters that can be accepted for this opcode.
1354 // The characters are stored as Unicode, so the storage width should multiply 2.
1355 //
1356 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16));
1357 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16));
1358 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (CHAR16));
1359
1360 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
1361 CurrentStatement->BufferValue = AllocateZeroPool ((CurrentStatement->StorageWidth + sizeof (CHAR16)));
1362
1363 InitializeRequestElement (FormSet, CurrentStatement);
1364 break;
1365
1366 case EFI_IFR_DATE_OP:
1367 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1368
1369 CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags;
1370 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE;
1371
1372 if ((CurrentStatement->Flags & EFI_QF_DATE_STORAGE) == QF_DATE_STORAGE_NORMAL) {
1373 CurrentStatement->StorageWidth = sizeof (EFI_HII_DATE);
1374
1375 InitializeRequestElement (FormSet, CurrentStatement);
1376 } else {
1377 //
1378 // Don't assign storage for RTC type of date/time
1379 //
1380 CurrentStatement->Storage = NULL;
1381 CurrentStatement->StorageWidth = 0;
1382 }
1383 break;
1384
1385 case EFI_IFR_TIME_OP:
1386 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
1387
1388 CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags;
1389 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME;
1390
1391 if ((CurrentStatement->Flags & QF_TIME_STORAGE) == QF_TIME_STORAGE_NORMAL) {
1392 CurrentStatement->StorageWidth = sizeof (EFI_IFR_TIME);
1393
1394 InitializeRequestElement (FormSet, CurrentStatement);
1395 } else {
1396 //
1397 // Don't assign storage for RTC type of date/time
1398 //
1399 CurrentStatement->Storage = NULL;
1400 CurrentStatement->StorageWidth = 0;
1401 }
1402 break;
1403
1404 //
1405 // Default
1406 //
1407 case EFI_IFR_DEFAULT_OP:
1408 //
1409 // EFI_IFR_DEFAULT appear in scope of a Question,
1410 // It creates a default value for the current question.
1411 // A Question may have more than one Default value which have different default types.
1412 //
1413 CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT));
1414 ASSERT (CurrentDefault != NULL);
1415 CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE;
1416
1417 CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type;
1418 CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16));
1419 CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
1420 ExtendValueToU64 (&CurrentDefault->Value);
1421
1422 //
1423 // Insert to Default Value list of current Question
1424 //
1425 InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link);
1426
1427 if (Scope != 0) {
1428 InScopeDefault = TRUE;
1429 }
1430 break;
1431
1432 //
1433 // Option
1434 //
1435 case EFI_IFR_ONE_OF_OPTION_OP:
1436 //
1437 // EFI_IFR_ONE_OF_OPTION appear in scope of a Question.
1438 // It create a selection for use in current Question.
1439 //
1440 CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION));
1441 ASSERT (CurrentOption != NULL);
1442 CurrentOption->Signature = QUESTION_OPTION_SIGNATURE;
1443
1444 CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags;
1445 CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type;
1446 CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID));
1447 CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
1448 ExtendValueToU64 (&CurrentOption->Value);
1449
1450 if (InScopeOptionSuppress) {
1451 CurrentOption->SuppressExpression = OptionSuppressExpression;
1452 }
1453
1454 //
1455 // Insert to Option list of current Question
1456 //
1457 InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link);
1458 break;
1459
1460 //
1461 // Conditional
1462 //
1463 case EFI_IFR_NO_SUBMIT_IF_OP:
1464 case EFI_IFR_INCONSISTENT_IF_OP:
1465 //
1466 // Create an Expression node
1467 //
1468 CurrentExpression = CreateExpression (CurrentForm);
1469 CopyMem (&CurrentExpression->Error, &((EFI_IFR_INCONSISTENT_IF *) OpCodeData)->Error, sizeof (EFI_STRING_ID));
1470
1471 if (Operand == EFI_IFR_NO_SUBMIT_IF_OP) {
1472 CurrentExpression->Type = EFI_HII_EXPRESSION_NO_SUBMIT_IF;
1473 InsertTailList (&CurrentStatement->NoSubmitListHead, &CurrentExpression->Link);
1474 } else {
1475 CurrentExpression->Type = EFI_HII_EXPRESSION_INCONSISTENT_IF;
1476 InsertTailList (&CurrentStatement->InconsistentListHead, &CurrentExpression->Link);
1477 }
1478 break;
1479
1480 case EFI_IFR_SUPPRESS_IF_OP:
1481 //
1482 // Question and Option will appear in scope of this OpCode
1483 //
1484 CurrentExpression = CreateExpression (CurrentForm);
1485 CurrentExpression->Type = EFI_HII_EXPRESSION_SUPPRESS_IF;
1486 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1487
1488 if (SuppressForOption) {
1489 InScopeOptionSuppress = TRUE;
1490 OptionSuppressExpression = CurrentExpression;
1491 } else {
1492 mInScopeSuppress = TRUE;
1493 mSuppressExpression = CurrentExpression;
1494 }
1495 break;
1496
1497 case EFI_IFR_GRAY_OUT_IF_OP:
1498 //
1499 // Questions will appear in scope of this OpCode
1500 //
1501 CurrentExpression = CreateExpression (CurrentForm);
1502 CurrentExpression->Type = EFI_HII_EXPRESSION_GRAY_OUT_IF;
1503 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1504
1505 mInScopeGrayOut = TRUE;
1506 mGrayOutExpression = CurrentExpression;
1507 break;
1508
1509 case EFI_IFR_DISABLE_IF_OP:
1510 //
1511 // The DisableIf expression should only rely on constant, so it could be
1512 // evaluated at initialization and it will not be queued
1513 //
1514 CurrentExpression = AllocateZeroPool (sizeof (FORM_EXPRESSION));
1515 ASSERT (CurrentExpression != NULL);
1516 CurrentExpression->Signature = FORM_EXPRESSION_SIGNATURE;
1517 CurrentExpression->Type = EFI_HII_EXPRESSION_DISABLE_IF;
1518 InitializeListHead (&CurrentExpression->OpCodeListHead);
1519
1520 InScopeDisable = TRUE;
1521 OpCodeDisabled = FALSE;
1522
1523 //
1524 // Take a look at next OpCode to see whether current expression consists
1525 // of single OpCode
1526 //
1527 if (((EFI_IFR_OP_HEADER *) (OpCodeData + OpCodeLength))->Scope == 0) {
1528 SingleOpCodeExpression = TRUE;
1529 }
1530 break;
1531
1532 //
1533 // Expression
1534 //
1535 case EFI_IFR_VALUE_OP:
1536 CurrentExpression = CreateExpression (CurrentForm);
1537 CurrentExpression->Type = EFI_HII_EXPRESSION_VALUE;
1538 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1539
1540 if (InScopeDefault) {
1541 //
1542 // Used for default (EFI_IFR_DEFAULT)
1543 //
1544 CurrentDefault->ValueExpression = CurrentExpression;
1545 } else {
1546 //
1547 // If used for a question, then the question will be read-only
1548 //
1549 CurrentStatement->ValueExpression = CurrentExpression;
1550 }
1551 break;
1552
1553 case EFI_IFR_RULE_OP:
1554 CurrentExpression = CreateExpression (CurrentForm);
1555 CurrentExpression->Type = EFI_HII_EXPRESSION_RULE;
1556
1557 CurrentExpression->RuleId = ((EFI_IFR_RULE *) OpCodeData)->RuleId;
1558 InsertTailList (&CurrentForm->ExpressionListHead, &CurrentExpression->Link);
1559 break;
1560
1561 //
1562 // Image
1563 //
1564 case EFI_IFR_IMAGE_OP:
1565 //
1566 // Get ScopeOpcode from top of stack
1567 //
1568 PopScope (&ScopeOpCode);
1569 PushScope (ScopeOpCode);
1570
1571 switch (ScopeOpCode) {
1572 case EFI_IFR_FORM_SET_OP:
1573 ImageId = &FormSet->ImageId;
1574 break;
1575
1576 case EFI_IFR_FORM_OP:
1577 ImageId = &CurrentForm->ImageId;
1578 break;
1579
1580 case EFI_IFR_ONE_OF_OPTION_OP:
1581 ImageId = &CurrentOption->ImageId;
1582 break;
1583
1584 default:
1585 ImageId = &CurrentStatement->ImageId;
1586 break;
1587 }
1588
1589 CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID));
1590 break;
1591
1592 //
1593 // Refresh
1594 //
1595 case EFI_IFR_REFRESH_OP:
1596 CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval;
1597 break;
1598
1599 //
1600 // Vendor specific
1601 //
1602 case EFI_IFR_GUID_OP:
1603 if (CompareGuid (&gTianoHiiIfrGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
1604 //
1605 // Tiano specific GUIDed opcodes
1606 //
1607 switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) {
1608 case EFI_IFR_EXTEND_OP_LABEL:
1609 //
1610 // just ignore label
1611 //
1612 break;
1613
1614 case EFI_IFR_EXTEND_OP_BANNER:
1615 if (FormSet->SubClass == EFI_FRONT_PAGE_SUBCLASS) {
1616 CopyMem (
1617 &BannerData->Banner[((EFI_IFR_GUID_BANNER *) OpCodeData)->LineNumber][
1618 ((EFI_IFR_GUID_BANNER *) OpCodeData)->Alignment],
1619 &((EFI_IFR_GUID_BANNER *) OpCodeData)->Title,
1620 sizeof (EFI_STRING_ID)
1621 );
1622 }
1623 break;
1624
1625 case EFI_IFR_EXTEND_OP_CLASS:
1626 CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16));
1627 break;
1628
1629 case EFI_IFR_EXTEND_OP_SUBCLASS:
1630 CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16));
1631 break;
1632
1633 default:
1634 break;
1635 }
1636 }
1637
1638 break;
1639
1640 //
1641 // Scope End
1642 //
1643 case EFI_IFR_END_OP:
1644 Status = PopScope (&ScopeOpCode);
1645 if (EFI_ERROR (Status)) {
1646 ResetScopeStack ();
1647 return Status;
1648 }
1649
1650 switch (ScopeOpCode) {
1651 case EFI_IFR_FORM_SET_OP:
1652 //
1653 // End of FormSet, update FormSet IFR binary length
1654 // to stop parsing substantial OpCodes
1655 //
1656 FormSet->IfrBinaryLength = OpCodeOffset;
1657 break;
1658
1659 case EFI_IFR_FORM_OP:
1660 //
1661 // End of Form
1662 //
1663 CurrentForm = NULL;
1664 break;
1665
1666 case EFI_IFR_ONE_OF_OPTION_OP:
1667 //
1668 // End of Option
1669 //
1670 CurrentOption = NULL;
1671 break;
1672
1673 case EFI_IFR_SUBTITLE_OP:
1674 mInScopeSubtitle = FALSE;
1675 break;
1676
1677 case EFI_IFR_NO_SUBMIT_IF_OP:
1678 case EFI_IFR_INCONSISTENT_IF_OP:
1679 //
1680 // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF
1681 //
1682 break;
1683
1684 case EFI_IFR_SUPPRESS_IF_OP:
1685 if (SuppressForOption) {
1686 InScopeOptionSuppress = FALSE;
1687 } else {
1688 mInScopeSuppress = FALSE;
1689 }
1690 break;
1691
1692 case EFI_IFR_GRAY_OUT_IF_OP:
1693 mInScopeGrayOut = FALSE;
1694 break;
1695
1696 case EFI_IFR_DISABLE_IF_OP:
1697 InScopeDisable = FALSE;
1698 OpCodeDisabled = FALSE;
1699 break;
1700
1701 case EFI_IFR_ONE_OF_OP:
1702 case EFI_IFR_ORDERED_LIST_OP:
1703 SuppressForOption = FALSE;
1704 break;
1705
1706 case EFI_IFR_DEFAULT_OP:
1707 InScopeDefault = FALSE;
1708 break;
1709
1710 default:
1711 if (IsExpressionOpCode (ScopeOpCode)) {
1712 if (InScopeDisable) {
1713 //
1714 // Evaluate DisableIf expression
1715 //
1716 Status = EvaluateExpression (FormSet, CurrentForm, CurrentExpression);
1717 if (EFI_ERROR (Status)) {
1718 return Status;
1719 }
1720 if (CurrentExpression->Result.Type != EFI_IFR_TYPE_BOOLEAN) {
1721 return EFI_INVALID_PARAMETER;
1722 }
1723
1724 OpCodeDisabled = CurrentExpression->Result.Value.b;
1725 //
1726 // DisableIf Expression is only used once and not quequed, free it
1727 //
1728 DestroyExpression (CurrentExpression);
1729 }
1730
1731 //
1732 // End of current Expression
1733 //
1734 CurrentExpression = NULL;
1735 }
1736 break;
1737 }
1738 break;
1739
1740 default:
1741 break;
1742 }
1743 }
1744
1745 return EFI_SUCCESS;
1746 }
EFI Development Kit II mirror for PVE