1 /*++ 2 3 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR> 4 This program and the accompanying materials 5 are licensed and made available under the terms and conditions of the BSD License 6 which accompanies this distribution. The full text of the license may be found at 7 http://opensource.org/licenses/bsd-license.php 8 9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 11 12 Module Name: 13 14 VfrFormPkg.cpp 15 16 Abstract: 17 18 --*/ 19 20 #include "stdio.h" 21 #include "VfrFormPkg.h" 22 23 /* 24 * The definition of CFormPkg's member function 25 */ 26 27 SPendingAssign::SPendingAssign ( 28 IN INT8 *Key, 29 IN VOID *Addr, 30 IN UINT32 Len, 31 IN UINT32 LineNo, 32 IN INT8 *Msg 33 ) 34 { 35 mKey = NULL; 36 mAddr = Addr; 37 mLen = Len; 38 mFlag = PENDING; 39 mLineNo = LineNo; 40 mMsg = NULL; 41 mNext = NULL; 42 43 if (Key != NULL) { 44 mKey = new INT8[strlen (Key) + 1]; 45 if (mKey != NULL) { 46 strcpy (mKey, Key); 47 } 48 } 49 50 if (Msg != NULL) { 51 mMsg = new INT8[strlen (Msg) + 1]; 52 if (mMsg != NULL) { 53 strcpy (mMsg, Msg); 54 } 55 } 56 } 57 58 SPendingAssign::~SPendingAssign ( 59 VOID 60 ) 61 { 62 if (mKey != NULL) { 63 delete mKey; 64 } 65 mAddr = NULL; 66 mLen = 0; 67 mLineNo = 0; 68 if (mMsg != NULL) { 69 delete mMsg; 70 } 71 mNext = NULL; 72 } 73 74 VOID 75 SPendingAssign::SetAddrAndLen ( 76 IN VOID *Addr, 77 IN UINT32 LineNo 78 ) 79 { 80 mAddr = Addr; 81 mLineNo = LineNo; 82 } 83 84 VOID 85 SPendingAssign::AssignValue ( 86 IN VOID *Addr, 87 IN UINT32 Len 88 ) 89 { 90 memcpy (mAddr, Addr, (mLen < Len ? mLen : Len)); 91 mFlag = ASSIGNED; 92 } 93 94 INT8 * 95 SPendingAssign::GetKey ( 96 VOID 97 ) 98 { 99 return mKey; 100 } 101 102 CFormPkg::CFormPkg ( 103 IN UINT32 BufferSize = 4096 104 ) 105 { 106 CHAR8 *BufferStart; 107 CHAR8 *BufferEnd; 108 SBufferNode *Node; 109 110 mPkgLength = 0; 111 mBufferNodeQueueHead = NULL; 112 mCurrBufferNode = NULL; 113 114 Node = new SBufferNode; 115 if (Node == NULL) { 116 return ; 117 } 118 BufferStart = new CHAR8[BufferSize]; 119 if (BufferStart == NULL) { 120 return; 121 } 122 BufferEnd = BufferStart + BufferSize; 123 124 memset (BufferStart, 0, BufferSize); 125 Node->mBufferStart = BufferStart; 126 Node->mBufferEnd = BufferEnd; 127 Node->mBufferFree = BufferStart; 128 Node->mNext = NULL; 129 130 mBufferSize = BufferSize; 131 mBufferNodeQueueHead = Node; 132 mBufferNodeQueueTail = Node; 133 mCurrBufferNode = Node; 134 } 135 136 CFormPkg::~CFormPkg () 137 { 138 SBufferNode *pBNode; 139 SPendingAssign *pPNode; 140 141 while (mBufferNodeQueueHead != NULL) { 142 pBNode = mBufferNodeQueueHead; 143 mBufferNodeQueueHead = mBufferNodeQueueHead->mNext; 144 if (pBNode->mBufferStart != NULL) { 145 delete pBNode->mBufferStart; 146 delete pBNode; 147 } 148 } 149 mBufferNodeQueueTail = NULL; 150 mCurrBufferNode = NULL; 151 152 while (PendingAssignList != NULL) { 153 pPNode = PendingAssignList; 154 PendingAssignList = PendingAssignList->mNext; 155 delete pPNode; 156 } 157 PendingAssignList = NULL; 158 } 159 160 CHAR8 * 161 CFormPkg::IfrBinBufferGet ( 162 IN UINT32 Len 163 ) 164 { 165 CHAR8 *BinBuffer = NULL; 166 167 if ((Len == 0) || (Len > mBufferSize)) { 168 return NULL; 169 } 170 171 if ((mCurrBufferNode->mBufferFree + Len) <= mCurrBufferNode->mBufferEnd) { 172 BinBuffer = mCurrBufferNode->mBufferFree; 173 mCurrBufferNode->mBufferFree += Len; 174 } else { 175 SBufferNode *Node; 176 177 Node = new SBufferNode; 178 if (Node == NULL) { 179 return NULL; 180 } 181 182 Node->mBufferStart = new CHAR8[mBufferSize]; 183 if (Node->mBufferStart == NULL) { 184 delete Node; 185 return NULL; 186 } else { 187 memset (Node->mBufferStart, 0, mBufferSize); 188 Node->mBufferEnd = Node->mBufferStart + mBufferSize; 189 Node->mBufferFree = Node->mBufferStart; 190 Node->mNext = NULL; 191 } 192 193 if (mBufferNodeQueueTail == NULL) { 194 mBufferNodeQueueHead = mBufferNodeQueueTail = Node; 195 } else { 196 mBufferNodeQueueTail->mNext = Node; 197 mBufferNodeQueueTail = Node; 198 } 199 mCurrBufferNode = Node; 200 201 // 202 // Now try again. 203 // 204 BinBuffer = mCurrBufferNode->mBufferFree; 205 mCurrBufferNode->mBufferFree += Len; 206 } 207 208 mPkgLength += Len; 209 210 return BinBuffer; 211 } 212 213 inline 214 UINT32 215 CFormPkg::GetPkgLength ( 216 VOID 217 ) 218 { 219 return mPkgLength; 220 } 221 222 VOID 223 CFormPkg::Open ( 224 VOID 225 ) 226 { 227 mReadBufferNode = mBufferNodeQueueHead; 228 mReadBufferOffset = 0; 229 } 230 231 VOID 232 CFormPkg::Close ( 233 VOID 234 ) 235 { 236 mReadBufferNode = NULL; 237 mReadBufferOffset = 0; 238 } 239 240 UINT32 241 CFormPkg::Read ( 242 IN CHAR8 *Buffer, 243 IN UINT32 Size 244 ) 245 { 246 UINT32 Index; 247 248 if ((Size == 0) || (Buffer == NULL)) { 249 return 0; 250 } 251 252 if (mReadBufferNode == NULL) { 253 return 0; 254 } 255 256 for (Index = 0; Index < Size; Index++) { 257 if ((mReadBufferNode->mBufferStart + mReadBufferOffset) < mReadBufferNode->mBufferFree) { 258 Buffer[Index] = mReadBufferNode->mBufferStart[mReadBufferOffset++]; 259 } else { 260 if ((mReadBufferNode = mReadBufferNode->mNext) == NULL) { 261 return Index; 262 } else { 263 mReadBufferOffset = 0; 264 Buffer[Index] = mReadBufferNode->mBufferStart[mReadBufferOffset++]; 265 } 266 } 267 } 268 269 return Size; 270 } 271 272 EFI_VFR_RETURN_CODE 273 CFormPkg::BuildPkgHdr ( 274 OUT EFI_HII_PACKAGE_HEADER **PkgHdr 275 ) 276 { 277 if (PkgHdr == NULL) { 278 return VFR_RETURN_FATAL_ERROR; 279 } 280 281 if (((*PkgHdr) = new EFI_HII_PACKAGE_HEADER) == NULL) { 282 return VFR_RETURN_OUT_FOR_RESOURCES; 283 } 284 285 (*PkgHdr)->Type = EFI_HII_PACKAGE_FORMS; 286 (*PkgHdr)->Length = mPkgLength + sizeof (EFI_HII_PACKAGE_HEADER); 287 return VFR_RETURN_SUCCESS; 288 } 289 290 EFI_VFR_RETURN_CODE 291 CFormPkg::BuildPkg ( 292 IN FILE *Output 293 ) 294 { 295 EFI_VFR_RETURN_CODE Ret; 296 CHAR8 Buffer[1024]; 297 UINT32 Size; 298 EFI_HII_PACKAGE_HEADER *PkgHdr; 299 300 if (Output == NULL) { 301 return VFR_RETURN_FATAL_ERROR; 302 } 303 304 if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) { 305 return Ret; 306 } 307 fwrite (PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER), 1, Output); 308 delete PkgHdr; 309 310 Open (); 311 while ((Size = Read (Buffer, 1024)) != 0) { 312 fwrite (Buffer, Size, 1, Output); 313 } 314 Close (); 315 316 return VFR_RETURN_SUCCESS; 317 } 318 319 VOID 320 CFormPkg::_WRITE_PKG_LINE ( 321 IN FILE *pFile, 322 IN UINT32 LineBytes, 323 IN INT8 *LineHeader, 324 IN INT8 *BlkBuf, 325 IN UINT32 BlkSize 326 ) 327 { 328 UINT32 Index; 329 330 if ((pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) { 331 return; 332 } 333 334 for (Index = 0; Index < BlkSize; Index++) { 335 if ((Index % LineBytes) == 0) { 336 fprintf (pFile, "\n%s", LineHeader); 337 } 338 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]); 339 } 340 } 341 342 VOID 343 CFormPkg::_WRITE_PKG_END ( 344 IN FILE *pFile, 345 IN UINT32 LineBytes, 346 IN INT8 *LineHeader, 347 IN INT8 *BlkBuf, 348 IN UINT32 BlkSize 349 ) 350 { 351 UINT32 Index; 352 353 if ((BlkSize == 0) || (pFile == NULL) || (LineHeader == NULL) || (BlkBuf == NULL)) { 354 return; 355 } 356 357 for (Index = 0; Index < BlkSize - 1; Index++) { 358 if ((Index % LineBytes) == 0) { 359 fprintf (pFile, "\n%s", LineHeader); 360 } 361 fprintf (pFile, "0x%02X, ", (UINT8)BlkBuf[Index]); 362 } 363 364 if ((Index % LineBytes) == 0) { 365 fprintf (pFile, "\n%s", LineHeader); 366 } 367 fprintf (pFile, "0x%02X\n", (UINT8)BlkBuf[Index]); 368 } 369 370 #define BYTES_PRE_LINE 0x10 371 372 EFI_VFR_RETURN_CODE 373 CFormPkg::GenCFile ( 374 IN INT8 *BaseName, 375 IN FILE *pFile 376 ) 377 { 378 EFI_VFR_RETURN_CODE Ret; 379 INT8 Buffer[BYTES_PRE_LINE * 8]; 380 EFI_HII_PACKAGE_HEADER *PkgHdr; 381 UINT32 PkgLength = 0; 382 UINT32 ReadSize = 0; 383 384 if ((BaseName == NULL) || (pFile == NULL)) { 385 return VFR_RETURN_FATAL_ERROR; 386 } 387 388 fprintf (pFile, "\nunsigned char %sBin[] = {\n", BaseName); 389 390 if ((Ret = BuildPkgHdr(&PkgHdr)) != VFR_RETURN_SUCCESS) { 391 return Ret; 392 } 393 394 fprintf (pFile, " // ARRAY LENGTH\n"); 395 PkgLength = PkgHdr->Length + sizeof (UINT32); 396 _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (INT8 *)&PkgLength, sizeof (UINT32)); 397 398 fprintf (pFile, "\n\n // PACKAGE HEADER\n"); 399 _WRITE_PKG_LINE(pFile, BYTES_PRE_LINE, " ", (INT8 *)PkgHdr, sizeof (EFI_HII_PACKAGE_HEADER)); 400 PkgLength = sizeof (EFI_HII_PACKAGE_HEADER); 401 402 fprintf (pFile, "\n\n // PACKAGE DATA\n"); 403 Open (); 404 while ((ReadSize = Read ((CHAR8 *)Buffer, BYTES_PRE_LINE * 8)) != 0) { 405 PkgLength += ReadSize; 406 if (PkgLength < PkgHdr->Length) { 407 _WRITE_PKG_LINE (pFile, BYTES_PRE_LINE, " ", Buffer, ReadSize); 408 } else { 409 _WRITE_PKG_END (pFile, BYTES_PRE_LINE, " ", Buffer, ReadSize); 410 } 411 } 412 Close (); 413 414 delete PkgHdr; 415 fprintf (pFile, "\n};\n"); 416 417 return VFR_RETURN_SUCCESS; 418 } 419 420 EFI_VFR_RETURN_CODE 421 CFormPkg::AssignPending ( 422 IN INT8 *Key, 423 IN VOID *ValAddr, 424 IN UINT32 ValLen, 425 IN UINT32 LineNo, 426 IN INT8 *Msg 427 ) 428 { 429 SPendingAssign *pNew; 430 431 pNew = new SPendingAssign (Key, ValAddr, ValLen, LineNo, Msg); 432 if (pNew == NULL) { 433 return VFR_RETURN_OUT_FOR_RESOURCES; 434 } 435 436 pNew->mNext = PendingAssignList; 437 PendingAssignList = pNew; 438 return VFR_RETURN_SUCCESS; 439 } 440 441 VOID 442 CFormPkg::DoPendingAssign ( 443 IN INT8 *Key, 444 IN VOID *ValAddr, 445 IN UINT32 ValLen 446 ) 447 { 448 SPendingAssign *pNode; 449 450 if ((Key == NULL) || (ValAddr == NULL)) { 451 return; 452 } 453 454 for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) { 455 if (strcmp (pNode->mKey, Key) == 0) { 456 pNode->AssignValue (ValAddr, ValLen); 457 } 458 } 459 } 460 461 bool 462 CFormPkg::HavePendingUnassigned ( 463 VOID 464 ) 465 { 466 SPendingAssign *pNode; 467 468 for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) { 469 if (pNode->mFlag == PENDING) { 470 return TRUE; 471 } 472 } 473 474 return FALSE; 475 } 476 477 VOID 478 CFormPkg::PendingAssignPrintAll ( 479 VOID 480 ) 481 { 482 SPendingAssign *pNode; 483 484 for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) { 485 if (pNode->mFlag == PENDING) { 486 gCVfrErrorHandle.PrintMsg (pNode->mLineNo, pNode->mKey, "Error", pNode->mMsg); 487 } 488 } 489 } 490 491 CFormPkg gCFormPkg; 492 493 SIfrRecord::SIfrRecord ( 494 VOID 495 ) 496 { 497 mIfrBinBuf = NULL; 498 mBinBufLen = 0; 499 mLineNo = 0xFFFFFFFF; 500 mOffset = 0xFFFFFFFF; 501 mNext = NULL; 502 } 503 504 SIfrRecord::~SIfrRecord ( 505 VOID 506 ) 507 { 508 mIfrBinBuf = NULL; 509 mLineNo = 0xFFFFFFFF; 510 mOffset = 0xFFFFFFFF; 511 mBinBufLen = 0; 512 mNext = NULL; 513 } 514 515 CIfrRecordInfoDB::CIfrRecordInfoDB ( 516 VOID 517 ) 518 { 519 mSwitch = FALSE; 520 mRecordCount = EFI_IFR_RECORDINFO_IDX_START; 521 mIfrRecordListHead = NULL; 522 mIfrRecordListTail = NULL; 523 } 524 525 CIfrRecordInfoDB::~CIfrRecordInfoDB ( 526 VOID 527 ) 528 { 529 SIfrRecord *pNode; 530 531 while (mIfrRecordListHead != NULL) { 532 pNode = mIfrRecordListHead; 533 mIfrRecordListHead = mIfrRecordListHead->mNext; 534 delete pNode; 535 } 536 } 537 538 SIfrRecord * 539 CIfrRecordInfoDB::GetRecordInfoFromIdx ( 540 IN UINT32 RecordIdx 541 ) 542 { 543 UINT32 Idx; 544 SIfrRecord *pNode = NULL; 545 546 if (RecordIdx == EFI_IFR_RECORDINFO_IDX_INVALUD) { 547 return NULL; 548 } 549 550 for (Idx = (EFI_IFR_RECORDINFO_IDX_START + 1), pNode = mIfrRecordListHead; 551 (Idx != RecordIdx) && (pNode != NULL); 552 Idx++, pNode = pNode->mNext) 553 ; 554 555 return pNode; 556 } 557 558 UINT32 559 CIfrRecordInfoDB::IfrRecordRegister ( 560 IN UINT32 LineNo, 561 IN CHAR8 *IfrBinBuf, 562 IN UINT8 BinBufLen, 563 IN UINT32 Offset 564 ) 565 { 566 SIfrRecord *pNew; 567 568 if (mSwitch == FALSE) { 569 return EFI_IFR_RECORDINFO_IDX_INVALUD; 570 } 571 572 if ((pNew = new SIfrRecord) == NULL) { 573 return EFI_IFR_RECORDINFO_IDX_INVALUD; 574 } 575 576 if (mIfrRecordListHead == NULL) { 577 mIfrRecordListHead = pNew; 578 mIfrRecordListTail = pNew; 579 } else { 580 mIfrRecordListTail->mNext = pNew; 581 mIfrRecordListTail = pNew; 582 } 583 mRecordCount++; 584 585 return mRecordCount; 586 } 587 588 VOID 589 CIfrRecordInfoDB::IfrRecordInfoUpdate ( 590 IN UINT32 RecordIdx, 591 IN UINT32 LineNo, 592 IN CHAR8 *BinBuf, 593 IN UINT8 BinBufLen, 594 IN UINT32 Offset 595 ) 596 { 597 SIfrRecord *pNode; 598 SIfrRecord *Prev; 599 600 if ((pNode = GetRecordInfoFromIdx (RecordIdx)) == NULL) { 601 return; 602 } 603 604 if (LineNo == 0) { 605 // 606 // Line number is not specified explicitly, try to use line number of previous opcode 607 // 608 Prev = GetRecordInfoFromIdx (RecordIdx - 1); 609 if (Prev != NULL) { 610 LineNo = Prev->mLineNo; 611 } 612 } 613 pNode->mLineNo = LineNo; 614 pNode->mOffset = Offset; 615 pNode->mBinBufLen = BinBufLen; 616 pNode->mIfrBinBuf = BinBuf; 617 } 618 619 VOID 620 CIfrRecordInfoDB::IfrRecordOutput ( 621 IN FILE *File, 622 IN UINT32 LineNo 623 ) 624 { 625 SIfrRecord *pNode; 626 UINT8 Index; 627 628 if (mSwitch == FALSE) { 629 return; 630 } 631 632 if (File == NULL) { 633 return; 634 } 635 636 for (pNode = mIfrRecordListHead; pNode != NULL; pNode = pNode->mNext) { 637 if (pNode->mLineNo == LineNo) { 638 fprintf (File, ">%08X: ", pNode->mOffset); 639 if (pNode->mIfrBinBuf != NULL) { 640 for (Index = 0; Index < pNode->mBinBufLen; Index++) { 641 fprintf (File, "%02X ", (UINT8)(pNode->mIfrBinBuf[Index])); 642 } 643 } 644 fprintf (File, "\n"); 645 } 646 } 647 } 648 649 CIfrRecordInfoDB gCIfrRecordInfoDB; 650 651 VOID 652 CIfrObj::_EMIT_PENDING_OBJ ( 653 VOID 654 ) 655 { 656 CHAR8 *ObjBinBuf = NULL; 657 658 ObjBinBuf = gCFormPkg.IfrBinBufferGet (mObjBinLen); 659 if (ObjBinBuf != NULL) { 660 memcpy (ObjBinBuf, mObjBinBuf, mObjBinLen); 661 } 662 663 if (mObjBinBuf != NULL) { 664 delete mObjBinBuf; 665 mObjBinBuf = ObjBinBuf; 666 } 667 } 668 669 /* 670 * The definition of CIfrObj's member function 671 */ 672 static struct { 673 UINT8 mSize; 674 UINT8 mScope; 675 } gOpcodeSizesScopeTable[] = { 676 { 0, 0 }, // EFI_IFR_INVALID - 0x00 677 { sizeof (EFI_IFR_FORM), 1 }, // EFI_IFR_FORM_OP 678 { sizeof (EFI_IFR_SUBTITLE), 1 }, // EFI_IFR_SUBTITLE_OP 679 { sizeof (EFI_IFR_TEXT), 0 }, // EFI_IFR_TEXT_OP 680 { sizeof (EFI_IFR_IMAGE), 0 }, // EFI_IFR_IMAGE_OP 681 { sizeof (EFI_IFR_ONE_OF), 1 }, // EFI_IFR_ONE_OF_OP - 0x05 682 { sizeof (EFI_IFR_CHECKBOX), 1}, // EFI_IFR_CHECKBOX_OP 683 { sizeof (EFI_IFR_NUMERIC), 1 }, // EFI_IFR_NUMERIC_OP 684 { sizeof (EFI_IFR_PASSWORD), 1 }, // EFI_IFR_PASSWORD_OP 685 { sizeof (EFI_IFR_ONE_OF_OPTION), 0 }, // EFI_IFR_ONE_OF_OPTION_OP 686 { sizeof (EFI_IFR_SUPPRESS_IF), 1 }, // EFI_IFR_SUPPRESS_IF - 0x0A 687 { sizeof (EFI_IFR_LOCKED), 0 }, // EFI_IFR_LOCKED_OP 688 { sizeof (EFI_IFR_ACTION), 1 }, // EFI_IFR_ACTION_OP 689 { sizeof (EFI_IFR_RESET_BUTTON), 1 }, // EFI_IFR_RESET_BUTTON_OP 690 { sizeof (EFI_IFR_FORM_SET), 1 }, // EFI_IFR_FORM_SET_OP -0xE 691 { sizeof (EFI_IFR_REF), 0 }, // EFI_IFR_REF_OP 692 { sizeof (EFI_IFR_NO_SUBMIT_IF), 1}, // EFI_IFR_NO_SUBMIT_IF_OP -0x10 693 { sizeof (EFI_IFR_INCONSISTENT_IF), 1 }, // EFI_IFR_INCONSISTENT_IF_OP 694 { sizeof (EFI_IFR_EQ_ID_VAL), 0 }, // EFI_IFR_EQ_ID_VAL_OP 695 { sizeof (EFI_IFR_EQ_ID_ID), 0 }, // EFI_IFR_EQ_ID_ID_OP 696 { sizeof (EFI_IFR_EQ_ID_LIST), 0 }, // EFI_IFR_EQ_ID_LIST_OP - 0x14 697 { sizeof (EFI_IFR_AND), 0 }, // EFI_IFR_AND_OP 698 { sizeof (EFI_IFR_OR), 0 }, // EFI_IFR_OR_OP 699 { sizeof (EFI_IFR_NOT), 0 }, // EFI_IFR_NOT_OP 700 { sizeof (EFI_IFR_RULE), 1 }, // EFI_IFR_RULE_OP 701 { sizeof (EFI_IFR_GRAY_OUT_IF), 1 }, // EFI_IFR_GRAYOUT_IF_OP - 0x19 702 { sizeof (EFI_IFR_DATE), 1 }, // EFI_IFR_DATE_OP 703 { sizeof (EFI_IFR_TIME), 1 }, // EFI_IFR_TIME_OP 704 { sizeof (EFI_IFR_STRING), 1 }, // EFI_IFR_STRING_OP 705 { sizeof (EFI_IFR_REFRESH), 0 }, // EFI_IFR_REFRESH_OP 706 { sizeof (EFI_IFR_DISABLE_IF), 1 }, // EFI_IFR_DISABLE_IF_OP - 0x1E 707 { 0, 0 }, // 0x1F 708 { sizeof (EFI_IFR_TO_LOWER), 0 }, // EFI_IFR_TO_LOWER_OP - 0x20 709 { sizeof (EFI_IFR_TO_UPPER), 0 }, // EFI_IFR_TO_UPPER_OP - 0x21 710 { 0, 0 }, // 0x22 711 { sizeof (EFI_IFR_ORDERED_LIST), 1 }, // EFI_IFR_ORDERED_LIST_OP - 0x23 712 { sizeof (EFI_IFR_VARSTORE), 0 }, // EFI_IFR_VARSTORE_OP 713 { sizeof (EFI_IFR_VARSTORE_NAME_VALUE), 0 }, // EFI_IFR_VARSTORE_NAME_VALUE_OP 714 { sizeof (EFI_IFR_VARSTORE_EFI), 0 }, // EFI_IFR_VARSTORE_EFI_OP 715 { sizeof (EFI_IFR_VARSTORE_DEVICE), 1 }, // EFI_IFR_VARSTORE_DEVICE_OP 716 { sizeof (EFI_IFR_VERSION), 0 }, // EFI_IFR_VERSION_OP - 0x28 717 { sizeof (EFI_IFR_END), 0 }, // EFI_IFR_END_OP 718 { sizeof (EFI_IFR_MATCH), 1 }, // EFI_IFR_MATCH_OP - 0x2A 719 { 0, 0 }, { 0, 0} , { 0, 0} , { 0, 0} , // 0x2B ~ 0x2E 720 { sizeof (EFI_IFR_EQUAL), 0 }, // EFI_IFR_EQUAL_OP - 0x2F 721 { sizeof (EFI_IFR_NOT_EQUAL), 0 }, // EFI_IFR_NOT_EQUAL_OP 722 { sizeof (EFI_IFR_GREATER_THAN), 0 }, // EFI_IFR_GREATER_THAN_OP 723 { sizeof (EFI_IFR_GREATER_EQUAL), 0 }, // EFI_IFR_GREATER_EQUAL_OP 724 { sizeof (EFI_IFR_LESS_THAN), 0 }, // EFI_IFR_LESS_THAN_OP 725 { sizeof (EFI_IFR_LESS_EQUAL), 0 }, // EFI_IFR_LESS_EQUAL_OP - 0x34 726 { sizeof (EFI_IFR_BITWISE_AND), 0 }, // EFI_IFR_BITWISE_AND_OP 727 { sizeof (EFI_IFR_BITWISE_OR), 0 }, // EFI_IFR_BITWISE_OR_OP 728 { sizeof (EFI_IFR_BITWISE_NOT), 0 }, // EFI_IFR_BITWISE_NOT_OP 729 { sizeof (EFI_IFR_SHIFT_LEFT), 0 }, // EFI_IFR_SHIFT_LEFT_OP 730 { sizeof (EFI_IFR_SHIFT_RIGHT), 0 }, // EFI_IFR_SHIFT_RIGHT_OP 731 { sizeof (EFI_IFR_ADD), 0 }, // EFI_IFR_ADD_OP - 0x3A 732 { sizeof (EFI_IFR_SUBTRACT), 0 }, // EFI_IFR_SUBTRACT_OP 733 { sizeof (EFI_IFR_MULTIPLY), 0 }, // EFI_IFR_MULTIPLY_OP 734 { sizeof (EFI_IFR_DIVIDE), 0 }, // EFI_IFR_DIVIDE_OP 735 { sizeof (EFI_IFR_MODULO), 0 }, // EFI_IFR_MODULO_OP - 0x3E 736 { sizeof (EFI_IFR_RULE_REF), 0 }, // EFI_IFR_RULE_REF_OP 737 { sizeof (EFI_IFR_QUESTION_REF1), 0 }, // EFI_IFR_QUESTION_REF1_OP 738 { sizeof (EFI_IFR_QUESTION_REF2), 0 }, // EFI_IFR_QUESTION_REF2_OP - 0x41 739 { sizeof (EFI_IFR_UINT8), 0}, // EFI_IFR_UINT8 740 { sizeof (EFI_IFR_UINT16), 0}, // EFI_IFR_UINT16 741 { sizeof (EFI_IFR_UINT32), 0}, // EFI_IFR_UINT32 742 { sizeof (EFI_IFR_UINT64), 0}, // EFI_IFR_UTNT64 743 { sizeof (EFI_IFR_TRUE), 0 }, // EFI_IFR_TRUE_OP - 0x46 744 { sizeof (EFI_IFR_FALSE), 0 }, // EFI_IFR_FALSE_OP 745 { sizeof (EFI_IFR_TO_UINT), 0 }, // EFI_IFR_TO_UINT_OP 746 { sizeof (EFI_IFR_TO_STRING), 0 }, // EFI_IFR_TO_STRING_OP 747 { sizeof (EFI_IFR_TO_BOOLEAN), 0 }, // EFI_IFR_TO_BOOLEAN_OP 748 { sizeof (EFI_IFR_MID), 0 }, // EFI_IFR_MID_OP 749 { sizeof (EFI_IFR_FIND), 0 }, // EFI_IFR_FIND_OP 750 { sizeof (EFI_IFR_TOKEN), 0 }, // EFI_IFR_TOKEN_OP 751 { sizeof (EFI_IFR_STRING_REF1), 0 }, // EFI_IFR_STRING_REF1_OP - 0x4E 752 { sizeof (EFI_IFR_STRING_REF2), 0 }, // EFI_IFR_STRING_REF2_OP 753 { sizeof (EFI_IFR_CONDITIONAL), 0 }, // EFI_IFR_CONDITIONAL_OP 754 { sizeof (EFI_IFR_QUESTION_REF3), 0 }, // EFI_IFR_QUESTION_REF3_OP 755 { sizeof (EFI_IFR_ZERO), 0 }, // EFI_IFR_ZERO_OP 756 { sizeof (EFI_IFR_ONE), 0 }, // EFI_IFR_ONE_OP 757 { sizeof (EFI_IFR_ONES), 0 }, // EFI_IFR_ONES_OP 758 { sizeof (EFI_IFR_UNDEFINED), 0 }, // EFI_IFR_UNDEFINED_OP 759 { sizeof (EFI_IFR_LENGTH), 0 }, // EFI_IFR_LENGTH_OP 760 { sizeof (EFI_IFR_DUP), 0 }, // EFI_IFR_DUP_OP - 0x57 761 { sizeof (EFI_IFR_THIS), 0 }, // EFI_IFR_THIS_OP 762 { sizeof (EFI_IFR_SPAN), 0 }, // EFI_IFR_SPAN_OP 763 { sizeof (EFI_IFR_VALUE), 1 }, // EFI_IFR_VALUE_OP 764 { sizeof (EFI_IFR_DEFAULT), 0 }, // EFI_IFR_DEFAULT_OP 765 { sizeof (EFI_IFR_DEFAULTSTORE), 0 }, // EFI_IFR_DEFAULTSTORE_OP - 0x5C 766 { 0, 0}, // 0x5D 767 { sizeof (EFI_IFR_CATENATE), 0 }, // EFI_IFR_CATENATE_OP 768 { sizeof (EFI_IFR_GUID), 0 }, // EFI_IFR_GUID_OP 769 }; 770 771 #ifdef CIFROBJ_DEUBG 772 static struct { 773 INT8 *mIfrName; 774 } gIfrObjPrintDebugTable[] = { 775 "EFI_IFR_INVALID", "EFI_IFR_FORM", "EFI_IFR_SUBTITLE", "EFI_IFR_TEXT", "EFI_IFR_IMAGE", "EFI_IFR_ONE_OF", 776 "EFI_IFR_CHECKBOX", "EFI_IFR_NUMERIC", "EFI_IFR_PASSWORD", "EFI_IFR_ONE_OF_OPTION", "EFI_IFR_SUPPRESS_IF", "EFI_IFR_LOCKED", 777 "EFI_IFR_ACTION", "EFI_IFR_RESET_BUTTON", "EFI_IFR_FORM_SET", "EFI_IFR_REF", "EFI_IFR_NO_SUBMIT_IF", "EFI_IFR_INCONSISTENT_IF", 778 "EFI_IFR_EQ_ID_VAL", "EFI_IFR_EQ_ID_ID", "EFI_IFR_EQ_ID_LIST", "EFI_IFR_AND", "EFI_IFR_OR", "EFI_IFR_NOT", 779 "EFI_IFR_RULE", "EFI_IFR_GRAY_OUT_IF", "EFI_IFR_DATE", "EFI_IFR_TIME", "EFI_IFR_STRING", "EFI_IFR_REFRESH", 780 "EFI_IFR_DISABLE_IF", "EFI_IFR_INVALID", "EFI_IFR_TO_LOWER", "EFI_IFR_TO_UPPER", "EFI_IFR_INVALID", "EFI_IFR_ORDERED_LIST", 781 "EFI_IFR_VARSTORE", "EFI_IFR_VARSTORE_NAME_VALUE", "EFI_IFR_VARSTORE_EFI", "EFI_IFR_VARSTORE_DEVICE", "EFI_IFR_VERSION", "EFI_IFR_END", 782 "EFI_IFR_MATCH", "EFI_IFR_INVALID", "EFI_IFR_INVALID", "EFI_IFR_INVALID", "EFI_IFR_INVALID", "EFI_IFR_EQUAL", 783 "EFI_IFR_NOT_EQUAL", "EFI_IFR_GREATER_THAN", "EFI_IFR_GREATER_EQUAL", "EFI_IFR_LESS_THAN", "EFI_IFR_LESS_EQUAL", "EFI_IFR_BITWISE_AND", 784 "EFI_IFR_BITWISE_OR", "EFI_IFR_BITWISE_NOT", "EFI_IFR_SHIFT_LEFT", "EFI_IFR_SHIFT_RIGHT", "EFI_IFR_ADD", "EFI_IFR_SUBTRACT", 785 "EFI_IFR_MULTIPLY", "EFI_IFR_DIVIDE", "EFI_IFR_MODULO", "EFI_IFR_RULE_REF", "EFI_IFR_QUESTION_REF1", "EFI_IFR_QUESTION_REF2", 786 "EFI_IFR_UINT8", "EFI_IFR_UINT16", "EFI_IFR_UINT32", "EFI_IFR_UINT64", "EFI_IFR_TRUE", "EFI_IFR_FALSE", 787 "EFI_IFR_TO_UINT", "EFI_IFR_TO_STRING", "EFI_IFR_TO_BOOLEAN", "EFI_IFR_MID", "EFI_IFR_FIND", "EFI_IFR_TOKEN", 788 "EFI_IFR_STRING_REF1","EFI_IFR_STRING_REF2", "EFI_IFR_CONDITIONAL", "EFI_IFR_QUESTION_REF3", "EFI_IFR_ZERO", "EFI_IFR_ONE", 789 "EFI_IFR_ONES", "EFI_IFR_UNDEFINED", "EFI_IFR_LENGTH", "EFI_IFR_DUP", "EFI_IFR_THIS", "EFI_IFR_SPAN", 790 "EFI_IFR_VALUE", "EFI_IFR_DEFAULT", "EFI_IFR_DEFAULTSTORE", "EFI_IFR_INVALID", "EFI_IFR_CATENATE", "EFI_IFR_GUID", 791 }; 792 793 VOID 794 CIFROBJ_DEBUG_PRINT ( 795 IN UINT8 OpCode 796 ) 797 { 798 printf ("======Create IFR [%s]\n", gIfrObjPrintDebugTable[OpCode].mIfrName); 799 } 800 #else 801 802 #define CIFROBJ_DEBUG_PRINT(OpCode) 803 804 #endif 805 806 bool gCreateOp = TRUE; 807 808 CIfrObj::CIfrObj ( 809 IN UINT8 OpCode, 810 OUT CHAR8 **IfrObj, 811 IN UINT8 ObjBinLen, 812 IN BOOLEAN DelayEmit 813 ) 814 { 815 mDelayEmit = DelayEmit; 816 mPkgOffset = gCFormPkg.GetPkgLength (); 817 mObjBinLen = (ObjBinLen == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : ObjBinLen; 818 mObjBinBuf = ((DelayEmit == FALSE) && (gCreateOp == TRUE)) ? gCFormPkg.IfrBinBufferGet (mObjBinLen) : new CHAR8[EFI_IFR_MAX_LENGTH]; 819 mRecordIdx = (gCreateOp == TRUE) ? gCIfrRecordInfoDB.IfrRecordRegister (0xFFFFFFFF, mObjBinBuf, mObjBinLen, mPkgOffset) : EFI_IFR_RECORDINFO_IDX_INVALUD; 820 821 if (IfrObj != NULL) { 822 *IfrObj = mObjBinBuf; 823 } 824 825 CIFROBJ_DEBUG_PRINT (OpCode); 826 } 827 828 CIfrObj::~CIfrObj ( 829 VOID 830 ) 831 { 832 if ((mDelayEmit == TRUE) && ((gCreateOp == TRUE))) { 833 _EMIT_PENDING_OBJ (); 834 } 835 836 gCIfrRecordInfoDB.IfrRecordInfoUpdate (mRecordIdx, mLineNo, mObjBinBuf, mObjBinLen, mPkgOffset); 837 } 838 839 /* 840 * The definition of CIfrObj's member function 841 */ 842 UINT8 gScopeCount = 0; 843 844 CIfrOpHeader::CIfrOpHeader ( 845 IN UINT8 OpCode, 846 IN VOID *StartAddr, 847 IN UINT8 Length 848 ) : mHeader ((EFI_IFR_OP_HEADER *)StartAddr) 849 { 850 mHeader->OpCode = OpCode; 851 mHeader->Length = (Length == 0) ? gOpcodeSizesScopeTable[OpCode].mSize : Length; 852 mHeader->Scope = (gOpcodeSizesScopeTable[OpCode].mScope + gScopeCount > 0) ? 1 : 0; 853 } 854 855 CIfrOpHeader::CIfrOpHeader ( 856 IN CIfrOpHeader &OpHdr 857 ) 858 { 859 mHeader = OpHdr.mHeader; 860 } 861 862 UINT32 CIfrForm::FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE] = {0, }; 863
