///*
// * refit/list.c
// * list manager functions
// *
// * Copyright (c) 2013 Cadet-petit Armel
// * All rights reserved.
// *
// * Redistribution and use in source and binary forms, with or without
// * modification, are permitted provided that the following conditions are
// * met:
// *
// *  * Redistributions of source code must retain the above copyright
// *    notice, this list of conditions and the following disclaimer.
// *
// *  * Redistributions in binary form must reproduce the above copyright
// *    notice, this list of conditions and the following disclaimer in the
// *    documentation and/or other materials provided with the
// *    distribution.
// *
// *  * Neither the name of Cadet-petit Armel nor the names of the
// *    contributors may be used to endorse or promote products derived
// *    from this software without specific prior written permission.
// *
// * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// */
//
//#include "Platform.h"
//#include "list.h"
//
//
//#ifndef DEBUG_ALL
//#define DEBUG_LIST 1
//#else
//#define DEBUG_LIST DEBUG_ALL
//#endif
//
//#if DEBUG_LIST == 0
//#define DBG(...)
//#else
//#define DBG(...) DebugLog(DEBUG_LIST, __VA_ARGS__)
//#endif
//
//
//EFI_STATUS
//CreateListElement(IN OUT LIST_ENTRY   *List)
//{
//
//  //
//  // Check for invalid input parameters
//  //
//  if (List == NULL) {
//    return EFI_INVALID_PARAMETER;
//  }
//
//  //
//  // Initializes the List
//  //
//  InitializeListHead (List);
//
//  return EFI_SUCCESS;
//}
//
//#ifdef RELEASE_LIST
//EFI_STATUS
//AddListElement(
//                IN OUT LIST_ENTRY               *List,
//                IN VOID                         *Element,
//                IN OUT UINTN                    *CurrentHandle,
//                IN LIST_ELEMENT_CONSTRUCTOR     Constructor            OPTIONAL,
//                IN LIST_ELEMENT_DESTRUCTOR      Destructor             OPTIONAL,
//                IN VOID                         *ConstructorParameters OPTIONAL
//
//                )
//#else
//EFI_STATUS
//Add_ListElement(
//               IN OUT LIST_ENTRY               *List,
//               IN VOID                         *Element,
//               IN OUT UINTN                    *CurrentHandle,
//               IN LIST_ELEMENT_CONSTRUCTOR     Constructor            OPTIONAL,
//               IN LIST_ELEMENT_DESTRUCTOR      Destructor             OPTIONAL,
//               IN VOID                         *ConstructorParameters OPTIONAL
//
//               )
//#endif
//{
//
//  REFIT_LIST       *CurrentList;
//  EFI_STATUS       Status;
//  UINTN            Handle;
//
//
//
//  //
//  // Check for invalid input parameters
//  //
//  if (List == NULL) {
//    return EFI_INVALID_PARAMETER;
//  }
//
//  if (CurrentHandle == NULL) {
//    return EFI_INVALID_PARAMETER;
//  }
//
//  Handle = *CurrentHandle;
//
//  //
//  // Initializes the element if the Constructor is not NULL
//  //
//  if (Constructor != NULL) {
//
//    Status = Constructor(&Element, ConstructorParameters);
//
//    if (EFI_ERROR(Status)) {
//      return EFI_ABORTED;
//    }
//#ifdef DEBUG_LIST
//    if (Destructor == NULL) {
//      DBG("Warning: The element have a constructor but no destructor, possible memory leak !!!\n");
//    }
//#endif
//  }
//#ifdef DEBUG_LIST
//  else {
//
//    if (Element == NULL) {
//      return EFI_INVALID_PARAMETER;
//    }
//
//    if (Destructor != NULL) {
//      DBG("Warning: The element have a destructor but no constructor, an unpredictable bug may occur (or not) !!!\n");
//    }
//  }
//#endif
//
//  //
//  // Create a new list entry
//  //
//  CurrentList = (__typeof__(CurrentList))AllocateZeroPool(sizeof (REFIT_LIST));
//
//  if (!CurrentList) {
//    return EFI_OUT_OF_RESOURCES;
//  }
//
//  //
//  // Increment the handle
//  //
//  Handle++;
//
//  //
//  // Initialize the list entry contents
//  //
//  CurrentList->Element     = Element;
//  CurrentList->Signature   = REFIT_LIST_SIGNATURE;
//  CurrentList->Destructor  = Destructor;
//  CurrentList->Handle      = Handle;
//
//  //
//  // NOTE: It should be useless to store this but let store it anyway
//  //
//  CurrentList->Constructor = Constructor;
//  CurrentList->ConstructorParameters = ConstructorParameters;
//
//  //
//  // Return the handle
//  //
//  *CurrentHandle = Handle;
//
//  //
//  // Insert the list entry at the end of the list
//  //
//  InsertTailList (List, &CurrentList->Link);
//
//  return EFI_SUCCESS;
//}
//
//LIST_ENTRY *
//FindElementByHandle(
//                    IN      LIST_ENTRY                *List,
//                    IN      CONST UINTN               Handle
//                    )
//{
//
//  LIST_ENTRY		             *Link;
//	REFIT_LIST                 *Entry;
//
//  //
//  // Check for invalid input parameters
//  //
//  if (List == NULL) {
//    return NULL;
//  }
//
//  if (Handle == 0) {
//    //
//    // The first handle of the list is 1, if 0 is passed in parameters it's useless to go further
//    // and we return the list pointer
//    //
//    return List;
//  }
//
//  //
//  // Find the entry in the list with the given handle (if any)
//  //
//  if (IsListEmpty(List) == FALSE) {
//		for (Link = List->ForwardLink; Link != List; Link = Link->ForwardLink) {
//
//      if (Link != NULL) {
//
//        if (Link != List) {
//
//          Entry = CR(Link, REFIT_LIST, Link, REFIT_LIST_SIGNATURE);
//
//          if (Entry  != NULL) {
//
//            if (Handle == Entry->Handle) {
//              return Link;
//
//            }
//          }
//        }
//
//      }
//	}
//  }
//
//  return List;
//}
//
//EFI_STATUS
//RemoveElementByHandle(
//                      IN OUT  LIST_ENTRY                *List,
//                      IN      CONST UINTN               Handle
//                      )
//{
//
//  LIST_ENTRY		         *Link;
//  REFIT_LIST                 *Entry;
//  EFI_STATUS                 Status;
//  VOID                       *Element;
//
//  //
//  // Check for invalid input parameters
//  //
//  if (List == NULL) {
//    return EFI_INVALID_PARAMETER;
//  }
//
//  if (Handle == 0) {
//    //
//    // The first handle of the list is 1, if 0 is passed in parameters it's useless to go further
//    // and we return the list pointer
//    //
//    return EFI_INVALID_PARAMETER;
//  }
//
//  //
//  // Remove and Free the entry of the list with the given handle
//  // (additionally destroy the associated element if the destructor is not NULL)
//  //
//  if ((Link = FindElementByHandle(List,Handle)) != List) {
//
//    if (Link != NULL) {
//
//      Entry = CR(Link, REFIT_LIST, Link, REFIT_LIST_SIGNATURE);
//
//      if (Entry != NULL) {
//        Element = Entry->Element;
//
//        if (Element != NULL) {
//          if (Entry->Destructor != NULL) {
//
//            //
//            // Destroy the element with the given destructor
//            //
//            Status = Entry->Destructor(&Element);
//
//            if (EFI_ERROR(Status)) {
//              return EFI_ABORTED;
//            }
//
//          }
//        }
//
//        RemoveEntryList (Link);
//
//        FreePool(Entry);
//      }
//
//    }
//
//  } else {
//    return EFI_NOT_FOUND;
//  }
//
//  return EFI_SUCCESS;
//}
//
//EFI_STATUS
//FreeListElement(IN OUT LIST_ENTRY *List)
//{
//  LIST_ENTRY		             *Link;
//	REFIT_LIST                 *Entry;
//  VOID                       *Element;
//  EFI_STATUS                 Status;
//
//  //
//  // Check for invalid input parameters
//  //
//  if (List == NULL) {
//    return EFI_INVALID_PARAMETER;
//  }
//
//  //
//  // Remove and Free all entrys of the list (additionally destroy all elements that have a destructor)
//  //
//  if (IsListEmpty(List) == FALSE) {
//		for (Link = List->ForwardLink; Link != List; Link = Link->ForwardLink) {
//
//      if (Link != NULL) {
//
//        if (Link != List) {
//          Entry = CR(Link, REFIT_LIST, Link, REFIT_LIST_SIGNATURE);
//
//          if (Entry != NULL) {
//            Element = Entry->Element;
//
//            if (Element != NULL) {
//              if (Entry->Destructor != NULL) {
//
//                //
//                // Destroy the element with the given destructor
//                //
//                Status = Entry->Destructor(&Element);
//
//                if (EFI_ERROR(Status)) {
//                  return EFI_ABORTED;
//                }
//
//              }
//            }
//
//            RemoveEntryList (Link);
//
//            FreePool(Entry);
//
//          }
//        }
//      }
//		}
//	} else {
//    return EFI_NOT_FOUND;
//  }
//
//  return EFI_SUCCESS;
//
//}
//
//// EOF