]> git.proxmox.com Git - mirror_edk2.git/blob - EdkCompatibilityPkg/Compatibility/FrameworkHiiOnUefiHiiThunk/UefiIfrParser.c
projects / mirror_edk2.git / blob
? search:


faff074209333f7360a868bb269e97a23e5e161d
[mirror_edk2.git] / EdkCompatibilityPkg / Compatibility / FrameworkHiiOnUefiHiiThunk / UefiIfrParser.c
1 /** @file
2 Parser for IFR binary encoding.
3
4 Copyright (c) 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 "HiiDatabase.h"
16
17 #include "UefiIfrParserExpression.h"
18
19 UINT16 mStatementIndex;
20
21 BOOLEAN mInScopeSubtitle;
22 BOOLEAN mInScopeSuppress;
23 BOOLEAN mInScopeGrayOut;
24
25 EFI_GUID mFrameworkHiiCompatibilityGuid = EFI_IFR_FRAMEWORK_GUID;
26 extern EFI_GUID mTianoHiiIfrGuid;
27
28 LIST_ENTRY *
29 GetOneOfOptionMapEntryListHead (
30 IN CONST FORM_BROWSER_FORMSET *FormSet,
31 IN UINT16 QuestionId
32 )
33 {
34 LIST_ENTRY *Link;
35 ONE_OF_OPTION_MAP *Map;
36
37 Link = GetFirstNode (&FormSet->OneOfOptionMapListHead);
38
39 while (!IsNull (&FormSet->OneOfOptionMapListHead, Link)) {
40 Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
41 if (QuestionId == Map->QuestionId) {
42 return &Map->OneOfOptionMapEntryListHead;
43 }
44 Link = GetNextNode (&FormSet->OneOfOptionMapListHead, Link);
45 }
46
47 return NULL;
48 }
49
50 VOID
51 DestoryOneOfOptionMap (
52 IN LIST_ENTRY *OneOfOptionMapListHead
53 )
54 {
55 ONE_OF_OPTION_MAP *Map;
56 ONE_OF_OPTION_MAP_ENTRY *MapEntry;
57 LIST_ENTRY *Link;
58 LIST_ENTRY *Link2;
59
60 while (!IsListEmpty (OneOfOptionMapListHead)) {
61 Link = GetFirstNode (OneOfOptionMapListHead);
62
63 Map = ONE_OF_OPTION_MAP_FROM_LINK (Link);
64
65 while (!IsListEmpty (&Map->OneOfOptionMapEntryListHead)) {
66 Link2 = GetFirstNode (&Map->OneOfOptionMapEntryListHead);
67
68 MapEntry = ONE_OF_OPTION_MAP_ENTRY_FROM_LINK (Link2);
69
70 RemoveEntryList (Link2);
71
72 FreePool (MapEntry);
73 }
74
75 RemoveEntryList (Link);
76 FreePool (Map);
77 }
78 }
79
80
81 /**
82 Initialize Statement header members.
83
84 @param OpCodeData Pointer of the raw OpCode data.
85 @param FormSet Pointer of the current FormSe.
86 @param Form Pointer of the current Form.
87
88 @return The Statement.
89
90 **/
91 FORM_BROWSER_STATEMENT *
92 CreateStatement (
93 IN UINT8 *OpCodeData,
94 IN OUT FORM_BROWSER_FORMSET *FormSet,
95 IN OUT FORM_BROWSER_FORM *Form
96 )
97 {
98 FORM_BROWSER_STATEMENT *Statement;
99 EFI_IFR_STATEMENT_HEADER *StatementHdr;
100
101 if (Form == NULL) {
102 //
103 // We are currently not in a Form Scope, so just skip this Statement
104 //
105 return NULL;
106 }
107
108 Statement = &FormSet->StatementBuffer[mStatementIndex];
109 mStatementIndex++;
110
111 InitializeListHead (&Statement->DefaultListHead);
112 InitializeListHead (&Statement->OptionListHead);
113
114 Statement->Signature = FORM_BROWSER_STATEMENT_SIGNATURE;
115
116 Statement->Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
117
118 StatementHdr = (EFI_IFR_STATEMENT_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
119 CopyMem (&Statement->Prompt, &StatementHdr->Prompt, sizeof (EFI_STRING_ID));
120 CopyMem (&Statement->Help, &StatementHdr->Help, sizeof (EFI_STRING_ID));
121
122 Statement->InSubtitle = mInScopeSubtitle;
123
124 //
125 // Insert this Statement into current Form
126 //
127 InsertTailList (&Form->StatementListHead, &Statement->Link);
128
129 return Statement;
130 }
131
132 /**
133 Initialize Question's members.
134
135 @param OpCodeData Pointer of the raw OpCode data.
136 @param FormSet Pointer of the current FormSet.
137 @param Form Pointer of the current Form.
138
139 @return The Question.
140
141 **/
142 FORM_BROWSER_STATEMENT *
143 CreateQuestion (
144 IN UINT8 *OpCodeData,
145 IN OUT FORM_BROWSER_FORMSET *FormSet,
146 IN OUT FORM_BROWSER_FORM *Form
147 )
148 {
149 FORM_BROWSER_STATEMENT *Statement;
150 EFI_IFR_QUESTION_HEADER *QuestionHdr;
151 LIST_ENTRY *Link;
152 FORMSET_STORAGE *Storage;
153
154 Statement = CreateStatement (OpCodeData, FormSet, Form);
155 if (Statement == NULL) {
156 return NULL;
157 }
158
159 QuestionHdr = (EFI_IFR_QUESTION_HEADER *) (OpCodeData + sizeof (EFI_IFR_OP_HEADER));
160 CopyMem (&Statement->QuestionId, &QuestionHdr->QuestionId, sizeof (EFI_QUESTION_ID));
161 CopyMem (&Statement->VarStoreId, &QuestionHdr->VarStoreId, sizeof (EFI_VARSTORE_ID));
162 CopyMem (&Statement->VarStoreInfo.VarOffset, &QuestionHdr->VarStoreInfo.VarOffset, sizeof (UINT16));
163
164 if (FormSet->MaxQuestionId < QuestionHdr->QuestionId) {
165 FormSet->MaxQuestionId = QuestionHdr->QuestionId;
166 }
167
168 Statement->QuestionFlags = QuestionHdr->Flags;
169
170 if (Statement->VarStoreId == 0) {
171 //
172 // VarStoreId of zero indicates no variable storage
173 //
174 return Statement;
175 }
176
177 //
178 // Find Storage for this Question
179 //
180 Link = GetFirstNode (&FormSet->StorageListHead);
181 while (!IsNull (&FormSet->StorageListHead, Link)) {
182 Storage = FORMSET_STORAGE_FROM_LINK (Link);
183
184 if (Storage->VarStoreId == Statement->VarStoreId) {
185 Statement->Storage = Storage;
186 break;
187 }
188
189 Link = GetNextNode (&FormSet->StorageListHead, Link);
190 }
191 ASSERT (Statement->Storage != NULL);
192
193 return Statement;
194 }
195
196 /**
197 Allocate a FORMSET_STORAGE data structure and insert to FormSet Storage List.
198
199 @param FormSet Pointer of the current FormSet
200
201 @return Pointer to a FORMSET_STORAGE data structure.
202
203 **/
204 FORMSET_STORAGE *
205 CreateStorage (
206 IN FORM_BROWSER_FORMSET *FormSet
207 )
208 {
209 FORMSET_STORAGE *Storage;
210
211 Storage = AllocateZeroPool (sizeof (FORMSET_STORAGE));
212 Storage->Signature = FORMSET_STORAGE_SIGNATURE;
213 InsertTailList (&FormSet->StorageListHead, &Storage->Link);
214
215 return Storage;
216 }
217
218 /**
219 Free resources of a storage
220
221 @param Storage Pointer of the storage
222
223 @return None.
224
225 **/
226 VOID
227 DestroyStorage (
228 IN FORMSET_STORAGE *Storage
229 )
230 {
231 if (Storage == NULL) {
232 return;
233 }
234
235 if (Storage->Name!= NULL) {
236 FreePool (Storage->Name);
237 }
238
239 FreePool (Storage);
240 }
241
242
243 /**
244 Free resources of a Statement
245
246 @param Statement Pointer of the Statement
247
248 @return None.
249
250 **/
251 VOID
252 DestroyStatement (
253 IN OUT FORM_BROWSER_STATEMENT *Statement
254 )
255 {
256 LIST_ENTRY *Link;
257 QUESTION_DEFAULT *Default;
258 QUESTION_OPTION *Option;
259
260 //
261 // Free Default value List
262 //
263 while (!IsListEmpty (&Statement->DefaultListHead)) {
264 Link = GetFirstNode (&Statement->DefaultListHead);
265 Default = QUESTION_DEFAULT_FROM_LINK (Link);
266 RemoveEntryList (&Default->Link);
267
268 gBS->FreePool (Default);
269 }
270
271 //
272 // Free Options List
273 //
274 while (!IsListEmpty (&Statement->OptionListHead)) {
275 Link = GetFirstNode (&Statement->OptionListHead);
276 Option = QUESTION_OPTION_FROM_LINK (Link);
277 RemoveEntryList (&Option->Link);
278
279 gBS->FreePool (Option);
280 }
281
282 }
283
284
285
286 /**
287 Free resources of a Form
288
289 @param Form Pointer of the Form
290
291 @return None.
292
293 **/
294 VOID
295 DestroyForm (
296 IN OUT FORM_BROWSER_FORM *Form
297 )
298 {
299 LIST_ENTRY *Link;
300 FORM_BROWSER_STATEMENT *Statement;
301
302 //
303 // Free Statements/Questions
304 //
305 while (!IsListEmpty (&Form->StatementListHead)) {
306 Link = GetFirstNode (&Form->StatementListHead);
307 Statement = FORM_BROWSER_STATEMENT_FROM_LINK (Link);
308 RemoveEntryList (&Statement->Link);
309
310 DestroyStatement (Statement);
311 }
312
313 //
314 // Free this Form
315 //
316 gBS->FreePool (Form);
317 }
318
319
320 /**
321 Free resources allocated for a FormSet
322
323 @param FormSet Pointer of the FormSet
324
325 @return None.
326
327 **/
328 VOID
329 DestroyFormSet (
330 IN OUT FORM_BROWSER_FORMSET *FormSet
331 )
332 {
333 LIST_ENTRY *Link;
334 FORMSET_STORAGE *Storage;
335 FORMSET_DEFAULTSTORE *DefaultStore;
336 FORM_BROWSER_FORM *Form;
337
338 //
339 // Free IFR binary buffer
340 //
341 FreePool (FormSet->IfrBinaryData);
342
343 //
344 // Free FormSet Storage
345 //
346 if (FormSet->StorageListHead.ForwardLink != NULL) {
347 while (!IsListEmpty (&FormSet->StorageListHead)) {
348 Link = GetFirstNode (&FormSet->StorageListHead);
349 Storage = FORMSET_STORAGE_FROM_LINK (Link);
350 RemoveEntryList (&Storage->Link);
351
352 DestroyStorage (Storage);
353 }
354 }
355
356 //
357 // Free FormSet Default Store
358 //
359 if (FormSet->DefaultStoreListHead.ForwardLink != NULL) {
360 while (!IsListEmpty (&FormSet->DefaultStoreListHead)) {
361 Link = GetFirstNode (&FormSet->DefaultStoreListHead);
362 DefaultStore = FORMSET_DEFAULTSTORE_FROM_LINK (Link);
363 RemoveEntryList (&DefaultStore->Link);
364
365 gBS->FreePool (DefaultStore);
366 }
367 }
368
369 //
370 // Free Forms
371 //
372 if (FormSet->FormListHead.ForwardLink != NULL) {
373 while (!IsListEmpty (&FormSet->FormListHead)) {
374 Link = GetFirstNode (&FormSet->FormListHead);
375 Form = FORM_BROWSER_FORM_FROM_LINK (Link);
376 RemoveEntryList (&Form->Link);
377
378 DestroyForm (Form);
379 }
380 }
381
382 if (FormSet->StatementBuffer != NULL) {
383 FreePool (FormSet->StatementBuffer);
384 }
385
386 DestoryOneOfOptionMap (&FormSet->OneOfOptionMapListHead);
387
388 if (FormSet->OriginalDefaultVarStoreName != NULL) {
389 FreePool (FormSet->OriginalDefaultVarStoreName);
390 }
391
392 FreePool (FormSet);
393 }
394
395
396 /**
397 Tell whether this Operand is an Expression OpCode or not
398
399 @param Operand Operand of an IFR OpCode.
400
401 @retval TRUE This is an Expression OpCode.
402 @retval FALSE Not an Expression OpCode.
403
404 **/
405 BOOLEAN
406 IsExpressionOpCode (
407 IN UINT8 Operand
408 )
409 {
410 if (((Operand >= EFI_IFR_EQ_ID_VAL_OP) && (Operand <= EFI_IFR_NOT_OP)) ||
411 ((Operand >= EFI_IFR_MATCH_OP) && (Operand <= EFI_IFR_SET_OP)) ||
412 ((Operand >= EFI_IFR_EQUAL_OP) && (Operand <= EFI_IFR_SPAN_OP)) ||
413 (Operand == EFI_IFR_CATENATE_OP) ||
414 (Operand == EFI_IFR_TO_LOWER_OP) ||
415 (Operand == EFI_IFR_TO_UPPER_OP) ||
416 (Operand == EFI_IFR_MAP_OP) ||
417 (Operand == EFI_IFR_VERSION_OP) ||
418 (Operand == EFI_IFR_SECURITY_OP)) {
419 return TRUE;
420 } else {
421 return FALSE;
422 }
423 }
424
425
426 /**
427 Calculate number of Statemens(Questions) and Expression OpCodes.
428
429 @param FormSet The FormSet to be counted.
430 @param NumberOfStatement Number of Statemens(Questions)
431 @param NumberOfExpression Number of Expression OpCodes
432
433 @return None.
434
435 **/
436 VOID
437 CountOpCodes (
438 IN FORM_BROWSER_FORMSET *FormSet,
439 IN OUT UINT16 *NumberOfStatement,
440 IN OUT UINT16 *NumberOfExpression
441 )
442 {
443 UINT16 StatementCount;
444 UINT16 ExpressionCount;
445 UINT8 *OpCodeData;
446 UINTN Offset;
447 UINTN OpCodeLen;
448
449 Offset = 0;
450 StatementCount = 0;
451 ExpressionCount = 0;
452
453 while (Offset < FormSet->IfrBinaryLength) {
454 OpCodeData = FormSet->IfrBinaryData + Offset;
455 OpCodeLen = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
456 Offset += OpCodeLen;
457
458 if (IsExpressionOpCode (((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode)) {
459 ExpressionCount++;
460 } else {
461 StatementCount++;
462 }
463 }
464
465 *NumberOfStatement = StatementCount;
466 *NumberOfExpression = ExpressionCount;
467 }
468
469
470 /**
471 Parse opcodes in the formset IFR binary.
472
473 @param FormSet Pointer of the FormSet data structure.
474
475 @retval EFI_SUCCESS Opcode parse success.
476 @retval Other Opcode parse fail.
477
478 **/
479 EFI_STATUS
480 ParseOpCodes (
481 IN FORM_BROWSER_FORMSET *FormSet
482 )
483 {
484 EFI_STATUS Status;
485 UINT16 Index;
486 FORM_BROWSER_FORM *CurrentForm;
487 FORM_BROWSER_STATEMENT *CurrentStatement;
488 UINT8 Operand;
489 UINT8 Scope;
490 UINTN OpCodeOffset;
491 UINTN OpCodeLength;
492 UINT8 *OpCodeData;
493 UINT8 ScopeOpCode;
494 FORMSET_STORAGE *Storage;
495 FORMSET_DEFAULTSTORE *DefaultStore;
496 QUESTION_DEFAULT *CurrentDefault;
497 QUESTION_OPTION *CurrentOption;
498 CHAR8 *AsciiString;
499 UINT16 NumberOfStatement;
500 UINT16 NumberOfExpression;
501 EFI_IMAGE_ID *ImageId;
502 EFI_HII_VALUE *Value;
503 LIST_ENTRY *OneOfOptinMapEntryListHead;
504 EFI_IFR_GUID_OPTIONKEY *OptionMap;
505 ONE_OF_OPTION_MAP *OneOfOptionMap;
506 ONE_OF_OPTION_MAP_ENTRY *OneOfOptionMapEntry;
507 UINT8 OneOfType;
508 EFI_IFR_ONE_OF *OneOfOpcode;
509 HII_THUNK_CONTEXT *ThunkContext;
510 EFI_IFR_FORM_MAP_METHOD *MapMethod;
511
512 mInScopeSubtitle = FALSE;
513 mInScopeSuppress = FALSE;
514 mInScopeGrayOut = FALSE;
515 CurrentDefault = NULL;
516 CurrentOption = NULL;
517 MapMethod = NULL;
518 ThunkContext = UefiHiiHandleToThunkContext ((CONST HII_THUNK_PRIVATE_DATA*) mHiiThunkPrivateData, FormSet->HiiHandle);
519
520 //
521 // Set to a invalid value.
522 //
523 OneOfType = (UINT8) -1;
524
525 //
526 // Get the number of Statements and Expressions
527 //
528 CountOpCodes (FormSet, &NumberOfStatement, &NumberOfExpression);
529 FormSet->NumberOfStatement = NumberOfStatement;
530
531 mStatementIndex = 0;
532 FormSet->StatementBuffer = AllocateZeroPool (NumberOfStatement * sizeof (FORM_BROWSER_STATEMENT));
533 if (FormSet->StatementBuffer == NULL) {
534 return EFI_OUT_OF_RESOURCES;
535 }
536
537 InitializeListHead (&FormSet->StorageListHead);
538 InitializeListHead (&FormSet->DefaultStoreListHead);
539 InitializeListHead (&FormSet->FormListHead);
540 InitializeListHead (&FormSet->OneOfOptionMapListHead);
541
542 CurrentForm = NULL;
543 CurrentStatement = NULL;
544
545 ResetScopeStack ();
546
547 OpCodeOffset = 0;
548 while (OpCodeOffset < FormSet->IfrBinaryLength) {
549 OpCodeData = FormSet->IfrBinaryData + OpCodeOffset;
550
551 OpCodeLength = ((EFI_IFR_OP_HEADER *) OpCodeData)->Length;
552 OpCodeOffset += OpCodeLength;
553 Operand = ((EFI_IFR_OP_HEADER *) OpCodeData)->OpCode;
554 Scope = ((EFI_IFR_OP_HEADER *) OpCodeData)->Scope;
555
556 //
557 // If scope bit set, push onto scope stack
558 //
559 if (Scope != 0) {
560 PushScope (Operand);
561 }
562
563 if (IsExpressionOpCode (Operand)) {
564 continue;
565 }
566
567 //
568 // Parse the Opcode
569 //
570 switch (Operand) {
571
572 case EFI_IFR_FORM_SET_OP:
573 //
574 // check the formset GUID
575 //
576 if (!CompareGuid ((EFI_GUID *)(VOID *)&FormSet->Guid, (EFI_GUID *)(VOID *)&((EFI_IFR_FORM_SET *) OpCodeData)->Guid)) {
577 return EFI_INVALID_PARAMETER;
578 }
579
580 CopyMem (&FormSet->FormSetTitle, &((EFI_IFR_FORM_SET *) OpCodeData)->FormSetTitle, sizeof (EFI_STRING_ID));
581 CopyMem (&FormSet->Help, &((EFI_IFR_FORM_SET *) OpCodeData)->Help, sizeof (EFI_STRING_ID));
582 break;
583
584 case EFI_IFR_FORM_OP:
585 //
586 // Create a new Form for this FormSet
587 //
588 CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
589 CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
590
591 InitializeListHead (&CurrentForm->StatementListHead);
592
593 CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16));
594 CopyMem (&CurrentForm->FormTitle, &((EFI_IFR_FORM *) OpCodeData)->FormTitle, sizeof (EFI_STRING_ID));
595
596 //
597 // Insert into Form list of this FormSet
598 //
599 InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
600 break;
601
602 case EFI_IFR_FORM_MAP_OP:
603 //
604 // Create a new Form Map for this FormSet
605 //
606 CurrentForm = AllocateZeroPool (sizeof (FORM_BROWSER_FORM));
607 CurrentForm->Signature = FORM_BROWSER_FORM_SIGNATURE;
608
609 InitializeListHead (&CurrentForm->StatementListHead);
610
611 CopyMem (&CurrentForm->FormId, &((EFI_IFR_FORM *) OpCodeData)->FormId, sizeof (UINT16));
612 MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP));
613
614 //
615 // FormMap Form must contain at least one Map Method.
616 //
617 if (((EFI_IFR_OP_HEADER *) OpCodeData)->Length < ((UINTN) (UINT8 *) (MapMethod + 1) - (UINTN) OpCodeData)) {
618 return EFI_INVALID_PARAMETER;
619 }
620
621 //
622 // Try to find the standard form map method.
623 //
624 while (((UINTN) (UINT8 *) MapMethod - (UINTN) OpCodeData) < ((EFI_IFR_OP_HEADER *) OpCodeData)->Length) {
625 if (CompareGuid ((EFI_GUID *) (VOID *) &MapMethod->MethodIdentifier, &gEfiHiiStandardFormGuid)) {
626 CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID));
627 break;
628 }
629 MapMethod ++;
630 }
631 //
632 // If the standard form map method is not found, the first map method title will be used.
633 //
634 if (CurrentForm->FormTitle == 0) {
635 MapMethod = (EFI_IFR_FORM_MAP_METHOD *) (OpCodeData + sizeof (EFI_IFR_FORM_MAP));
636 CopyMem (&CurrentForm->FormTitle, &MapMethod->MethodTitle, sizeof (EFI_STRING_ID));
637 }
638
639 //
640 // Insert into Form list of this FormSet
641 //
642 InsertTailList (&FormSet->FormListHead, &CurrentForm->Link);
643 break;
644
645 //
646 // Storage
647 //
648 case EFI_IFR_VARSTORE_OP:
649 //
650 // Create a buffer Storage for this FormSet
651 //
652 Storage = CreateStorage (FormSet);
653 Storage->Type = EFI_HII_VARSTORE_BUFFER;
654
655 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
656 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE *) OpCodeData)->Guid, sizeof (EFI_GUID));
657 CopyMem (&Storage->Size, &((EFI_IFR_VARSTORE *) OpCodeData)->Size, sizeof (UINT16));
658
659 AsciiString = (CHAR8 *) ((EFI_IFR_VARSTORE *) OpCodeData)->Name;
660 Storage->Name = AllocateZeroPool (AsciiStrSize (AsciiString) * 2);
661 ASSERT (Storage->Name != NULL);
662 for (Index = 0; AsciiString[Index] != 0; Index++) {
663 Storage->Name[Index] = (CHAR16) AsciiString[Index];
664 }
665
666 break;
667
668 case EFI_IFR_VARSTORE_NAME_VALUE_OP:
669 //
670 // Framework IFR doesn't support Name/Value VarStore opcode
671 //
672 if (ThunkContext != NULL && ThunkContext->ByFrameworkHiiNewPack) {
673 ASSERT (FALSE);
674 }
675
676 //
677 // Create a name/value Storage for this FormSet
678 //
679 Storage = CreateStorage (FormSet);
680 Storage->Type = EFI_HII_VARSTORE_NAME_VALUE;
681
682 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
683 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_NAME_VALUE *) OpCodeData)->Guid, sizeof (EFI_GUID));
684
685 break;
686
687 case EFI_IFR_VARSTORE_EFI_OP:
688 //
689 // Create a EFI variable Storage for this FormSet
690 //
691 Storage = CreateStorage (FormSet);
692 Storage->Type = EFI_HII_VARSTORE_EFI_VARIABLE;
693
694 CopyMem (&Storage->VarStoreId, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->VarStoreId, sizeof (EFI_VARSTORE_ID));
695 CopyMem (&Storage->Guid, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Guid, sizeof (EFI_GUID));
696 CopyMem (&Storage->Attributes, &((EFI_IFR_VARSTORE_EFI *) OpCodeData)->Attributes, sizeof (UINT32));
697 break;
698
699 //
700 // DefaultStore
701 //
702 case EFI_IFR_DEFAULTSTORE_OP:
703 DefaultStore = AllocateZeroPool (sizeof (FORMSET_DEFAULTSTORE));
704 DefaultStore->Signature = FORMSET_DEFAULTSTORE_SIGNATURE;
705
706 CopyMem (&DefaultStore->DefaultId, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultId, sizeof (UINT16));
707 CopyMem (&DefaultStore->DefaultName, &((EFI_IFR_DEFAULTSTORE *) OpCodeData)->DefaultName, sizeof (EFI_STRING_ID));
708
709 //
710 // Insert to DefaultStore list of this Formset
711 //
712 InsertTailList (&FormSet->DefaultStoreListHead, &DefaultStore->Link);
713 break;
714
715 //
716 // Statements
717 //
718 case EFI_IFR_SUBTITLE_OP:
719 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
720 ASSERT (CurrentStatement != NULL);
721 CurrentStatement->Flags = ((EFI_IFR_SUBTITLE *) OpCodeData)->Flags;
722
723 if (Scope != 0) {
724 mInScopeSubtitle = TRUE;
725 }
726 break;
727
728 case EFI_IFR_TEXT_OP:
729 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
730 ASSERT (CurrentStatement != NULL);
731
732 CopyMem (&CurrentStatement->TextTwo, &((EFI_IFR_TEXT *) OpCodeData)->TextTwo, sizeof (EFI_STRING_ID));
733 break;
734
735 //
736 // Questions
737 //
738 case EFI_IFR_ACTION_OP:
739 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
740 ASSERT (CurrentStatement != NULL);
741
742 if (OpCodeLength == sizeof (EFI_IFR_ACTION_1)) {
743 //
744 // No QuestionConfig present, so no configuration string will be processed
745 //
746 CurrentStatement->QuestionConfig = 0;
747 } else {
748 CopyMem (&CurrentStatement->QuestionConfig, &((EFI_IFR_ACTION *) OpCodeData)->QuestionConfig, sizeof (EFI_STRING_ID));
749 }
750 break;
751
752 case EFI_IFR_RESET_BUTTON_OP:
753 CurrentStatement = CreateStatement (OpCodeData, FormSet, CurrentForm);
754 ASSERT (CurrentStatement != NULL);
755 CopyMem (&CurrentStatement->DefaultId, &((EFI_IFR_RESET_BUTTON *) OpCodeData)->DefaultId, sizeof (EFI_DEFAULT_ID));
756 break;
757
758 case EFI_IFR_REF_OP:
759 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
760 ASSERT (CurrentStatement != NULL);
761
762 CopyMem (&CurrentStatement->RefFormId, &((EFI_IFR_REF *) OpCodeData)->FormId, sizeof (EFI_FORM_ID));
763 if (OpCodeLength >= sizeof (EFI_IFR_REF2)) {
764 CopyMem (&CurrentStatement->RefQuestionId, &((EFI_IFR_REF2 *) OpCodeData)->QuestionId, sizeof (EFI_QUESTION_ID));
765
766 if (OpCodeLength >= sizeof (EFI_IFR_REF3)) {
767 CopyMem (&CurrentStatement->RefFormSetId, &((EFI_IFR_REF3 *) OpCodeData)->FormSetId, sizeof (EFI_GUID));
768
769 if (OpCodeLength >= sizeof (EFI_IFR_REF4)) {
770 CopyMem (&CurrentStatement->RefDevicePath, &((EFI_IFR_REF4 *) OpCodeData)->DevicePath, sizeof (EFI_STRING_ID));
771 }
772 }
773 }
774 break;
775
776 case EFI_IFR_ONE_OF_OP:
777 case EFI_IFR_NUMERIC_OP:
778 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
779 ASSERT (CurrentStatement != NULL);
780
781 CurrentStatement->Flags = ((EFI_IFR_ONE_OF *) OpCodeData)->Flags;
782 Value = &CurrentStatement->HiiValue;
783
784 switch (CurrentStatement->Flags & EFI_IFR_NUMERIC_SIZE) {
785 case EFI_IFR_NUMERIC_SIZE_1:
786 CurrentStatement->Minimum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MinValue;
787 CurrentStatement->Maximum = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.MaxValue;
788 CurrentStatement->Step = ((EFI_IFR_NUMERIC *) OpCodeData)->data.u8.Step;
789 CurrentStatement->StorageWidth = sizeof (UINT8);
790 Value->Type = EFI_IFR_TYPE_NUM_SIZE_8;
791 break;
792
793 case EFI_IFR_NUMERIC_SIZE_2:
794 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MinValue, sizeof (UINT16));
795 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.MaxValue, sizeof (UINT16));
796 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u16.Step, sizeof (UINT16));
797 CurrentStatement->StorageWidth = sizeof (UINT16);
798 Value->Type = EFI_IFR_TYPE_NUM_SIZE_16;
799 break;
800
801 case EFI_IFR_NUMERIC_SIZE_4:
802 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MinValue, sizeof (UINT32));
803 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.MaxValue, sizeof (UINT32));
804 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u32.Step, sizeof (UINT32));
805 CurrentStatement->StorageWidth = sizeof (UINT32);
806 Value->Type = EFI_IFR_TYPE_NUM_SIZE_32;
807 break;
808
809 case EFI_IFR_NUMERIC_SIZE_8:
810 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MinValue, sizeof (UINT64));
811 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.MaxValue, sizeof (UINT64));
812 CopyMem (&CurrentStatement->Step, &((EFI_IFR_NUMERIC *) OpCodeData)->data.u64.Step, sizeof (UINT64));
813 CurrentStatement->StorageWidth = sizeof (UINT64);
814 Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
815 break;
816
817 default:
818 break;
819 }
820
821 if (Operand == EFI_IFR_ONE_OF_OP) {
822 OneOfOpcode = (EFI_IFR_ONE_OF *) OpCodeData;
823 OneOfType = (UINT8) (OneOfOpcode->Flags & EFI_IFR_NUMERIC_SIZE);
824 }
825 break;
826
827 case EFI_IFR_ORDERED_LIST_OP:
828 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
829 ASSERT (CurrentStatement != NULL);
830
831 CurrentStatement->Flags = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->Flags;
832 CurrentStatement->MaxContainers = ((EFI_IFR_ORDERED_LIST *) OpCodeData)->MaxContainers;
833 CurrentStatement->StorageWidth = (UINT16)(CurrentStatement->MaxContainers * sizeof (UINT8));
834
835 //
836 // No buffer type is defined in EFI_IFR_TYPE_VALUE, so a Configuration Driver
837 // has to use FormBrowser2.Callback() to retrieve the uncommited data for
838 // an interactive orderedlist (i.e. with EFI_IFR_FLAG_CALLBACK flag set).
839 //
840 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_OTHER;
841 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
842
843 break;
844
845 case EFI_IFR_CHECKBOX_OP:
846 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
847 ASSERT (CurrentStatement != NULL);
848
849 CurrentStatement->Flags = ((EFI_IFR_CHECKBOX *) OpCodeData)->Flags;
850 CurrentStatement->StorageWidth = sizeof (BOOLEAN);
851 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_BOOLEAN;
852
853 break;
854
855 case EFI_IFR_STRING_OP:
856 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
857 ASSERT (CurrentStatement != NULL);
858
859 //
860 // MinSize is the minimum number of characters that can be accepted for this opcode,
861 // MaxSize is the maximum number of characters that can be accepted for this opcode.
862 // The characters are stored as Unicode, so the storage width should multiply 2.
863 //
864 CurrentStatement->Minimum = ((EFI_IFR_STRING *) OpCodeData)->MinSize;
865 CurrentStatement->Maximum = ((EFI_IFR_STRING *) OpCodeData)->MaxSize;
866 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
867 CurrentStatement->Flags = ((EFI_IFR_STRING *) OpCodeData)->Flags;
868
869 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
870 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
871
872 break;
873
874 case EFI_IFR_PASSWORD_OP:
875 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
876 ASSERT (CurrentStatement != NULL);
877
878 //
879 // MinSize is the minimum number of characters that can be accepted for this opcode,
880 // MaxSize is the maximum number of characters that can be accepted for this opcode.
881 // The characters are stored as Unicode, so the storage width should multiply 2.
882 //
883 CopyMem (&CurrentStatement->Minimum, &((EFI_IFR_PASSWORD *) OpCodeData)->MinSize, sizeof (UINT16));
884 CopyMem (&CurrentStatement->Maximum, &((EFI_IFR_PASSWORD *) OpCodeData)->MaxSize, sizeof (UINT16));
885 CurrentStatement->StorageWidth = (UINT16)((UINTN) CurrentStatement->Maximum * sizeof (UINT16));
886
887 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_STRING;
888 CurrentStatement->BufferValue = AllocateZeroPool (CurrentStatement->StorageWidth);
889
890 break;
891
892 case EFI_IFR_DATE_OP:
893 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
894 ASSERT (CurrentStatement != NULL);
895
896 CurrentStatement->Flags = ((EFI_IFR_DATE *) OpCodeData)->Flags;
897 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_DATE;
898
899 break;
900
901 case EFI_IFR_TIME_OP:
902 CurrentStatement = CreateQuestion (OpCodeData, FormSet, CurrentForm);
903 ASSERT (CurrentStatement != NULL);
904
905 CurrentStatement->Flags = ((EFI_IFR_TIME *) OpCodeData)->Flags;
906 CurrentStatement->HiiValue.Type = EFI_IFR_TYPE_TIME;
907
908 break;
909
910 //
911 // Default
912 //
913 case EFI_IFR_DEFAULT_OP:
914 //
915 // EFI_IFR_DEFAULT appear in scope of a Question,
916 // It creates a default value for the current question.
917 // A Question may have more than one Default value which have different default types.
918 //
919 CurrentDefault = AllocateZeroPool (sizeof (QUESTION_DEFAULT));
920 CurrentDefault->Signature = QUESTION_DEFAULT_SIGNATURE;
921
922 CurrentDefault->Value.Type = ((EFI_IFR_DEFAULT *) OpCodeData)->Type;
923 CopyMem (&CurrentDefault->DefaultId, &((EFI_IFR_DEFAULT *) OpCodeData)->DefaultId, sizeof (UINT16));
924 CopyMem (&CurrentDefault->Value.Value, &((EFI_IFR_DEFAULT *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
925 ExtendValueToU64 (&CurrentDefault->Value);
926
927 //
928 // Insert to Default Value list of current Question
929 //
930 InsertTailList (&CurrentStatement->DefaultListHead, &CurrentDefault->Link);
931
932 break;
933
934 //
935 // Option
936 //
937 case EFI_IFR_ONE_OF_OPTION_OP:
938 //
939 // EFI_IFR_ONE_OF_OPTION appear in scope of a Question.
940 // It create a selection for use in current Question.
941 //
942 CurrentOption = AllocateZeroPool (sizeof (QUESTION_OPTION));
943 CurrentOption->Signature = QUESTION_OPTION_SIGNATURE;
944
945 CurrentOption->Flags = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Flags;
946 CurrentOption->Value.Type = ((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Type;
947 CopyMem (&CurrentOption->Text, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Option, sizeof (EFI_STRING_ID));
948 CopyMem (&CurrentOption->Value.Value, &((EFI_IFR_ONE_OF_OPTION *) OpCodeData)->Value, sizeof (EFI_IFR_TYPE_VALUE));
949 ExtendValueToU64 (&CurrentOption->Value);
950
951 //
952 // Insert to Option list of current Question
953 //
954 InsertTailList (&CurrentStatement->OptionListHead, &CurrentOption->Link);
955 break;
956
957 //
958 // Conditional
959 //
960 case EFI_IFR_NO_SUBMIT_IF_OP:
961 case EFI_IFR_INCONSISTENT_IF_OP:
962 break;
963
964 case EFI_IFR_SUPPRESS_IF_OP:
965 break;
966
967 case EFI_IFR_GRAY_OUT_IF_OP:
968 break;
969
970 case EFI_IFR_DISABLE_IF_OP:
971 //
972 // Framework IFR doesn't support DisableIf opcode
973 //
974 if (ThunkContext != NULL && ThunkContext->ByFrameworkHiiNewPack) {
975 ASSERT (FALSE);
976 }
977
978 //
979 // Expression
980 //
981 case EFI_IFR_VALUE_OP:
982 case EFI_IFR_READ_OP:
983 case EFI_IFR_WRITE_OP:
984 break;
985
986 case EFI_IFR_RULE_OP:
987 break;
988
989 //
990 // Image
991 //
992 case EFI_IFR_IMAGE_OP:
993 //
994 // Get ScopeOpcode from top of stack
995 //
996 PopScope (&ScopeOpCode);
997 PushScope (ScopeOpCode);
998
999 switch (ScopeOpCode) {
1000 case EFI_IFR_FORM_SET_OP:
1001 ImageId = &FormSet->ImageId;
1002 break;
1003
1004 case EFI_IFR_FORM_OP:
1005 case EFI_IFR_FORM_MAP_OP:
1006 ImageId = &CurrentForm->ImageId;
1007 break;
1008
1009 case EFI_IFR_ONE_OF_OPTION_OP:
1010 ImageId = &CurrentOption->ImageId;
1011 break;
1012
1013 default:
1014 //
1015 // Make sure CurrentStatement is not NULL.
1016 // If it is NULL, 1) ParseOpCodes functions may parse the IFR wrongly. Or 2) the IFR
1017 // file is wrongly generated by tools such as VFR Compiler.
1018 //
1019 ASSERT (CurrentStatement != NULL);
1020 ImageId = &CurrentStatement->ImageId;
1021 break;
1022 }
1023
1024 ASSERT (ImageId != NULL);
1025 CopyMem (ImageId, &((EFI_IFR_IMAGE *) OpCodeData)->Id, sizeof (EFI_IMAGE_ID));
1026 break;
1027
1028 //
1029 // Refresh
1030 //
1031 case EFI_IFR_REFRESH_OP:
1032 ASSERT (CurrentStatement != NULL);
1033 CurrentStatement->RefreshInterval = ((EFI_IFR_REFRESH *) OpCodeData)->RefreshInterval;
1034 break;
1035
1036 //
1037 // Vendor specific
1038 //
1039 case EFI_IFR_GUID_OP:
1040 OptionMap = (EFI_IFR_GUID_OPTIONKEY *) OpCodeData;
1041
1042 if (CompareGuid (&mTianoHiiIfrGuid, (EFI_GUID *)(OpCodeData + sizeof (EFI_IFR_OP_HEADER)))) {
1043 //
1044 // Tiano specific GUIDed opcodes
1045 //
1046 switch (((EFI_IFR_GUID_LABEL *) OpCodeData)->ExtendOpCode) {
1047 case EFI_IFR_EXTEND_OP_LABEL:
1048 //
1049 // just ignore label
1050 //
1051 break;
1052
1053
1054 case EFI_IFR_EXTEND_OP_CLASS:
1055 CopyMem (&FormSet->Class, &((EFI_IFR_GUID_CLASS *) OpCodeData)->Class, sizeof (UINT16));
1056 break;
1057
1058 case EFI_IFR_EXTEND_OP_SUBCLASS:
1059 CopyMem (&FormSet->SubClass, &((EFI_IFR_GUID_SUBCLASS *) OpCodeData)->SubClass, sizeof (UINT16));
1060 break;
1061
1062 default:
1063 break;
1064 }
1065 } else if (CompareGuid ((EFI_GUID *)(VOID *)&OptionMap->Guid, &mFrameworkHiiCompatibilityGuid)) {
1066 if (OptionMap->ExtendOpCode == EFI_IFR_EXTEND_OP_OPTIONKEY) {
1067 OneOfOptinMapEntryListHead = GetOneOfOptionMapEntryListHead (FormSet, OptionMap->QuestionId);
1068 if (OneOfOptinMapEntryListHead == NULL) {
1069 OneOfOptionMap = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP));
1070 ASSERT (OneOfOptionMap != NULL);
1071
1072 OneOfOptionMap->Signature = ONE_OF_OPTION_MAP_SIGNATURE;
1073 OneOfOptionMap->QuestionId = OptionMap->QuestionId;
1074
1075 //
1076 // Make sure OneOfType is initialized.
1077 //
1078 ASSERT (OneOfType != (UINT8) -1);
1079 OneOfOptionMap->ValueType = OneOfType;
1080 InitializeListHead (&OneOfOptionMap->OneOfOptionMapEntryListHead);
1081 OneOfOptinMapEntryListHead = &OneOfOptionMap->OneOfOptionMapEntryListHead;
1082 InsertTailList (&FormSet->OneOfOptionMapListHead, &OneOfOptionMap->Link);
1083 }
1084 OneOfOptionMapEntry = AllocateZeroPool (sizeof (ONE_OF_OPTION_MAP_ENTRY));
1085 ASSERT (OneOfOptionMapEntry != NULL);
1086
1087 OneOfOptionMapEntry->Signature = ONE_OF_OPTION_MAP_ENTRY_SIGNATURE;
1088 OneOfOptionMapEntry->FwKey = OptionMap->KeyValue;
1089 CopyMem (&OneOfOptionMapEntry->Value, &OptionMap->OptionValue, sizeof (EFI_IFR_TYPE_VALUE));
1090
1091 InsertTailList (OneOfOptinMapEntryListHead, &OneOfOptionMapEntry->Link);
1092 }
1093 }
1094 break;
1095
1096 //
1097 // Scope End
1098 //
1099 case EFI_IFR_END_OP:
1100 Status = PopScope (&ScopeOpCode);
1101 if (EFI_ERROR (Status)) {
1102 ResetScopeStack ();
1103 return Status;
1104 }
1105
1106 switch (ScopeOpCode) {
1107 case EFI_IFR_FORM_SET_OP:
1108 //
1109 // End of FormSet, update FormSet IFR binary length
1110 // to stop parsing substantial OpCodes
1111 //
1112 FormSet->IfrBinaryLength = OpCodeOffset;
1113 break;
1114
1115 case EFI_IFR_FORM_OP:
1116 case EFI_IFR_FORM_MAP_OP:
1117 //
1118 // End of Form
1119 //
1120 CurrentForm = NULL;
1121 break;
1122
1123 case EFI_IFR_ONE_OF_OPTION_OP:
1124 //
1125 // End of Option
1126 //
1127 CurrentOption = NULL;
1128 break;
1129
1130 case EFI_IFR_SUBTITLE_OP:
1131 mInScopeSubtitle = FALSE;
1132 break;
1133
1134 case EFI_IFR_NO_SUBMIT_IF_OP:
1135 case EFI_IFR_INCONSISTENT_IF_OP:
1136 //
1137 // Ignore end of EFI_IFR_NO_SUBMIT_IF and EFI_IFR_INCONSISTENT_IF
1138 //
1139 break;
1140
1141 case EFI_IFR_GRAY_OUT_IF_OP:
1142 mInScopeGrayOut = FALSE;
1143 break;
1144
1145 default:
1146 if (IsExpressionOpCode (ScopeOpCode)) {
1147 }
1148 break;
1149 }
1150 break;
1151
1152 default:
1153 break;
1154 }
1155 }
1156
1157 return EFI_SUCCESS;
1158 }
1159
1160
1161
1162
EFI Development Kit II mirror for PVE