自学教程：C++ GetNextNode函数代码示例

/**  Process some op codes which is out side of current form.    @param FormData                Pointer to the form data.  @return EFI_SUCCESS            Pass the statement success.**/VOIDProcessExternedOpcode (  IN FORM_DISPLAY_ENGINE_FORM       *FormData  ){  LIST_ENTRY                    *Link;  LIST_ENTRY                    *NestLink;  FORM_DISPLAY_ENGINE_STATEMENT *Statement;  FORM_DISPLAY_ENGINE_STATEMENT *NestStatement;  Link = GetFirstNode (&FormData->StatementListOSF);  while (!IsNull (&FormData->StatementListOSF, Link)) {    Statement = FORM_DISPLAY_ENGINE_STATEMENT_FROM_LINK (Link);    Link = GetNextNode (&FormData->StatementListOSF, Link);    ProcessUserOpcode(Statement->OpCode);  }  Link = GetFirstNode (&FormData->StatementListHead);  while (!IsNull (&FormData->StatementListHead, Link)) {    Statement = FORM_DISPLAY_ENGINE_STATEMENT_FROM_LINK (Link);    Link = GetNextNode (&FormData->StatementListHead, Link);    ProcessUserOpcode(Statement->OpCode);    NestLink = GetFirstNode (&Statement->NestStatementList);    while (!IsNull (&Statement->NestStatementList, NestLink)) {      NestStatement = FORM_DISPLAY_ENGINE_STATEMENT_FROM_LINK (NestLink);      NestLink = GetNextNode (&Statement->NestStatementList, NestLink);      ProcessUserOpcode(NestStatement->OpCode);    }  }}

////////////////////////////////////////////////////////////////////////////////////  Function: xml_get_child_tag//	Gets the position of the child tag.//XmlNode CXmlDocument::GetChildNode(XmlNode node, char* szTag){	char szCurrentTag[32];	char* szChildTag;	// get parent node tag	strcpy(szCurrentTag,GetNodeTag(node));	// get child node	node = GetNextNode(node);	while (node>0)	{		// get child node tag		szChildTag = GetNodeTag(node);		// does the child's tag match the one we're looking for		if ( !strcmpi(szChildTag,szTag) )			return node;		// is this actually the parent's closing tag?		else if ( !strcmpi(&szChildTag[1],szCurrentTag) )			return 0;		node = GetNextNode(node);	}	return 0;}

