2 will go in the multiple value parameter pool.
#
# Therefore the following parameter names must be provided to this macro:
# Parameters:
#   NAME
#     - mandatory, single value
#     - the value following it will be used to build the CMake module file name.
#     - e.g.: providing NAME "ICU" as parameters, FindICU.cmake will be used for the search.
#   FOUND_VAR
#     - mandatory, single value
#     - the variable that the FindXXX.cmake module sets if the library is found
#     - e.g.: FOUND_VAR "XERCESC_FOUND" when trying to find XercesC
#   SEARCH_NAMES
#     - mandatory, multiple value
#     - the possible directory name fragments that this library can have
#     - e.g.: SEARCH_NAMES "icu" "i_c_u" "uci"
#   COMPONENTS
#     - optional, multiple value
#
# Once done this will define:
#   FOUND_LOCATION - The directory where the library was found
#
MACRO (FIND_PACKAGE_WIN32)

  IF (NOT WIN32)
    MESSAGE (FATAL_ERROR "This macro is intended only for Windows platforms.")
  ENDIF (NOT WIN32)

  PARSE_ARGUMENTS(MODULE "SEARCH_NAMES;COMPONENTS" "NAME;FOUND_VAR" "" ${ARGN})
  
  IF(NOT MODULE_NAME)
    MESSAGE (FATAL_ERROR "'NAME' argument is required")
  ENDIF(NOT MODULE_NAME)
  IF(NOT MODULE_FOUND_VAR)
    MESSAGE (FATAL_ERROR "'FOUND_VAR' argument is required")
  ENDIF(NOT MODULE_FOUND_VAR)
  IF(NOT MODULE_SEARCH_NAMES)
    MESSAGE (FATAL_ERROR "'SEARCH_NAMES' argument is required")
  ENDIF(NOT MODULE_SEARCH_NAMES)
  
  PRINT_FIND_TITLE (${MODULE_NAME})
  
  # reset the output variable where the target library is found
  SET (FOUND_LOCATION)

  # if not already provided add the program files directory
  SET (SEARCH_PATHS ${ZORBA_THIRD_PARTY_REQUIREMENTS})

  STRING (REGEX MATCHALL "machine:x64" MACHINE_X64_FOUND "${CMAKE_EXE_LINKER_FLAGS}")
  IF(MACHINE_X64_FOUND)
    LIST (FIND SEARCH_PATHS "C:/Program Files" PRORAM_FILES_FOUND)
    IF (PRORAM_FILES_FOUND EQUAL -1)
      SET (SEARCH_PATHS "${SEARCH_PATHS}" "C:/Program Files")
    ENDIF (PRORAM_FILES_FOUND EQUAL -1)
  ELSE(MACHINE_X64_FOUND)
    LIST (FIND SEARCH_PATHS "$ENV{ProgramFiles}" PRORAM_FILES_FOUND)
    IF (PRORAM_FILES_FOUND EQUAL -1)
      SET (SEARCH_PATHS "${SEARCH_PATHS}" "$ENV{ProgramFiles}")
    ENDIF (PRORAM_FILES_FOUND EQUAL -1)
  ENDIF(MACHINE_X64_FOUND)
  
  
  LIST (FIND SEARCH_PATHS "$ENV{ProgramFiles}" PRORAM_FILES_FOUND)
  IF (PRORAM_FILES_FOUND EQUAL -1)
    SET (SEARCH_PATHS "${SEARCH_PATHS}" "$ENV{ProgramFiles}")
  ENDIF (PRORAM_FILES_FOUND EQUAL -1)

  SET (PATH_REGEX)
  FOREACH (PATH ${SEARCH_PATHS})
    FILE (TO_CMAKE_PATH "${PATH}" PATH)
    FOREACH (NAME ${MODULE_SEARCH_NAMES})
      SET (PATH_REGEX ${PATH_REGEX} "${PATH}/*${NAME}*")
    ENDFOREACH (NAME)
  ENDFOREACH (PATH)

  # search the SEARCH_PATHS for folders containing one of the names in SEARCH_NAMES
  FILE (GLOB MATCHED_DIRS ${PATH_REGEX})

  # the list to gather all the prefix paths to be searched
  SET (LIST_CMAKE_PREFIX_PATH)

  # the list of found directories will be added to the paths LIST_CMAKE_PREFIX_PATH and
  # thus will be used by the real Find${MODULE_NAME}.cmake module
  FOREACH (DIR ${MATCHED_DIRS})
    MESSAGE (STATUS "${MODULE_NAME} will be searched for in: [ZORBA_THIRD_PARTY_REQUIREMENTS] ${DIR}")
    SET (LIST_CMAKE_PREFIX_PATH ${LIST_CMAKE_PREFIX_PATH} ${DIR})
  ENDFOREACH (DIR)

  # add all the paths from the PATH environment variable that contain one of the names in SEARCH_NAMES
  FOREACH (PATH $ENV{PATH})
    FILE (TO_CMAKE_PATH "${PATH}" PATH)
    STRING (TOLOWER "${PATH}" LC_PATH)

    # now iterate over all the possible names
    FOREACH (NAME ${MODULE_SEARCH_NAMES})
      STRING (TOLOWER "${NAME}" LC_NAME)
      IF ("${LC_PATH}" MATCHES ".*${LC_NAME}.*")
        IF (EXISTS "${PATH}/include")
          MESSAGE (STATUS "${MODULE_NAME} will be searched for in: [PATH environment variable] ${PATH}")
          SET (LIST_CMAKE_PREFIX_PATH ${LIST_CMAKE_PREFIX_PATH} ${PATH})
        ELSEIF (EXISTS "${PATH}/../include")
          MESSAGE (STATUS "${MODULE_NAME} will be searched for in: [PATH environment variable] ${PATH}/..")
          SET (LIST_CMAKE_PREFIX_PATH ${LIST_CMAKE_PREFIX_PATH} ${PATH}/..)
        ENDIF (EXISTS "${PATH}/include")
      ENDIF ("${LC_PATH}" MATCHES ".*${LC_NAME}.*")
    ENDFOREACH (NAME)
  ENDFOREACH (PATH)

  # print some help
  IF (NOT LIST_CMAKE_PREFIX_PATH)
    MESSAGE (STATUS "No candidate ${MODULE_NAME} directory was found in the paths: ${SEARCH_PATHS};%PATH%")
    MESSAGE (STATUS "You might want to check the following:")
    MESSAGE (STATUS "  1. Did you set ZORBA_THIRD_PARTY_REQUIREMENTS properly?")
    MESSAGE (STATUS "  2. Is your ${MODULE_NAME} directory matching one of the search names: ${SEARCH_NAMES}?")
    MESSAGE (STATUS "  3. Is ${MODULE_NAME} or its \"bin\" directory in the PATH environment variable?")
  ENDIF (NOT LIST_CMAKE_PREFIX_PATH)

  # remove the Windows module path (both from Zorba or the external modules)
  # to avoid an infinite recursion
  FOREACH (PATH ${CMAKE_MODULE_PATH})
    IF ("${PATH}" MATCHES ".*/cmake_modules/Windows")
      LIST (REMOVE_ITEM CMAKE_MODULE_PATH "${PATH}")
    ENDIF ("${PATH}" MATCHES ".*/cmake_modules/Windows")
  ENDFOREACH (PATH)

  # before we start searching, we save the old CMAKE_PREFIX_PATH
  SET (OLD_CMAKE_PREFIX_PATH ${CMAKE_PREFIX_PATH})
  
  # now try to find the module for each path in LIST_CMAKE_PREFIX_PATH
  FOREACH(PATH ${LIST_CMAKE_PREFIX_PATH})
    # set the CMAKE_PREFIX_PATH to the probed path
    SET (CMAKE_PREFIX_PATH ${PATH})

    # call the real Find${MODULE_NAME}.cmake module
    IF(NOT MODULE_COMPONENTS)
      FIND_PACKAGE (${MODULE_NAME})
    ELSE(NOT MODULE_COMPONENTS)
      FIND_PACKAGE (${MODULE_NAME} COMPONENTS ${MODULE_COMPONENTS})
    ENDIF(NOT MODULE_COMPONENTS)
    
    IF (${MODULE_FOUND_VAR})
      SET (FOUND_LOCATION ${CMAKE_PREFIX_PATH})
      BREAK ()
    ENDIF (${MODULE_FOUND_VAR})
  ENDFOREACH(PATH)

  PRINT_FIND_END_TITLE (${MODULE_NAME} FOUND_LOCATION)

  # restore the module path
  SET (CMAKE_MODULE_PATH ${PROJECT_SOURCE_