/**  Get the FORM_BROWSER_STATEMENT that matches the Question's value.      @param FormSet                  The Form Set.  @param QuestionId               QuestionId     @retval FORM_BROWSER_STATEMENT*   FORM_BROWSER_STATEMENT that match Question's value.  @retval NULL                      If the Form Set does not have EFI_IFR_VARSTORE.**/FORM_BROWSER_STATEMENT *GetStorageFromQuestionId (  IN CONST FORM_BROWSER_FORMSET * FormSet,  IN       EFI_QUESTION_ID        QuestionId  ){  LIST_ENTRY             *FormList;  LIST_ENTRY             *StatementList;  FORM_BROWSER_FORM      *Form;  FORM_BROWSER_STATEMENT *Statement;  FormList = GetFirstNode (&FormSet->FormListHead);  while (!IsNull (&FormSet->FormListHead, FormList)) {    Form = FORM_BROWSER_FORM_FROM_LINK (FormList);    StatementList = GetFirstNode (&Form->StatementListHead);    while (!IsNull (&Form->StatementListHead, StatementList)) {      Statement = FORM_BROWSER_STATEMENT_FROM_LINK (StatementList);      if ((QuestionId == Statement->QuestionId) && (Statement->Storage != NULL)) {        //        // UEFI Question ID is unique in a FormSet.        //        ASSERT (Statement->Storage->Type == EFI_HII_VARSTORE_BUFFER);        return Statement;      }      StatementList = GetNextNode (&Form->StatementListHead, StatementList);    }    FormList = GetNextNode (&FormSet->FormListHead, FormList);  }    return NULL;}

/**  Search the Head doubly linked list for the passed in MTC. Return the  matching element in Head and the MTC on the next entry.  @param Head             Head of Data Log linked list.  @param ClassFilter      Only match the MTC if it is in the same Class as the                          ClassFilter.  @param PtrCurrentMTC    On IN contians MTC to search for. On OUT contians next                          MTC in the data log list or zero if at end of the list.  @retval EFI_DATA_LOG_ENTRY  Return pointer to data log data from Head list.  @retval NULL                If no data record exists.**/EFI_DATA_RECORD_HEADER *GetNextDataRecord (  IN  LIST_ENTRY          *Head,  IN  UINT64              ClassFilter,  IN OUT  UINT64          *PtrCurrentMTC  ){  EFI_DATA_ENTRY          *LogEntry;  LIST_ENTRY              *Link;  BOOLEAN                 ReturnFirstEntry;  EFI_DATA_RECORD_HEADER  *Record;  EFI_DATA_ENTRY          *NextLogEntry;  //  // If MonotonicCount == 0 just return the first one  //  ReturnFirstEntry  = (BOOLEAN) (*PtrCurrentMTC == 0);  Record            = NULL;  for (Link = GetFirstNode(Head); Link != Head; Link = GetNextNode(Head, Link)) {    LogEntry = DATA_ENTRY_FROM_LINK (Link);    if ((LogEntry->Record->DataRecordClass & ClassFilter) == 0) {      //      // Skip any entry that does not have the correct ClassFilter      //      continue;    }    if ((LogEntry->Record->LogMonotonicCount == *PtrCurrentMTC) || ReturnFirstEntry) {      //      // Return record to the user      //      Record = LogEntry->Record;      //      // Calculate the next MTC value. If there is no next entry set      // MTC to zero.      //      *PtrCurrentMTC = 0;      for (Link = GetNextNode(Head, Link); Link != Head; Link = GetNextNode(Head, Link)) {        NextLogEntry = DATA_ENTRY_FROM_LINK (Link);        if ((NextLogEntry->Record->DataRecordClass & ClassFilter) != 0) {          //          // Return the MTC of the next thing to search for if found          //          *PtrCurrentMTC = NextLogEntry->Record->LogMonotonicCount;          break;        }      }      //      // Record found exit loop and return      //      break;    }  }  return Record;}

/**  Determines the handles that are currently active in the database.  This function determines the handles that are currently active in the database.   For example, a program wishing to create a Setup-like configuration utility would use this call   to determine the handles that are available. It would then use calls defined in the forms section   below to extract forms and then interpret them.  @param This                 A pointer to the EFI_HII_PROTOCOL instance.  @param HandleBufferLength   On input, a pointer to the length of the handle buffer.                               On output, the length of the handle buffer that is required for the handles found.  @param Handle               Pointer to an array of EFI_HII_HANDLE instances returned.                               Type EFI_HII_HANDLE is defined in EFI_HII_PROTOCOL.NewPack() in the Packages section.  @retval EFI_SUCCESS         Handle was updated successfully.   @retval EFI_BUFFER_TOO_SMALL The HandleBufferLength parameter indicates that Handle is too small                                to support the number of handles. HandleBufferLength is updated with a value that                                will enable the data to fit.**/EFI_STATUSEFIAPIHiiFindHandles (  IN     EFI_HII_PROTOCOL *This,  IN OUT UINT16           *HandleBufferLength,  OUT    FRAMEWORK_EFI_HII_HANDLE    *Handle  ){  UINT16                      Count;  LIST_ENTRY                  *Link;  HII_THUNK_CONTEXT           *ThunkContext;  HII_THUNK_PRIVATE_DATA      *Private;  if (HandleBufferLength == NULL) {    return EFI_INVALID_PARAMETER;  }  Private = HII_THUNK_PRIVATE_DATA_FROM_THIS(This);    //  // Count the number of handles.  //  Count = 0;  Link = GetFirstNode (&Private->ThunkContextListHead);  while (!IsNull (&Private->ThunkContextListHead, Link)) {    Count++;    Link = GetNextNode (&Private->ThunkContextListHead, Link);  }  if (Count > *HandleBufferLength) {    *HandleBufferLength = (UINT16) (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));    return EFI_BUFFER_TOO_SMALL;  }  //  // Output the handles.  //  Count = 0;  Link = GetFirstNode (&Private->ThunkContextListHead);  while (!IsNull (&Private->ThunkContextListHead, Link)) {    ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);    Handle[Count] = ThunkContext->FwHiiHandle;    Count++;    Link = GetNextNode (&Private->ThunkContextListHead, Link);  }  *HandleBufferLength = (UINT16) (Count * sizeof (FRAMEWORK_EFI_HII_HANDLE));  return EFI_SUCCESS;}

/**  Sets a list of all Shell-Guid-based environment variables.  this will  also eliminate all existing shell environment variables (even if they  are not on the list).  This function will also deallocate the memory from List.  @param[in] ListHead           The pointer to LIST_ENTRY from                                GetShellEnvVarList().  @retval EFI_SUCCESS           the list was Set sucessfully.**/EFI_STATUSEFIAPISetEnvironmentVariableList(    IN LIST_ENTRY *ListHead){    ENV_VAR_LIST      VarList;    ENV_VAR_LIST      *Node;    EFI_STATUS        Status;    UINTN             Size;    InitializeListHead(&VarList.Link);    //    // Delete all the current environment variables    //    Status = GetEnvironmentVariableList(&VarList.Link);    ASSERT_EFI_ERROR(Status);    for ( Node = (ENV_VAR_LIST*)GetFirstNode(&VarList.Link)                 ; !IsNull(&VarList.Link, &Node->Link)            ; Node = (ENV_VAR_LIST*)GetNextNode(&VarList.Link, &Node->Link)        ) {        if (Node->Key != NULL) {            Status = SHELL_DELETE_ENVIRONMENT_VARIABLE(Node->Key);        }        ASSERT_EFI_ERROR(Status);    }    FreeEnvironmentVariableList(&VarList.Link);    //    // set all the variables fron the list    //    for ( Node = (ENV_VAR_LIST*)GetFirstNode(ListHead)                 ; !IsNull(ListHead, &Node->Link)            ; Node = (ENV_VAR_LIST*)GetNextNode(ListHead, &Node->Link)        ) {        Size = StrSize(Node->Val);        if (Node->Atts & EFI_VARIABLE_NON_VOLATILE) {            Status = SHELL_SET_ENVIRONMENT_VARIABLE_NV(Node->Key, Size, Node->Val);        } else {            Status = SHELL_SET_ENVIRONMENT_VARIABLE_V (Node->Key, Size, Node->Val);        }        ASSERT_EFI_ERROR(Status);    }    FreeEnvironmentVariableList(ListHead);    return (Status);}

wxHashTable::Node* wxHashTable::Next(){    if( m_curr == NULL )        GetNextNode( 0 );    else    {        m_curr = m_curr->GetNext();        if( m_curr == ( (Node*)m_table[m_currBucket] )->GetNext() )            GetNextNode( m_currBucket + 1 );    }    return m_curr;}

void CXmlDocument::EnumerateNodes(char* szTag, XmlNodeCallback pFunc){	char* szCurrentTag;	XmlNode node;		node = GetNextNode(XML_ROOT_NODE);	while (node>0)	{		szCurrentTag = GetNodeTag(node);		if ( !strcmpi(szCurrentTag,szTag) )			pFunc(szTag,node);		node = GetNextNode(node);	}}

UINT32BootMonFsGetImageLength (  IN BOOTMON_FS_FILE      *File  ){  UINT32                   Index;  UINT32                   FileSize;  LIST_ENTRY              *RegionToFlushLink;  BOOTMON_FS_FILE_REGION  *Region;  FileSize = 0;  // Look at all Flash areas to determine file size  for (Index = 0; Index < HW_IMAGE_DESCRIPTION_REGION_MAX; Index++) {    FileSize += File->HwDescription.Region[Index].Size;  }  // Add the regions that have not been flushed yet  for (RegionToFlushLink = GetFirstNode (&File->RegionToFlushLink);       !IsNull (&File->RegionToFlushLink, RegionToFlushLink);       RegionToFlushLink = GetNextNode (&File->RegionToFlushLink, RegionToFlushLink)       )  {    Region = (BOOTMON_FS_FILE_REGION*)RegionToFlushLink;    if (Region->Offset + Region->Size > FileSize) {      FileSize += Region->Offset + Region->Size;    }  }  return FileSize;}

// Helper function that calculates a rough "free space" by:// - Taking the media size// - Subtracting the sum of all file sizes// - Subtracting the block size times the number of files//    (To account for the blocks containing the HW_IMAGE_INFOSTATICUINT64ComputeFreeSpace (  IN BOOTMON_FS_INSTANCE *Instance  ){  LIST_ENTRY   *FileLink;  UINT64        FileSizeSum;  UINT64        MediaSize;  UINTN         NumFiles;  EFI_BLOCK_IO_MEDIA *Media;  BOOTMON_FS_FILE *File;  Media = Instance->BlockIo->Media;  MediaSize = Media->BlockSize * (Media->LastBlock + 1);  NumFiles = 0;  FileSizeSum = 0;  for (FileLink = GetFirstNode (&Instance->RootFile->Link);         !IsNull (&Instance->RootFile->Link, FileLink);         FileLink = GetNextNode (&Instance->RootFile->Link, FileLink)         )  {    File = BOOTMON_FS_FILE_FROM_LINK_THIS (FileLink);    FileSizeSum += BootMonFsGetImageLength (File);    NumFiles++;  }  return MediaSize - (FileSizeSum + (Media->BlockSize + NumFiles));}

/**  Remove an alias from the given list.  @param[in] Alias               The alias to remove.  @param[in, out] List           The list to search.**/BOOLEANEFIAPIInternalRemoveAliasFromList(  IN CONST CHAR16       *Alias,  IN OUT LIST_ENTRY     *List  ){  ALIAS_LIST *Node;  //  // assert for NULL parameter  //  ASSERT(Alias != NULL);  //  // check for the Alias  //  for ( Node = (ALIAS_LIST *)GetFirstNode(List)      ; !IsNull(List, &Node->Link)      ; Node = (ALIAS_LIST *)GetNextNode(List, &Node->Link)     ){    ASSERT(Node->CommandString != NULL);    ASSERT(Node->Alias != NULL);    if (StrCmp(Node->Alias, Alias)==0) {      RemoveEntryList(&Node->Link);      FreePool(Node->Alias);      FreePool(Node->CommandString);      FreePool(Node);      return (TRUE);    }  }  return (FALSE);}

/**  Unregister a notification function.  The UnregisterResetNotify() function removes the previously registered  notification using RegisterResetNotify().  @param[in]  This              A pointer to the EFI_RESET_NOTIFICATION_PROTOCOL instance.  @param[in]  ResetFunction     The pointer to the ResetFunction being unregistered.  @retval EFI_SUCCESS           The reset notification function was unregistered.  @retval EFI_INVALID_PARAMETER ResetFunction is NULL.  @retval EFI_INVALID_PARAMETER The reset notification function specified by ResetFunction was not previously                                registered using RegisterResetNotify().**/EFI_STATUSEFIAPIUnregisterResetNotify (  IN EFI_RESET_NOTIFICATION_PROTOCOL *This,  IN EFI_RESET_SYSTEM                ResetFunction  ){  RESET_NOTIFICATION_INSTANCE        *Instance;  LIST_ENTRY                         *Link;  RESET_NOTIFY_ENTRY                 *Entry;  if (ResetFunction == NULL) {    return EFI_INVALID_PARAMETER;  }  Instance = RESET_NOTIFICATION_INSTANCE_FROM_THIS (This);  for ( Link = GetFirstNode (&Instance->ResetNotifies)      ; !IsNull (&Instance->ResetNotifies, Link)      ; Link = GetNextNode (&Instance->ResetNotifies, Link)      ) {    Entry = RESET_NOTIFY_ENTRY_FROM_LINK (Link);    if (Entry->ResetNotify == ResetFunction) {      RemoveEntryList (&Entry->Link);      FreePool (Entry);      return EFI_SUCCESS;    }  }  return EFI_INVALID_PARAMETER;}

/**  Get the default value for Buffer Type storage from the FormSet in ThunkContext.    The results can be multiple instances of UEFI_IFR_BUFFER_STORAGE_NODE.   They are inserted to the link list.    @param  ThunkContext  Hii thunk context.  @param  UefiDefaults  The head of link list for the output.  @retval   EFI_SUCCESS          Successful.  **/EFI_STATUSUefiIfrGetBufferTypeDefaults (  IN  HII_THUNK_CONTEXT   *ThunkContext,  OUT LIST_ENTRY          **UefiDefaults  ){  LIST_ENTRY            *DefaultLink;  FORMSET_DEFAULTSTORE  *DefaultStore;  EFI_STATUS            Status;  ASSERT (UefiDefaults != NULL);  *UefiDefaults = AllocateZeroPool (sizeof (LIST_ENTRY));  ASSERT (*UefiDefaults != NULL);  InitializeListHead (*UefiDefaults);  DefaultLink = GetFirstNode (&ThunkContext->FormSet->DefaultStoreListHead);  while (!IsNull (&ThunkContext->FormSet->DefaultStoreListHead, DefaultLink)) {    DefaultStore = FORMSET_DEFAULTSTORE_FROM_LINK(DefaultLink);    Status = GetBufferTypeDefaultId (DefaultStore, ThunkContext->FormSet, *UefiDefaults);    ASSERT_EFI_ERROR (Status);    DefaultLink = GetNextNode (&ThunkContext->FormSet->DefaultStoreListHead, DefaultLink);      }  return EFI_SUCCESS;}

/**  Register the platform provided boot description handler.  @param Handler  The platform provided boot description handler  @retval EFI_SUCCESS          The handler was registered successfully.  @retval EFI_ALREADY_STARTED  The handler was already registered.  @retval EFI_OUT_OF_RESOURCES There is not enough resource to perform the registration.**/EFI_STATUSEFIAPIEfiBootManagerRegisterBootDescriptionHandler (  IN EFI_BOOT_MANAGER_BOOT_DESCRIPTION_HANDLER  Handler  ){  LIST_ENTRY                                    *Link;  BM_BOOT_DESCRIPTION_ENTRY                    *Entry;  for ( Link = GetFirstNode (&mPlatformBootDescriptionHandlers)      ; !IsNull (&mPlatformBootDescriptionHandlers, Link)      ; Link = GetNextNode (&mPlatformBootDescriptionHandlers, Link)      ) {    Entry = CR (Link, BM_BOOT_DESCRIPTION_ENTRY, Link, BM_BOOT_DESCRIPTION_ENTRY_SIGNATURE);    if (Entry->Handler == Handler) {      return EFI_ALREADY_STARTED;    }  }  Entry = AllocatePool (sizeof (BM_BOOT_DESCRIPTION_ENTRY));  if (Entry == NULL) {    return EFI_OUT_OF_RESOURCES;  }  Entry->Signature = BM_BOOT_DESCRIPTION_ENTRY_SIGNATURE;  Entry->Handler   = Handler;  InsertTailList (&mPlatformBootDescriptionHandlers, &Entry->Link);  return EFI_SUCCESS;}

/**  Get the EFI_IFR_VARSTORE based the <ConfigHdr> string in a <ConfigRequest>  or a <ConfigResp> string.      @param FormSet                  The Form Set.  @param ConfigString             The Configuration String which is defined by UEFI HII.     @retval FORMSET_STORAGE *       The EFI_IFR_VARSTORE where the Question's value is stored.  @retval NULL                    If the Form Set does not have EFI_IFR_VARSTORE with such ID.**/FORMSET_STORAGE *GetStorageFromConfigString (  IN CONST FORM_BROWSER_FORMSET *FormSet,  IN  CONST EFI_STRING          ConfigString  ){  LIST_ENTRY             *StorageList;  FORMSET_STORAGE        *Storage;  CHAR16                 *Name;  if (ConfigString == NULL) {    return NULL;  }  StorageList = GetFirstNode (&FormSet->StorageListHead);  while (!IsNull (&FormSet->StorageListHead, StorageList)) {    Storage = FORMSET_STORAGE_FROM_LINK (StorageList);    if ((Storage->VarStoreId == FormSet->DefaultVarStoreId) && (FormSet->OriginalDefaultVarStoreName != NULL)) {      Name = FormSet->OriginalDefaultVarStoreName;    } else {      Name = Storage->Name;    }        if (HiiIsConfigHdrMatch (ConfigString, &Storage->Guid, Name)) {      return Storage;    }    StorageList = GetNextNode (&FormSet->StorageListHead, StorageList);  }  return NULL;}

FMessageLogListingModel::FPage* FMessageLogListingModel::PageAtIndex(const uint32 PageIndex) const{	check(PageIndex < (uint32)Pages.Num());	if(CachedPage != NULL && CachedPageIndex == PageIndex)	{		return CachedPage;	}	else	{		uint32 CurrentIndex = 0;		for(auto Node = Pages.GetHead(); Node; Node = Node->GetNextNode())		{			if(CurrentIndex == PageIndex)			{				CachedPage = &Node->GetValue();				CachedPageIndex = CurrentIndex;				return CachedPage;			}			CurrentIndex++;		}	}	check(false);	// Should never get here!	return NULL;}

/**  Validate the input screen diemenstion info.  @param  FormData               The input form data info.  @return EFI_SUCCESS            The input screen info is acceptable.  @return EFI_INVALID_PARAMETER  The input screen info is not acceptable.**/EFI_STATUS ScreenDiemensionInfoValidate (  IN FORM_DISPLAY_ENGINE_FORM       *FormData  ){  LIST_ENTRY           *Link;  UINTN                Index;  //  // Calculate total number of Register HotKeys.   //  Index = 0;  if (!IsListEmpty (&FormData->HotKeyListHead)){    Link  = GetFirstNode (&FormData->HotKeyListHead);    while (!IsNull (&FormData->HotKeyListHead, Link)) {      Link = GetNextNode (&FormData->HotKeyListHead, Link);      Index ++;    }  }  //  // Show three HotKeys help information on one row.  //  gFooterHeight = FOOTER_HEIGHT + (Index / 3);  ZeroMem (&gScreenDimensions, sizeof (EFI_SCREEN_DESCRIPTOR));  gST->ConOut->QueryMode (                 gST->ConOut,                 gST->ConOut->Mode->Mode,                 &gScreenDimensions.RightColumn,                 &gScreenDimensions.BottomRow                 );  //  // Check local dimension vs. global dimension.  //  if (FormData->ScreenDimensions != NULL) {    if ((gScreenDimensions.RightColumn < FormData->ScreenDimensions->RightColumn) ||        (gScreenDimensions.BottomRow < FormData->ScreenDimensions->BottomRow)        ) {      return EFI_INVALID_PARAMETER;    } else {      //      // Local dimension validation.      //      if ((FormData->ScreenDimensions->RightColumn > FormData->ScreenDimensions->LeftColumn) &&          (FormData->ScreenDimensions->BottomRow > FormData->ScreenDimensions->TopRow) &&          ((FormData->ScreenDimensions->RightColumn - FormData->ScreenDimensions->LeftColumn) > 2) &&          ((FormData->ScreenDimensions->BottomRow - FormData->ScreenDimensions->TopRow) > STATUS_BAR_HEIGHT +            FRONT_PAGE_HEADER_HEIGHT + gFooterHeight + 3)) {        CopyMem (&gScreenDimensions, (VOID *) FormData->ScreenDimensions, sizeof (EFI_SCREEN_DESCRIPTOR));      } else {        return EFI_INVALID_PARAMETER;      }    }  }  return EFI_SUCCESS;}

/**  Get the default value for Buffer Type storage named by  a Default Store from a FormSet.  The result is in the a instance of UEFI_IFR_BUFFER_STORAGE_NODE  allocated by this function. The output can be multiple instances  of UEFI_IFR_BUFFER_STORAGE_NODE. It is inserted to the link list.    @param  DefaultStore            The Default Store.  @param  FormSet                  The Form Set.  @param  UefiDefaultsListHead The head of link list for the output.  @retval   EFI_SUCCESS          Successful.  **/EFI_STATUSGetBufferTypeDefaultId (  IN  FORMSET_DEFAULTSTORE  *DefaultStore,  IN  FORM_BROWSER_FORMSET  *FormSet,  OUT       LIST_ENTRY      *UefiDefaultsListHead  ){  LIST_ENTRY                  *StorageLink;  FORMSET_STORAGE             *Storage;  EFI_STATUS                  Status;  StorageLink = GetFirstNode (&FormSet->StorageListHead);  while (!IsNull (&FormSet->StorageListHead, StorageLink)) {    Storage = FORMSET_STORAGE_FROM_LINK(StorageLink);    if (Storage->Type == EFI_HII_VARSTORE_BUFFER) {      Status = GetBufferTypeDefaultIdAndStorageId (DefaultStore, Storage, FormSet, UefiDefaultsListHead);      ASSERT_EFI_ERROR (Status);    }    StorageLink = GetNextNode (&FormSet->StorageListHead, StorageLink);  }    return EFI_SUCCESS;}

/*---------------------------------------------------------------------------------------*/EFI_STATUSEFIAPIRegisterSmmCoreEntry (  IN       UINTN  SmmCoreEntry  ){  EFI_STATUS            Status;  SMM_FOUNDATION_TABLE  *SmmInfo;  LIST_ENTRY            *Link;  // First open the Smm space  Status = mSmmAccess->Open (mSmmAccess);  if (EFI_ERROR (Status)) {    return (Status);  }  // Parse to SMM_INFO structure of all SMM cores  Link = mSmmInfoListHead;  do {      //And update the SmmCore entry in the structure    SmmInfo = SMM_FOUNDATION_FROM_LINK (Link);    SmmInfo->UefiSmmCoreBase = SmmCoreEntry;    Link = GetNextNode (mSmmInfoListHead, Link);  } while (Link != mSmmInfoListHead);  // Finally close the Smm space  Status = mSmmAccess->Close (mSmmAccess);  return Status;}

/**  Extract the default values from all questions in the input Form,   and set default value into the matched var storage.  @param  Form                   The Form which to be reset.  @param  DefaultId              The Class of the default.  @param  VarStoreId             Id of var storage.   @param  Node                   Var storage buffer to store the got default value.  @retval EFI_SUCCESS            The function completed successfully.**/EFI_STATUSExtractFormDefault (  IN FORM_BROWSER_FORM                *Form,  IN UINT16                           DefaultId,  IN UINT16                           VarStoreId,  OUT UEFI_IFR_BUFFER_STORAGE_NODE    *Node  ){  EFI_STATUS              Status;  LIST_ENTRY              *Link;  FORM_BROWSER_STATEMENT  *Question;  Link = GetFirstNode (&Form->StatementListHead);  while (!IsNull (&Form->StatementListHead, Link)) {    Question = FORM_BROWSER_STATEMENT_FROM_LINK (Link);    //    // Reset Question to its default value    //    Status = GetQuestionDefault (Question, DefaultId, VarStoreId, Node);    if (EFI_ERROR (Status)) {      continue;    }    Link = GetNextNode (&Form->StatementListHead, Link);  }  return EFI_SUCCESS;}

EFI_STATUSQNCSmmCoreUnRegister (  IN QNC_SMM_GENERIC_PROTOCOL                         *This,  IN EFI_HANDLE                                        DispatchHandle  )/*++Routine Description:Arguments:Returns:--*/// GC_TODO:    This - add argument and description to function comment// GC_TODO:    DispatchHandle - add argument and description to function comment// GC_TODO:    EFI_INVALID_PARAMETER - add return value to function comment// GC_TODO:    EFI_INVALID_PARAMETER - add return value to function comment// GC_TODO:    EFI_SUCCESS - add return value to function comment{  BOOLEAN         SafeToDisable;  DATABASE_RECORD *RecordToDelete;  DATABASE_RECORD *RecordInDb;  LIST_ENTRY      *LinkInDb;  if (DispatchHandle == NULL) {    return EFI_INVALID_PARAMETER;  }  if (BASE_CR (DispatchHandle, DATABASE_RECORD, Link)->Signature != DATABASE_RECORD_SIGNATURE) {    return EFI_INVALID_PARAMETER;  }  RecordToDelete = DATABASE_RECORD_FROM_LINK (DispatchHandle);  RemoveEntryList (&RecordToDelete->Link);  RecordToDelete->Signature = 0;  //  // See if we can disable the source, reserved for future use since this might  //  not be the only criteria to disable  //  SafeToDisable = TRUE;  LinkInDb = GetFirstNode (&mPrivateData.CallbackDataBase);  while(!IsNull (&mPrivateData.CallbackDataBase, LinkInDb)) {    RecordInDb = DATABASE_RECORD_FROM_LINK (LinkInDb);    if (CompareEnables (&RecordToDelete->SrcDesc, &RecordInDb->SrcDesc)) {      SafeToDisable = FALSE;      break;    }    LinkInDb = GetNextNode (&mPrivateData.CallbackDataBase, &RecordInDb->Link);  }  if (SafeToDisable) {    QNCSmmDisableSource( &RecordToDelete->SrcDesc );}  FreePool (RecordToDelete);  return EFI_SUCCESS;}

std::vector<double> TrianglesMeshReader<ELEMENT_DIM, SPACE_DIM>::GetNode(unsigned index){    if (!mFilesAreBinary)    {        EXCEPTION("Random access is only implemented in mesh readers for binary mesh files.");    }    if (index >= mNumNodes)    {        EXCEPTION("Node does not exist - not enough nodes.");    }    if (mNodePermutationDefined)    {        assert(index<mInversePermutationVector.size());        index = mInversePermutationVector[index];    }    // Put the file stream pointer to the right location    if ( index > mNodesRead )    {        // This is a monotonic (but non-contiguous) read.  Let's assume that it's more efficient        // to seek from the current position rather than from the start of the file        mNodesFile.seekg( mNodeItemWidth*(index-mNodesRead), std::ios_base::cur);    }    else if ( mNodesRead != index )    {        mNodesFile.seekg(mNodeFileDataStart + mNodeItemWidth*index, std::ios_base::beg);    }    mNodesRead = index; // Allow GetNextNode() to note the position of the item after this one    // Read the next item.    return GetNextNode();}

/**  Given a Package List with only a IFR package, find the Package List that only has a String Package based on  the TAG GUID. Then export the String Package from the Package List and insert it  to the given IFR package.  This is to handle the case of Framework HII interface which allow String Package  and IFR package to be registered using two different NewPack () calls.  @param Private                      The HII THUNK driver context data.  @param IfrThunkContext              Package List with only a IFR package.  @retval EFI_SUCCESS                 If the String Package is found and inserted to the                                      Package List with only a IFR package.  @retval EFI_NOT_FOUND               No String Package matching the TAG GUID is found.**/EFI_STATUSFindStringPackAndUpdatePackListWithOnlyIfrPack (  IN HII_THUNK_PRIVATE_DATA          *Private,  IN HII_THUNK_CONTEXT                *IfrThunkContext  ){  EFI_STATUS                      Status;  LIST_ENTRY                      *Link;  EFI_HII_PACKAGE_LIST_HEADER     *StringPackageListHeader;  UINTN                           Size;  HII_THUNK_CONTEXT               *ThunkContext;    Link = GetFirstNode (&Private->ThunkContextListHead);  while (!IsNull (&Private->ThunkContextListHead, Link)) {    ThunkContext = HII_THUNK_CONTEXT_FROM_LINK (Link);    if (ThunkContext != IfrThunkContext) {      if (CompareGuid (&IfrThunkContext->TagGuid, &ThunkContext->TagGuid) && (ThunkContext->IfrPackageCount == 0)) {        StringPackageListHeader = NULL;        Status = ExportPackageLists (ThunkContext->UefiHiiHandle, &StringPackageListHeader, &Size);        ASSERT_EFI_ERROR (Status);        if (StringPackageListHeader == NULL) {          return EFI_NOT_FOUND;        }        IfrThunkContext->StringPackageCount = GetPackageCountByType (StringPackageListHeader, EFI_HII_PACKAGE_STRINGS);        //        // Add Function to only get only String Packages from the Package List        //        Status = mHiiDatabase->UpdatePackageList (                                  mHiiDatabase,                                  IfrThunkContext->UefiHiiHandle,                                  StringPackageListHeader                                  );        ASSERT_EFI_ERROR (Status);                FreePool (StringPackageListHeader);        IfrThunkContext->SharingStringPack = TRUE;        ThunkContext->SharingStringPack = TRUE;                return EFI_SUCCESS;      }    }    Link = GetNextNode (&Private->ThunkContextListHead, Link);  }  //  // A Form Package must have a String Package to function.  // If ASSERT here, check the sequence of call to Hii->NewPack.   // String Pack must be registered before Ifr Package is registered.  //  ASSERT (FALSE);  return EFI_NOT_FOUND;  }

void nofGeologist::GoToNextNode(){    // Wenn es keine Flagge mehr gibt, dann gleich rumirren    if(!flag)    {        StartWandering();        Wander();        state = STATE_FIGUREWORK;        return;    }    // ersten Punkt suchen    unsigned char dir = GetNextNode();    if(dir != 0xFF)    {        // Wenn es einen Punkt gibt, dann hingehen        state = STATE_GEOLOGIST_GOTONEXTNODE;        StartWalking(dir);        --signs;    }    else    {        // ansonsten zur Flagge zurückgehen        state = STATE_GOTOFLAG;        Walked();    }}

//// Add callback note in terms with priority. Highest first//VOIDEFIAPIAddCallbackNode (  IN  PSP_SMM_CALLBACK_NODE *NewNode  ){  EFI_LIST_ENTRY          *Node;  if (IsListEmpty (&PspHeadList)) {    InsertTailList (&PspHeadList, &(NewNode->ListEntry));    return;  } for (Node = GetFirstNode (&PspHeadList);      Node != & PspHeadList;      Node = GetNextNode (&PspHeadList, Node)) {    if (NewNode->CallbackPriority >= ((PSP_SMM_CALLBACK_NODE *)Node)->CallbackPriority) {      InsertHeadList (Node->BackLink, &(NewNode->ListEntry));      return;    }  }  InsertTailList (&PspHeadList, &(NewNode->ListEntry));  return;}

EFI_STATUSEFIAPIPspResumeServiceCallBack (  IN       UINT8 ResumeType   ){  EFI_LIST_ENTRY   *Node;  CHAR8 *ResumeTypeStr;  ResumeTypeStr = ((ResumeType == ResumeFromConnectedStandby) ? "S0i3" : ((ResumeType == ResumeFromS3) ? "S3" : "Unsupported"));  PSP_DEBUG ("Psp.ResumeServiceCallBack %s/n", ResumeTypeStr);  for (Node = GetFirstNode (&PspHeadList);       Node != &PspHeadList;       Node = GetNextNode (&PspHeadList, Node)) {    PSP_DEBUG ("Call PspResumeService.Hook at 0x%08x/n", (UINTN) ((PSP_SMM_CALLBACK_NODE *)Node)->CallBackFunction);    // Call all registered callback function in order of priority and pass the resume type    ((PSP_SMM_CALLBACK_NODE *)Node)->CallBackFunction (    ResumeType,    ((PSP_SMM_CALLBACK_NODE *)Node)->Context    );   }  return EFI_SUCCESS;}

/**  Internal worker function that returns a pointer to the  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT structure associated with the  DispatchHandle that was returned when the periodic SMI handler was enabled  with PeriodicSmiEnable().  If DispatchHandle is NULL, then the active  periodic SMI handler is returned.  If DispatchHandle is NULL and there is  no active periodic SMI handler, then NULL is returned.  @param[in] DispatchHandle  DispatchHandle that was returned when the periodic                             SMI handler was enabled with PeriodicSmiEnable().                             This is an optional parameter that may be NULL.                             If this parameter is NULL, then the active periodic                             SMI handler is returned.  @retval  NULL   DispatchHandle is NULL and there is no active periodic SMI                  handler.  @retval  NULL   DispatchHandle does not match any of the periodic SMI handlers                  that have been enabled with PeriodicSmiEnable().  @retval  other  Pointer to the PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT                  associated with the DispatchHandle.**/PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT *LookupPeriodicSmiLibraryHandler (  IN EFI_HANDLE                         DispatchHandle    OPTIONAL  ){  LIST_ENTRY                            *Link;  PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT  *PeriodicSmiLibraryHandler;  //  // If DispatchHandle is NULL, then return the active periodic SMI handler  //  if (DispatchHandle == NULL) {    return GetActivePeriodicSmiLibraryHandler ();  }  //  // Search the periodic SMI handler entries for a a matching DispatchHandle  //  for ( Link = GetFirstNode (&gPeriodicSmiLibraryHandlers)      ; !IsNull (&gPeriodicSmiLibraryHandlers, Link)      ; Link = GetNextNode (&gPeriodicSmiLibraryHandlers, Link)      ) {    PeriodicSmiLibraryHandler = PERIODIC_SMI_LIBRARY_HANDLER_CONTEXT_FROM_LINK (Link);    if (PeriodicSmiLibraryHandler->DispatchHandle == DispatchHandle) {      return PeriodicSmiLibraryHandler;    }  }  //  // No entries match DispatchHandle, so return NULL  //  return NULL;}