The Tor Browser / file revision

 # This Source Code Form is subject to the terms of the Mozilla Public

 # License, v. 2.0. If a copy of the MPL was not distributed with this

 # file, You can obtain one at http://mozilla.org/MPL/2.0/.

 ################################################################################

 # Helper defines and macros for toolkit applications

 /**

  * Avoid creating macros / functions that overwrite registers (see the

  * GetLongPath macro for one way to avoid this)!

  *

  * Before using the registers exchange the passed in params and save existing

  * register values to the stack.

  *

  * Exch $R9 ; exhange the original $R9 with the top of the stack

  * Exch 1   ; exchange the top of the stack with 1 below the top of the stack

  * Exch $R8 ; exchange the original $R8 with the top of the stack

  * Exch 2   ; exchange the top of the stack with 2 below the top of the stack

  * Exch $R7 ; exchange the original $R7 with the top of the stack

  * Push $R6 ; push the original $R6 onto the top of the stack

  * Push $R5 ; push the original $R5 onto the top of the stack

  * Push $R4 ; push the original $R4 onto the top of the stack

  *

  * <do stuff>

  *

  * ; Restore the values.

  * Pop $R4  ; restore the value for $R4 from the top of the stack

  * Pop $R5  ; restore the value for $R5 from the top of the stack

  * Pop $R6  ; restore the value for $R6 from the top of the stack

  * Exch $R7 ; exchange the new $R7 value with the top of the stack

  * Exch 2   ; exchange the top of the stack with 2 below the top of the stack

  * Exch $R8 ; exchange the new $R8 value with the top of the stack

  * Exch 1   ; exchange the top of the stack with 2 below the top of the stack

  * Exch $R9 ; exchange the new $R9 value with the top of the stack

  *

  *

  * When inserting macros in common.nsh from another macro in common.nsh that

  * can be used from the uninstaller _MOZFUNC_UN will be undefined when it is

  * inserted. Use the following to redefine _MOZFUNC_UN with its original value

  * (see the RegCleanMain macro for an example).

  *

  * !define _MOZFUNC_UN_TMP ${_MOZFUNC_UN}

  * !insertmacro ${_MOZFUNC_UN_TMP}FileJoin

  * !insertmacro ${_MOZFUNC_UN_TMP}LineFind

  * !insertmacro ${_MOZFUNC_UN_TMP}TextCompareNoDetails

  * !insertmacro ${_MOZFUNC_UN_TMP}TrimNewLines

  * !undef _MOZFUNC_UN

  * !define _MOZFUNC_UN ${_MOZFUNC_UN_TMP}

  * !undef _MOZFUNC_UN_TMP

  */

 ; When including a file provided by NSIS check if its verbose macro is defined

 ; to prevent loading the file a second time.

 !ifmacrondef TEXTFUNC_VERBOSE

   !include TextFunc.nsh

 !endif

 !ifmacrondef FILEFUNC_VERBOSE

   !include FileFunc.nsh

 !endif

 !ifmacrondef LOGICLIB_VERBOSITY

   !include LogicLib.nsh

 !endif

 !ifndef WINMESSAGES_INCLUDED

   !include WinMessages.nsh

 !endif

 ; When including WinVer.nsh check if ___WINVER__NSH___ is defined to prevent

 ; loading the file a second time.

 !ifndef ___WINVER__NSH___

   !include WinVer.nsh

 !endif

 !include x64.nsh

 ; NSIS provided macros that we have overridden.

 !include overrides.nsh

 !define SHORTCUTS_LOG "shortcuts_log.ini"

 !define TO_BE_DELETED "tobedeleted"

 ; !define SHCNF_DWORD     0x0003

 ; !define SHCNF_FLUSH     0x1000

 !ifndef SHCNF_DWORDFLUSH

   !define SHCNF_DWORDFLUSH 0x1003

 !endif

 !ifndef SHCNE_ASSOCCHANGED

   !define SHCNE_ASSOCCHANGED 0x08000000

 !endif

 ################################################################################

 # Macros for debugging

 /**

  * The following two macros assist with verifying that a macro doesn't

  * overwrite any registers.

  *

  * Usage:

  * ${debugSetRegisters}

  * <do stuff>

  * ${debugDisplayRegisters}

  */

 /**

  * Sets all register values to their name to assist with verifying that a macro

  * doesn't overwrite any registers.

  */

 !macro debugSetRegisters

   StrCpy $0 "$$0"

   StrCpy $1 "$$1"

   StrCpy $2 "$$2"

   StrCpy $3 "$$3"

   StrCpy $4 "$$4"

   StrCpy $5 "$$5"

   StrCpy $6 "$$6"

   StrCpy $7 "$$7"

   StrCpy $8 "$$8"

   StrCpy $9 "$$9"

   StrCpy $R0 "$$R0"

   StrCpy $R1 "$$R1"

   StrCpy $R2 "$$R2"

   StrCpy $R3 "$$R3"

   StrCpy $R4 "$$R4"

   StrCpy $R5 "$$R5"

   StrCpy $R6 "$$R6"

   StrCpy $R7 "$$R7"

   StrCpy $R8 "$$R8"

   StrCpy $R9 "$$R9"

 !macroend

 !define debugSetRegisters "!insertmacro debugSetRegisters"

 /**

  * Displays all register values to assist with verifying that a macro doesn't

  * overwrite any registers.

  */

 !macro debugDisplayRegisters

   MessageBox MB_OK \

       "Register Values:$\n\

        $$0 = $0$\n$$1 = $1$\n$$2 = $2$\n$$3 = $3$\n$$4 = $4$\n\

        $$5 = $5$\n$$6 = $6$\n$$7 = $7$\n$$8 = $8$\n$$9 = $9$\n\

        $$R0 = $R0$\n$$R1 = $R1$\n$$R2 = $R2$\n$$R3 = $R3$\n$$R4 = $R4$\n\

        $$R5 = $R5$\n$$R6 = $R6$\n$$R7 = $R7$\n$$R8 = $R8$\n$$R9 = $R9"

 !macroend

 !define debugDisplayRegisters "!insertmacro debugDisplayRegisters"

 ################################################################################

 # Modern User Interface (MUI) override macros

 ; Removed macros in nsis 2.33u (ported from nsis 2.22)

 ;  MUI_LANGUAGEFILE_DEFINE

 ;  MUI_LANGUAGEFILE_LANGSTRING_PAGE

 ;  MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE

 ;  MUI_LANGUAGEFILE_LANGSTRING_DEFINE

 ;  MUI_LANGUAGEFILE_UNLANGSTRING_PAGE

 !macro MOZ_MUI_LANGUAGEFILE_DEFINE DEFINE NAME

   !ifndef "${DEFINE}"

     !define "${DEFINE}" "${${NAME}}"

   !endif

   !undef "${NAME}"

 !macroend

 !macro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE PAGE NAME

   !ifdef MUI_${PAGE}PAGE

     LangString "${NAME}" 0 "${${NAME}}"

     !undef "${NAME}"

   !else

     !undef "${NAME}"

   !endif

 !macroend

 !macro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE PAGE NAME

   !ifdef MUI_${PAGE}PAGE | MUI_UN${PAGE}PAGE

     LangString "${NAME}" 0 "${${NAME}}"

     !undef "${NAME}"

   !else

     !undef "${NAME}"

   !endif

 !macroend

 !macro MOZ_MUI_LANGUAGEFILE_LANGSTRING_DEFINE DEFINE NAME

   !ifdef "${DEFINE}"

     LangString "${NAME}" 0 "${${NAME}}"

   !endif

   !undef "${NAME}"

 !macroend

 !macro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE PAGE NAME

   !ifdef MUI_UNINSTALLER

     !ifdef MUI_UN${PAGE}PAGE

       LangString "${NAME}" 0 "${${NAME}}"

       !undef "${NAME}"

     !else

       !undef "${NAME}"

     !endif

   !else

     !undef "${NAME}"

   !endif

 !macroend

 ; Modified version of the following MUI macros to support Mozilla localization.

 ; MUI_LANGUAGE

 ; MUI_LANGUAGEFILE_BEGIN

 ; MOZ_MUI_LANGUAGEFILE_END

 ; See <NSIS App Dir>/Contrib/Modern UI/System.nsh for more information

 !define MUI_INSTALLOPTIONS_READ "!insertmacro MUI_INSTALLOPTIONS_READ"

 !macro MOZ_MUI_LANGUAGE LANGUAGE

   !verbose push

   !verbose ${MUI_VERBOSE}

   !include "${LANGUAGE}.nsh"

   !verbose pop

 !macroend

 !macro MOZ_MUI_LANGUAGEFILE_BEGIN LANGUAGE

   !insertmacro MUI_INSERT

   !ifndef "MUI_LANGUAGEFILE_${LANGUAGE}_USED"

     !define "MUI_LANGUAGEFILE_${LANGUAGE}_USED"

     LoadLanguageFile "${LANGUAGE}.nlf"

   !else

     !error "Modern UI language file ${LANGUAGE} included twice!"

   !endif

 !macroend

 ; Custom version of MUI_LANGUAGEFILE_END. The macro to add the default MUI

 ; strings and the macros for several strings that are part of the NSIS MUI and

 ; not in our locale files have been commented out.

 !macro MOZ_MUI_LANGUAGEFILE_END

 #  !include "${NSISDIR}\Contrib\Modern UI\Language files\Default.nsh"

   !ifdef MUI_LANGUAGEFILE_DEFAULT_USED

     !undef MUI_LANGUAGEFILE_DEFAULT_USED

     !warning "${LANGUAGE} Modern UI language file version doesn't match. Using default English texts for missing strings."

   !endif

   !insertmacro MOZ_MUI_LANGUAGEFILE_DEFINE "MUI_${LANGUAGE}_LANGNAME" "MUI_LANGNAME"

   !ifndef MUI_LANGDLL_PUSHLIST

     !define MUI_LANGDLL_PUSHLIST "'${MUI_${LANGUAGE}_LANGNAME}' ${LANG_${LANGUAGE}} "

   !else

     !ifdef MUI_LANGDLL_PUSHLIST_TEMP

       !undef MUI_LANGDLL_PUSHLIST_TEMP

     !endif

     !define MUI_LANGDLL_PUSHLIST_TEMP "${MUI_LANGDLL_PUSHLIST}"

     !undef MUI_LANGDLL_PUSHLIST

     !define MUI_LANGDLL_PUSHLIST "'${MUI_${LANGUAGE}_LANGNAME}' ${LANG_${LANGUAGE}} ${MUI_LANGDLL_PUSHLIST_TEMP}"

   !endif

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE WELCOME "MUI_TEXT_WELCOME_INFO_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE WELCOME "MUI_TEXT_WELCOME_INFO_TEXT"

 !ifdef MUI_TEXT_LICENSE_TITLE

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE LICENSE "MUI_TEXT_LICENSE_TITLE"

 !endif

 !ifdef MUI_TEXT_LICENSE_SUBTITLE

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE LICENSE "MUI_TEXT_LICENSE_SUBTITLE"

 !endif

 !ifdef MUI_INNERTEXT_LICENSE_TOP

   !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE LICENSE "MUI_INNERTEXT_LICENSE_TOP"

 !endif

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE LICENSE "MUI_INNERTEXT_LICENSE_BOTTOM"

 !ifdef MUI_INNERTEXT_LICENSE_BOTTOM_CHECKBOX

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE LICENSE "MUI_INNERTEXT_LICENSE_BOTTOM_CHECKBOX"

 !endif

 !ifdef MUI_INNERTEXT_LICENSE_BOTTOM_RADIOBUTTONS

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE LICENSE "MUI_INNERTEXT_LICENSE_BOTTOM_RADIOBUTTONS"

 !endif

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE COMPONENTS "MUI_TEXT_COMPONENTS_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE COMPONENTS "MUI_TEXT_COMPONENTS_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE COMPONENTS "MUI_INNERTEXT_COMPONENTS_DESCRIPTION_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE COMPONENTS "MUI_INNERTEXT_COMPONENTS_DESCRIPTION_INFO"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE DIRECTORY "MUI_TEXT_DIRECTORY_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE DIRECTORY "MUI_TEXT_DIRECTORY_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE STARTMENU "MUI_TEXT_STARTMENU_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE STARTMENU "MUI_TEXT_STARTMENU_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE STARTMENU "MUI_INNERTEXT_STARTMENU_TOP"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE STARTMENU "MUI_INNERTEXT_STARTMENU_CHECKBOX"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE INSTFILES "MUI_TEXT_INSTALLING_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE INSTFILES "MUI_TEXT_INSTALLING_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE INSTFILES "MUI_TEXT_FINISH_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE INSTFILES "MUI_TEXT_FINISH_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE INSTFILES "MUI_TEXT_ABORT_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE INSTFILES "MUI_TEXT_ABORT_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE FINISH "MUI_BUTTONTEXT_FINISH"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE FINISH "MUI_TEXT_FINISH_INFO_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE FINISH "MUI_TEXT_FINISH_INFO_TEXT"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_PAGE FINISH "MUI_TEXT_FINISH_INFO_REBOOT"

   !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE FINISH "MUI_TEXT_FINISH_REBOOTNOW"

   !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE FINISH "MUI_TEXT_FINISH_REBOOTLATER"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE FINISH "MUI_TEXT_FINISH_RUN"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_MULTILANGSTRING_PAGE FINISH "MUI_TEXT_FINISH_SHOWREADME"

 ; Support for using the existing MUI_TEXT_ABORTWARNING string

 !ifdef MOZ_MUI_CUSTOM_ABORT

     LangString MOZ_MUI_TEXT_ABORTWARNING 0 "${MUI_TEXT_ABORTWARNING}"

 !endif

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_DEFINE MUI_ABORTWARNING "MUI_TEXT_ABORTWARNING"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE WELCOME "MUI_UNTEXT_WELCOME_INFO_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE WELCOME "MUI_UNTEXT_WELCOME_INFO_TEXT"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE CONFIRM "MUI_UNTEXT_CONFIRM_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE CONFIRM "MUI_UNTEXT_CONFIRM_SUBTITLE"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE LICENSE "MUI_UNTEXT_LICENSE_TITLE"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE LICENSE "MUI_UNTEXT_LICENSE_SUBTITLE"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE LICENSE "MUI_UNINNERTEXT_LICENSE_BOTTOM"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE LICENSE "MUI_UNINNERTEXT_LICENSE_BOTTOM_CHECKBOX"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE LICENSE "MUI_UNINNERTEXT_LICENSE_BOTTOM_RADIOBUTTONS"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE COMPONENTS "MUI_UNTEXT_COMPONENTS_TITLE"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE COMPONENTS "MUI_UNTEXT_COMPONENTS_SUBTITLE"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE DIRECTORY "MUI_UNTEXT_DIRECTORY_TITLE"

 #  !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE DIRECTORY  "MUI_UNTEXT_DIRECTORY_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE INSTFILES "MUI_UNTEXT_UNINSTALLING_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE INSTFILES "MUI_UNTEXT_UNINSTALLING_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE INSTFILES "MUI_UNTEXT_FINISH_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE INSTFILES "MUI_UNTEXT_FINISH_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE INSTFILES "MUI_UNTEXT_ABORT_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE INSTFILES "MUI_UNTEXT_ABORT_SUBTITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE FINISH "MUI_UNTEXT_FINISH_INFO_TITLE"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE FINISH "MUI_UNTEXT_FINISH_INFO_TEXT"

   !insertmacro MOZ_MUI_LANGUAGEFILE_UNLANGSTRING_PAGE FINISH "MUI_UNTEXT_FINISH_INFO_REBOOT"

   !insertmacro MOZ_MUI_LANGUAGEFILE_LANGSTRING_DEFINE MUI_UNABORTWARNING "MUI_UNTEXT_ABORTWARNING"

   !ifndef MUI_LANGDLL_LANGUAGES

     !define MUI_LANGDLL_LANGUAGES "'${LANGFILE_${LANGUAGE}_NAME}' '${LANG_${LANGUAGE}}' "

     !define MUI_LANGDLL_LANGUAGES_CP "'${LANGFILE_${LANGUAGE}_NAME}' '${LANG_${LANGUAGE}}' '${LANG_${LANGUAGE}_CP}' "

   !else

     !ifdef MUI_LANGDLL_LANGUAGES_TEMP

       !undef MUI_LANGDLL_LANGUAGES_TEMP

     !endif

     !define MUI_LANGDLL_LANGUAGES_TEMP "${MUI_LANGDLL_LANGUAGES}"

     !undef MUI_LANGDLL_LANGUAGES

     !ifdef MUI_LANGDLL_LANGUAGES_CP_TEMP

       !undef MUI_LANGDLL_LANGUAGES_CP_TEMP

     !endif

     !define MUI_LANGDLL_LANGUAGES_CP_TEMP "${MUI_LANGDLL_LANGUAGES_CP}"

     !undef MUI_LANGDLL_LANGUAGES_CP

     !define MUI_LANGDLL_LANGUAGES "'${LANGFILE_${LANGUAGE}_NAME}' '${LANG_${LANGUAGE}}' ${MUI_LANGDLL_LANGUAGES_TEMP}"

     !define MUI_LANGDLL_LANGUAGES_CP "'${LANGFILE_${LANGUAGE}_NAME}' '${LANG_${LANGUAGE}}' '${LANG_${LANGUAGE}_CP}' ${MUI_LANGDLL_LANGUAGES_CP_TEMP}"

   !endif

 !macroend

 /**

  * Creates an InstallOptions file with a UTF-16LE BOM and adds the RTL value

  * to the Settings section.

  *

  * @param   _FILE

  *          The name of the file to be created in $PLUGINSDIR.

  */

 !macro InitInstallOptionsFile _FILE

   Push $R9

   FileOpen $R9 "$PLUGINSDIR\${_FILE}" w

   FileWriteWord $R9 "65279"

   FileClose $R9

   WriteIniStr "$PLUGINSDIR\${_FILE}" "Settings" "RTL" "$(^RTL)"

   Pop $R9

 !macroend

 ################################################################################

 # Macros for handling files in use

 /**

  * Checks for files in use in the $INSTDIR directory. To check files in

  * sub-directories this macro would need to be rewritten to create

  * sub-directories in the temporary directory used to backup the files that are

  * checked.

  *

  * Example usage:

  *

  *  ; The first string to be pushed onto the stack MUST be "end" to indicate

  *  ; that there are no more files in the $INSTDIR directory to check.

  *  Push "end"

  *  Push "freebl3.dll"

  *  ; The last file pushed should be the app's main exe so if it is in use this

  *  ; macro will return after the first check.

  *  Push "${FileMainEXE}"

  *  ${CheckForFilesInUse} $R9

  *

  * !IMPORTANT - this macro uses the $R7, $R8, and $R9 registers and makes no

  *              attempt to restore their original values.

  *

  * @return  _RESULT

  *          false if all of the files popped from the stack are not in use.

  *          True if any of the files popped from the stack are in use.

  * $R7 = Temporary backup directory where the files will be copied to.

  * $R8 = value popped from the stack. This will either be a file name for a file

  *       in the $INSTDIR directory or "end" to indicate that there are no

  *       additional files to check.

  * $R9 = _RESULT

  */

 !macro CheckForFilesInUse

   !ifndef ${_MOZFUNC_UN}CheckForFilesInUse

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}CheckForFilesInUse "!insertmacro ${_MOZFUNC_UN}CheckForFilesInUseCall"

     Function ${_MOZFUNC_UN}CheckForFilesInUse

       ; Create a temporary backup directory.

       GetTempFileName $R7 "$INSTDIR"

       Delete "$R7"

       SetOutPath "$R7"

       StrCpy $R9 "false"

       Pop $R8

       ${While} $R8 != "end"

         ${Unless} ${FileExists} "$INSTDIR\$R8"

           Pop $R8 ; get next file to check before continuing

           ${Continue}

         ${EndUnless}

         ClearErrors

         CopyFiles /SILENT "$INSTDIR\$R8" "$R7\$R8" ; try to copy

         ${If} ${Errors}

           ; File is in use

           StrCpy $R9 "true"

           ${Break}

         ${EndIf}

         Delete "$INSTDIR\$R8" ; delete original

         ${If} ${Errors}

           ; File is in use

           StrCpy $R9 "true"

           Delete "$R7\$R8" ; delete temp copy

           ${Break}

         ${EndIf}

         Pop $R8 ; get next file to check

       ${EndWhile}

       ; clear stack

       ${While} $R8 != "end"

         Pop $R8

       ${EndWhile}

       ; restore everything

       SetOutPath "$INSTDIR"

       CopyFiles /SILENT "$R7\*" "$INSTDIR\"

       RmDir /r "$R7"

       SetOutPath "$EXEDIR"

       ClearErrors

       Push $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro CheckForFilesInUseCall _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Call CheckForFilesInUse

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.CheckForFilesInUseCall _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Call un.CheckForFilesInUse

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.CheckForFilesInUse

   !ifndef un.CheckForFilesInUse

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro CheckForFilesInUse

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * The macros below will automatically prepend un. to the function names when

  * they are defined (e.g. !define un.RegCleanMain).

  */

 !verbose push

 !verbose 3

 !ifndef _MOZFUNC_VERBOSE

   !define _MOZFUNC_VERBOSE 3

 !endif

 !verbose ${_MOZFUNC_VERBOSE}

 !define MOZFUNC_VERBOSE "!insertmacro MOZFUNC_VERBOSE"

 !define _MOZFUNC_UN

 !define _MOZFUNC_S

 !verbose pop

 !macro MOZFUNC_VERBOSE _VERBOSE

   !verbose push

   !verbose 3

   !undef _MOZFUNC_VERBOSE

   !define _MOZFUNC_VERBOSE ${_VERBOSE}

   !verbose pop

 !macroend

 /**

  * Displays a MessageBox and then calls abort to prevent continuing to the

  * next page when the specified Window Class is found.

  *

  * @param   _WINDOW_CLASS

  *          The Window Class to search for with FindWindow.

  * @param   _MSG

  *          The message text to display in the message box.

  *

  * $R7 = return value from FindWindow

  * $R8 = _WINDOW_CLASS

  * $R9 = _MSG

  */

 !macro ManualCloseAppPrompt

   !ifndef ${_MOZFUNC_UN}ManualCloseAppPrompt

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}ManualCloseAppPrompt "!insertmacro ${_MOZFUNC_UN}ManualCloseAppPromptCall"

     Function ${_MOZFUNC_UN}ManualCloseAppPrompt

       Exch $R9

       Exch 1

       Exch $R8

       Push $R7

       FindWindow $R7 "$R8"

       ${If} $R7 <> 0 ; integer comparison

         MessageBox MB_OK|MB_ICONQUESTION "$R9"

         Abort

       ${EndIf}

       Pop $R7

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro ManualCloseAppPromptCall _WINDOW_CLASS _MSG

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_WINDOW_CLASS}"

   Push "${_MSG}"

   Call ManualCloseAppPrompt

   !verbose pop

 !macroend

 !macro un.ManualCloseAppPromptCall _WINDOW_CLASS _MSG

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_WINDOW_CLASS}"

   Push "${_MSG}"

   Call un.ManualCloseAppPrompt

   !verbose pop

 !macroend

 !macro un.ManualCloseAppPrompt

   !ifndef un.ManualCloseAppPrompt

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro ManualCloseAppPrompt

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 ################################################################################

 # Macros for working with the registry

 /**

  * Writes a registry string using SHCTX and the supplied params and logs the

  * action to the install log and the uninstall log if _LOG_UNINSTALL equals 1.

  *

  * Define NO_LOG to prevent all logging when calling this from the uninstaller.

  *

  * @param   _ROOT

  *          The registry key root as defined by NSIS (e.g. HKLM, HKCU, etc.).

  *          This will only be used for logging.

  * @param   _KEY

  *          The subkey in relation to the key root.

  * @param   _NAME

  *          The key value name to write to.

  * @param   _STR

  *          The string to write to the key value name.

  * @param   _LOG_UNINSTALL

  *          0 = don't add to uninstall log, 1 = add to uninstall log.

  *

  * $R5 = _ROOT

  * $R6 = _KEY

  * $R7 = _NAME

  * $R8 = _STR

  * $R9 = _LOG_UNINSTALL

  */

 !macro WriteRegStr2

   !ifndef ${_MOZFUNC_UN}WriteRegStr2

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}WriteRegStr2 "!insertmacro ${_MOZFUNC_UN}WriteRegStr2Call"

     Function ${_MOZFUNC_UN}WriteRegStr2

       Exch $R9

       Exch 1

       Exch $R8

       Exch 2

       Exch $R7

       Exch 3

       Exch $R6

       Exch 4

       Exch $R5

       ClearErrors

       WriteRegStr SHCTX "$R6" "$R7" "$R8"

       !ifndef NO_LOG

         ${If} ${Errors}

           ${LogMsg} "** ERROR Adding Registry String: $R5 | $R6 | $R7 | $R8 **"

         ${Else}

           ${If} $R9 == 1 ; add to the uninstall log?

             ${LogUninstall} "RegVal: $R5 | $R6 | $R7"

           ${EndIf}

           ${LogMsg} "Added Registry String: $R5 | $R6 | $R7 | $R8"

         ${EndIf}

       !endif

       Exch $R5

       Exch 4

       Exch $R6

       Exch 3

       Exch $R7

       Exch 2

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro WriteRegStr2Call _ROOT _KEY _NAME _STR _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_NAME}"

   Push "${_STR}"

   Push "${_LOG_UNINSTALL}"

   Call WriteRegStr2

   !verbose pop

 !macroend

 !macro un.WriteRegStr2Call _ROOT _KEY _NAME _STR _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_NAME}"

   Push "${_STR}"

   Push "${_LOG_UNINSTALL}"

   Call un.WriteRegStr2

   !verbose pop

 !macroend

 !macro un.WriteRegStr2

   !ifndef un.WriteRegStr2

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro WriteRegStr2

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Writes a registry dword using SHCTX and the supplied params and logs the

  * action to the install log and the uninstall log if _LOG_UNINSTALL equals 1.

  *

  * Define NO_LOG to prevent all logging when calling this from the uninstaller.

  *

  * @param   _ROOT

  *          The registry key root as defined by NSIS (e.g. HKLM, HKCU, etc.).

  *          This will only be used for logging.

  * @param   _KEY

  *          The subkey in relation to the key root.

  * @param   _NAME

  *          The key value name to write to.

  * @param   _DWORD

  *          The dword to write to the key value name.

  * @param   _LOG_UNINSTALL

  *          0 = don't add to uninstall log, 1 = add to uninstall log.

  *

  * $R5 = _ROOT

  * $R6 = _KEY

  * $R7 = _NAME

  * $R8 = _DWORD

  * $R9 = _LOG_UNINSTALL

  */

 !macro WriteRegDWORD2

   !ifndef ${_MOZFUNC_UN}WriteRegDWORD2

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}WriteRegDWORD2 "!insertmacro ${_MOZFUNC_UN}WriteRegDWORD2Call"

     Function ${_MOZFUNC_UN}WriteRegDWORD2

       Exch $R9

       Exch 1

       Exch $R8

       Exch 2

       Exch $R7

       Exch 3

       Exch $R6

       Exch 4

       Exch $R5

       ClearErrors

       WriteRegDWORD SHCTX "$R6" "$R7" "$R8"

       !ifndef NO_LOG

         ${If} ${Errors}

           ${LogMsg} "** ERROR Adding Registry DWord: $R5 | $R6 | $R7 | $R8 **"

         ${Else}

           ${If} $R9 == 1 ; add to the uninstall log?

             ${LogUninstall} "RegVal: $R5 | $R6 | $R7"

           ${EndIf}

           ${LogMsg} "Added Registry DWord: $R5 | $R6 | $R7 | $R8"

         ${EndIf}

       !endif

       Exch $R5

       Exch 4

       Exch $R6

       Exch 3

       Exch $R7

       Exch 2

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro WriteRegDWORD2Call _ROOT _KEY _NAME _DWORD _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_NAME}"

   Push "${_DWORD}"

   Push "${_LOG_UNINSTALL}"

   Call WriteRegDWORD2

   !verbose pop

 !macroend

 !macro un.WriteRegDWORD2Call _ROOT _KEY _NAME _DWORD _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_NAME}"

   Push "${_DWORD}"

   Push "${_LOG_UNINSTALL}"

   Call un.WriteRegDWORD2

   !verbose pop

 !macroend

 !macro un.WriteRegDWORD2

   !ifndef un.WriteRegDWORD2

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro WriteRegDWORD2

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Writes a registry string to HKCR using the supplied params and logs the

  * action to the install log and the uninstall log if _LOG_UNINSTALL equals 1.

  *

  * Define NO_LOG to prevent all logging when calling this from the uninstaller.

  *

  * @param   _ROOT

  *          The registry key root as defined by NSIS (e.g. HKLM, HKCU, etc.).

  *          This will only be used for logging.

  * @param   _KEY

  *          The subkey in relation to the key root.

  * @param   _NAME

  *          The key value name to write to.

  * @param   _STR

  *          The string to write to the key value name.

  * @param   _LOG_UNINSTALL

  *          0 = don't add to uninstall log, 1 = add to uninstall log.

  *

  * $R5 = _ROOT

  * $R6 = _KEY

  * $R7 = _NAME

  * $R8 = _STR

  * $R9 = _LOG_UNINSTALL

  */

 !macro WriteRegStrHKCR

   !ifndef ${_MOZFUNC_UN}WriteRegStrHKCR

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}WriteRegStrHKCR "!insertmacro ${_MOZFUNC_UN}WriteRegStrHKCRCall"

     Function ${_MOZFUNC_UN}WriteRegStrHKCR

       Exch $R9

       Exch 1

       Exch $R8

       Exch 2

       Exch $R7

       Exch 3

       Exch $R6

       Exch 4

       Exch $R5

       ClearErrors

       WriteRegStr HKCR "$R6" "$R7" "$R8"

       !ifndef NO_LOG

         ${If} ${Errors}

           ${LogMsg} "** ERROR Adding Registry String: $R5 | $R6 | $R7 | $R8 **"

         ${Else}

           ${If} $R9 == 1 ; add to the uninstall log?

             ${LogUninstall} "RegVal: $R5 | $R6 | $R7"

           ${EndIf}

           ${LogMsg} "Added Registry String: $R5 | $R6 | $R7 | $R8"

         ${EndIf}

       !endif

       Exch $R5

       Exch 4

       Exch $R6

       Exch 3

       Exch $R7

       Exch 2

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro WriteRegStrHKCRCall _ROOT _KEY _NAME _STR _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_NAME}"

   Push "${_STR}"

   Push "${_LOG_UNINSTALL}"

   Call WriteRegStrHKCR

   !verbose pop

 !macroend

 !macro un.WriteRegStrHKCRCall _ROOT _KEY _NAME _STR _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_NAME}"

   Push "${_STR}"

   Push "${_LOG_UNINSTALL}"

   Call un.WriteRegStrHKCR

   !verbose pop

 !macroend

 !macro un.WriteRegStrHKCR

   !ifndef un.WriteRegStrHKCR

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro WriteRegStrHKCR

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 !ifndef KEY_SET_VALUE

   !define KEY_SET_VALUE 0x0002

 !endif

 !ifndef KEY_WOW64_64KEY

   !define KEY_WOW64_64KEY 0x0100

 !endif

 !ifndef HAVE_64BIT_OS

   !define CREATE_KEY_SAM ${KEY_SET_VALUE}

 !else

   !define CREATE_KEY_SAM ${KEY_SET_VALUE}|${KEY_WOW64_64KEY}

 !endif

 /**

  * Creates a registry key. This will log the actions to the install and

  * uninstall logs. Alternatively you can set a registry value to create the key

  * and then delete the value.

  *

  * Define NO_LOG to prevent all logging when calling this from the uninstaller.

  *

  * @param   _ROOT

  *          The registry key root as defined by NSIS (e.g. HKLM, HKCU, etc.).

  * @param   _KEY

  *          The subkey in relation to the key root.

  * @param   _LOG_UNINSTALL

  *          0 = don't add to uninstall log, 1 = add to uninstall log.

  *

  * $R4 = [out] handle to newly created registry key. If this is not a key

  *       located in one of the predefined registry keys this must be closed

  *       with RegCloseKey (this should not be needed unless someone decides to

  *       do something extremely squirrelly with NSIS).

  * $R5 = return value from RegCreateKeyExW (represented by R5 in the system call).

  * $R6 = [in] hKey passed to RegCreateKeyExW.

  * $R7 = _ROOT

  * $R8 = _KEY

  * $R9 = _LOG_UNINSTALL

  */

 !macro CreateRegKey

   !ifndef ${_MOZFUNC_UN}CreateRegKey

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}CreateRegKey "!insertmacro ${_MOZFUNC_UN}CreateRegKeyCall"

     Function ${_MOZFUNC_UN}CreateRegKey

       Exch $R9

       Exch 1

       Exch $R8

       Exch 2

       Exch $R7

       Push $R6

       Push $R5

       Push $R4

       StrCmp $R7 "HKCR" +1 +2

       StrCpy $R6 "0x80000000"

       StrCmp $R7 "HKCU" +1 +2

       StrCpy $R6 "0x80000001"

       StrCmp $R7 "HKLM" +1 +2

       StrCpy $R6 "0x80000002"

       ; see definition of RegCreateKey

       System::Call "Advapi32::RegCreateKeyExW(i R6, w R8, i 0, i 0, i 0,\

                                               i ${CREATE_KEY_SAM}, i 0, *i .R4,\

                                               i 0) i .R5"

       !ifndef NO_LOG

         ; if $R5 is not 0 then there was an error creating the registry key.

         ${If} $R5 <> 0

           ${LogMsg} "** ERROR Adding Registry Key: $R7 | $R8 **"

         ${Else}

           ${If} $R9 == 1 ; add to the uninstall log?

             ${LogUninstall} "RegKey: $R7 | $R8"

           ${EndIf}

           ${LogMsg} "Added Registry Key: $R7 | $R8"

         ${EndIf}

       !endif

       StrCmp $R5 0 +1 +2

       System::Call "Advapi32::RegCloseKey(iR4)"

       Pop $R4

       Pop $R5

       Pop $R6

       Exch $R7

       Exch 2

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro CreateRegKeyCall _ROOT _KEY _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_LOG_UNINSTALL}"

   Call CreateRegKey

   !verbose pop

 !macroend

 !macro un.CreateRegKeyCall _ROOT _KEY _LOG_UNINSTALL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_ROOT}"

   Push "${_KEY}"

   Push "${_LOG_UNINSTALL}"

   Call un.CreateRegKey

   !verbose pop

 !macroend

 !macro un.CreateRegKey

   !ifndef un.CreateRegKey

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro CreateRegKey

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Helper for checking for the existence of a registry key.

  * SHCTX is the root key to search.

  *

  * @param   _MAIN_KEY

  *          Sub key to iterate for the key in question

  * @param   _KEY

  *          Key name to search for

  * @return  _RESULT

  *          'true' / 'false' result

  */

 !macro CheckIfRegistryKeyExists

   !ifndef CheckIfRegistryKeyExists

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define CheckIfRegistryKeyExists "!insertmacro CheckIfRegistryKeyExistsCall"

     Function CheckIfRegistryKeyExists

       ; stack: main key, key

       Exch $R9 ; main key, stack: old R9, key

       Exch 1   ; stack: key, old R9

       Exch $R8 ; key, stack: old R8, old R9

       Push $R7

       Push $R6

       Push $R5

       StrCpy $R5 "false"

       StrCpy $R7 "0" # loop index

       ${Do}

         EnumRegKey $R6 SHCTX "$R9" "$R7"

         ${If} "$R6" == "$R8"

           StrCpy $R5 "true"

           ${Break}

         ${EndIf}

         IntOp $R7 $R7 + 1

       ${LoopWhile} $R6 != ""

       ClearErrors

       StrCpy $R9 $R5

       Pop $R5

       Pop $R6

       Pop $R7 ; stack: old R8, old R9

       Pop $R8 ; stack: old R9

       Exch $R9 ; stack: result

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro CheckIfRegistryKeyExistsCall _MAIN_KEY _KEY _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Push "${_MAIN_KEY}"

   Call CheckIfRegistryKeyExists

   Pop ${_RESULT}

   !verbose pop

 !macroend

 ################################################################################

 # Macros for adding file and protocol handlers

 /**

  * Writes common registry values for a handler using SHCTX.

  *

  * @param   _KEY

  *          The subkey in relation to the key root.

  * @param   _VALOPEN

  *          The path and args to launch the application.

  * @param   _VALICON

  *          The path to the binary that contains the icon group for the default icon

  *          followed by a comma and either the icon group's resource index or the icon

  *          group's resource id prefixed with a minus sign

  * @param   _DISPNAME

  *          The display name for the handler. If emtpy no value will be set.

  * @param   _ISPROTOCOL

  *          Sets protocol handler specific registry values when "true".

  *          Deletes protocol handler specific registry values when "delete".

  *          Otherwise doesn't touch handler specific registry values.

  * @param   _ISDDE

  *          Sets DDE specific registry values when "true".

  *

  * $R3 = string value of the current registry key path.

  * $R4 = _KEY

  * $R5 = _VALOPEN

  * $R6 = _VALICON

  * $R7 = _DISPNAME

  * $R8 = _ISPROTOCOL

  * $R9 = _ISDDE

  */

 !macro AddHandlerValues

   !ifndef ${_MOZFUNC_UN}AddHandlerValues

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}AddHandlerValues "!insertmacro ${_MOZFUNC_UN}AddHandlerValuesCall"

     Function ${_MOZFUNC_UN}AddHandlerValues

       Exch $R9

       Exch 1

       Exch $R8

       Exch 2

       Exch $R7

       Exch 3

       Exch $R6

       Exch 4

       Exch $R5

       Exch 5

       Exch $R4

       Push $R3

       StrCmp "$R7" "" +6 +1

       ReadRegStr $R3 SHCTX "$R4" "FriendlyTypeName"

       StrCmp "$R3" "" +1 +3

       WriteRegStr SHCTX "$R4" "" "$R7"

       WriteRegStr SHCTX "$R4" "FriendlyTypeName" "$R7"

       StrCmp "$R8" "true" +1 +2

       WriteRegStr SHCTX "$R4" "URL Protocol" ""

       StrCmp "$R8" "delete" +1 +2

       DeleteRegValue SHCTX "$R4" "URL Protocol"

       StrCpy $R3 ""

       ReadRegDWord $R3 SHCTX "$R4" "EditFlags"

       StrCmp $R3 "" +1 +3  ; Only add EditFlags if a value doesn't exist

       DeleteRegValue SHCTX "$R4" "EditFlags"

       WriteRegDWord SHCTX "$R4" "EditFlags" 0x00000002

       StrCmp "$R6" "" +2 +1

       WriteRegStr SHCTX "$R4\DefaultIcon" "" "$R6"

       StrCmp "$R5" "" +2 +1

       WriteRegStr SHCTX "$R4\shell\open\command" "" "$R5"

 !ifdef DDEApplication

       StrCmp "$R9" "true" +1 +11

       WriteRegStr SHCTX "$R4\shell\open\ddeexec" "" "$\"%1$\",,0,0,,,,"

       WriteRegStr SHCTX "$R4\shell\open\ddeexec" "NoActivateHandler" ""

       WriteRegStr SHCTX "$R4\shell\open\ddeexec\Application" "" "${DDEApplication}"

       WriteRegStr SHCTX "$R4\shell\open\ddeexec\Topic" "" "WWW_OpenURL"

       ; The ifexec key may have been added by another application so try to

       ; delete it to prevent it from breaking this app's shell integration.

       ; Also, IE 6 and below doesn't remove this key when it sets itself as the

       ; default handler and if this key exists IE's shell integration breaks.

       DeleteRegKey HKLM "$R4\shell\open\ddeexec\ifexec"

       DeleteRegKey HKCU "$R4\shell\open\ddeexec\ifexec"

 !endif

       ClearErrors

       Pop $R3

       Exch $R4

       Exch 5

       Exch $R5

       Exch 4

       Exch $R6

       Exch 3

       Exch $R7

       Exch 2

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro AddHandlerValuesCall _KEY _VALOPEN _VALICON _DISPNAME _ISPROTOCOL _ISDDE

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Push "${_VALOPEN}"

   Push "${_VALICON}"

   Push "${_DISPNAME}"

   Push "${_ISPROTOCOL}"

   Push "${_ISDDE}"

   Call AddHandlerValues

   !verbose pop

 !macroend

 !macro un.AddHandlerValuesCall _KEY _VALOPEN _VALICON _DISPNAME _ISPROTOCOL _ISDDE

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Push "${_VALOPEN}"

   Push "${_VALICON}"

   Push "${_DISPNAME}"

   Push "${_ISPROTOCOL}"

   Push "${_ISDDE}"

   Call un.AddHandlerValues

   !verbose pop

 !macroend

 !macro un.AddHandlerValues

   !ifndef un.AddHandlerValues

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro AddHandlerValues

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Writes common registry values for a handler that uses DDE using SHCTX.

  *

  * @param   _KEY

  *          The key name in relation to the HKCR root. SOFTWARE\Classes is

  *          prefixed to this value when using SHCTX.

  * @param   _VALOPEN

  *          The path and args to launch the application.

  * @param   _VALICON

  *          The path to the binary that contains the icon group for the default icon

  *          followed by a comma and either the icon group's resource index or the icon

  *          group's resource id prefixed with a minus sign

  * @param   _DISPNAME

  *          The display name for the handler. If emtpy no value will be set.

  * @param   _ISPROTOCOL

  *          Sets protocol handler specific registry values when "true".

  *          Deletes protocol handler specific registry values when "delete".

  *          Otherwise doesn't touch handler specific registry values.

  * @param   _DDE_APPNAME

  *          Sets DDE specific registry values when not an empty string.

  *

  * $R0 = storage for SOFTWARE\Classes

  * $R1 = string value of the current registry key path.

  * $R2 = _KEY

  * $R3 = _VALOPEN

  * $R4 = _VALICON

  * $R5 = _DISPNAME

  * $R6 = _ISPROTOCOL

  * $R7 = _DDE_APPNAME

  * $R8 = _DDE_DEFAULT

  * $R9 = _DDE_TOPIC

  */

 !macro AddDDEHandlerValues

   !ifndef ${_MOZFUNC_UN}AddDDEHandlerValues

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}AddDDEHandlerValues "!insertmacro ${_MOZFUNC_UN}AddDDEHandlerValuesCall"

     Function ${_MOZFUNC_UN}AddDDEHandlerValues

       Exch $R9

       Exch 1

       Exch $R8

       Exch 2

       Exch $R7

       Exch 3

       Exch $R6

       Exch 4

       Exch $R5

       Exch 5

       Exch $R4

       Exch 6

       Exch $R3

       Exch 7

       Exch $R2

       Push $R1

       Push $R0

       StrCpy $R0 "SOFTWARE\Classes"

       StrCmp "$R5" "" +6 +1

       ReadRegStr $R1 SHCTX "$R2" "FriendlyTypeName"

       StrCmp "$R1" "" +1 +3

       WriteRegStr SHCTX "$R0\$R2" "" "$R5"

       WriteRegStr SHCTX "$R0\$R2" "FriendlyTypeName" "$R5"

       StrCmp "$R6" "true" +1 +2

       WriteRegStr SHCTX "$R0\$R2" "URL Protocol" ""

       StrCmp "$R6" "delete" +1 +2

       DeleteRegValue SHCTX "$R0\$R2" "URL Protocol"

       StrCpy $R1 ""

       ReadRegDWord $R1 SHCTX "$R0\$R2" "EditFlags"

       StrCmp $R1 "" +1 +3  ; Only add EditFlags if a value doesn't exist

       DeleteRegValue SHCTX "$R0\$R2" "EditFlags"

       WriteRegDWord SHCTX "$R0\$R2" "EditFlags" 0x00000002

       StrCmp "$R4" "" +2 +1

       WriteRegStr SHCTX "$R0\$R2\DefaultIcon" "" "$R4"

       WriteRegStr SHCTX "$R0\$R2\shell" "" "open"

       WriteRegStr SHCTX "$R0\$R2\shell\open\command" "" "$R3"

       WriteRegStr SHCTX "$R0\$R2\shell\open\ddeexec" "" "$R8"

       WriteRegStr SHCTX "$R0\$R2\shell\open\ddeexec" "NoActivateHandler" ""

       WriteRegStr SHCTX "$R0\$R2\shell\open\ddeexec\Application" "" "$R7"

       WriteRegStr SHCTX "$R0\$R2\shell\open\ddeexec\Topic" "" "$R9"

       ; The ifexec key may have been added by another application so try to

       ; delete it to prevent it from breaking this app's shell integration.

       ; Also, IE 6 and below doesn't remove this key when it sets itself as the

       ; default handler and if this key exists IE's shell integration breaks.

       DeleteRegKey HKLM "$R0\$R2\shell\open\ddeexec\ifexec"

       DeleteRegKey HKCU "$R0\$R2\shell\open\ddeexec\ifexec"

       ClearErrors

       Pop $R0

       Pop $R1

       Exch $R2

       Exch 7

       Exch $R3

       Exch 6

       Exch $R4

       Exch 5

       Exch $R5

       Exch 4

       Exch $R6

       Exch 3

       Exch $R7

       Exch 2

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro AddDDEHandlerValuesCall _KEY _VALOPEN _VALICON _DISPNAME _ISPROTOCOL _DDE_APPNAME _DDE_DEFAULT _DDE_TOPIC

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Push "${_VALOPEN}"

   Push "${_VALICON}"

   Push "${_DISPNAME}"

   Push "${_ISPROTOCOL}"

   Push "${_DDE_APPNAME}"

   Push "${_DDE_DEFAULT}"

   Push "${_DDE_TOPIC}"

   Call AddDDEHandlerValues

   !verbose pop

 !macroend

 !macro un.AddDDEHandlerValuesCall _KEY _VALOPEN _VALICON _DISPNAME _ISPROTOCOL _DDE_APPNAME _DDE_DEFAULT _DDE_TOPIC

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Push "${_VALOPEN}"

   Push "${_VALICON}"

   Push "${_DISPNAME}"

   Push "${_ISPROTOCOL}"

   Push "${_DDE_APPNAME}"

   Push "${_DDE_DEFAULT}"

   Push "${_DDE_TOPIC}"

   Call un.AddDDEHandlerValues

   !verbose pop

 !macroend

 !macro un.AddDDEHandlerValues

   !ifndef un.AddDDEHandlerValues

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro AddDDEHandlerValues

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Writes common registry values for a handler that DOES NOT use DDE using SHCTX.

  *

  * @param   _KEY

  *          The key name in relation to the HKCR root. SOFTWARE\Classes is

  *          prefixed to this value when using SHCTX.

  * @param   _VALOPEN

  *          The path and args to launch the application.

  * @param   _VALICON

  *          The path to the binary that contains the icon group for the default icon

  *          followed by a comma and either the icon group's resource index or the icon

  *          group's resource id prefixed with a minus sign

  * @param   _DISPNAME

  *          The display name for the handler. If emtpy no value will be set.

  * @param   _ISPROTOCOL

  *          Sets protocol handler specific registry values when "true".

  *          Deletes protocol handler specific registry values when "delete".

  *          Otherwise doesn't touch handler specific registry values.

  *

  * $R3 = storage for SOFTWARE\Classes

  * $R4 = string value of the current registry key path.

  * $R5 = _KEY

  * $R6 = _VALOPEN

  * $R7 = _VALICON

  * $R8 = _DISPNAME

  * $R9 = _ISPROTOCOL

  */

 !macro AddDisabledDDEHandlerValues

   !ifndef ${_MOZFUNC_UN}AddDisabledDDEHandlerValues

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}AddDisabledDDEHandlerValues "!insertmacro ${_MOZFUNC_UN}AddDisabledDDEHandlerValuesCall"

     Function ${_MOZFUNC_UN}AddDisabledDDEHandlerValues

       Exch $R9 ; _ISPROTOCOL

       Exch 1

       Exch $R8 ; FriendlyTypeName

       Exch 2

       Exch $R7 ; icon index

       Exch 3

       Exch $R6 ; shell\open\command

       Exch 4

       Exch $R5 ; reg key

       Push $R4 ;

       Push $R3 ; base reg class

       StrCpy $R3 "SOFTWARE\Classes"

       StrCmp "$R8" "" +6 +1

       ReadRegStr $R4 SHCTX "$R5" "FriendlyTypeName"

       StrCmp "$R4" "" +1 +3

       WriteRegStr SHCTX "$R3\$R5" "" "$R8"

       WriteRegStr SHCTX "$R3\$R5" "FriendlyTypeName" "$R8"

       StrCmp "$R9" "true" +1 +2

       WriteRegStr SHCTX "$R3\$R5" "URL Protocol" ""

       StrCmp "$R9" "delete" +1 +2

       DeleteRegValue SHCTX "$R3\$R5" "URL Protocol"

       StrCpy $R4 ""

       ReadRegDWord $R4 SHCTX "$R3\$R5" "EditFlags"

       StrCmp $R4 "" +1 +3  ; Only add EditFlags if a value doesn't exist

       DeleteRegValue SHCTX "$R3\$R5" "EditFlags"

       WriteRegDWord SHCTX "$R3\$R5" "EditFlags" 0x00000002

       StrCmp "$R7" "" +2 +1

       WriteRegStr SHCTX "$R3\$R5\DefaultIcon" "" "$R7"

       ; Main command handler for the app

       WriteRegStr SHCTX "$R3\$R5\shell" "" "open"

       WriteRegStr SHCTX "$R3\$R5\shell\open\command" "" "$R6"

       ; Drop support for DDE (bug 491947), and remove old dde entries if

       ; they exist.

       ;

       ; Note, changes in SHCTX should propegate to hkey classes root when

       ; current user or local machine entries are written. Windows will also

       ; attempt to propegate entries when a handler is used. CR entries are a

       ; combination of LM and CU, with CU taking priority.

       ;

       ; To disable dde, an empty shell/ddeexec key must be created in current

       ; user or local machine. Unfortunately, settings have various different

       ; behaviors depending on the windows version. The following code attempts

       ; to address these differences.

       ;

       ; On XP (no SP, SP1, SP2), Vista: An empty default string

       ; must be set under ddeexec. Empty strings propagate to CR.

       ;

       ; Win7: IE does not configure ddeexec, so issues with left over ddeexec keys

       ; in LM are reduced. We configure an empty ddeexec key with an empty default

       ; string in CU to be sure.

       ;

       DeleteRegKey SHCTX "SOFTWARE\Classes\$R5\shell\open\ddeexec"

       WriteRegStr SHCTX "SOFTWARE\Classes\$R5\shell\open\ddeexec" "" ""

       ClearErrors

       Pop $R3

       Pop $R4

       Exch $R5

       Exch 4

       Exch $R6

       Exch 3

       Exch $R7

       Exch 2

       Exch $R8

       Exch 1

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro AddDisabledDDEHandlerValuesCall _KEY _VALOPEN _VALICON _DISPNAME _ISPROTOCOL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Push "${_VALOPEN}"

   Push "${_VALICON}"

   Push "${_DISPNAME}"

   Push "${_ISPROTOCOL}"

   Call AddDisabledDDEHandlerValues

   !verbose pop

 !macroend

 !macro un.AddDisabledDDEHandlerValuesCall _KEY _VALOPEN _VALICON _DISPNAME _ISPROTOCOL

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Push "${_VALOPEN}"

   Push "${_VALICON}"

   Push "${_DISPNAME}"

   Push "${_ISPROTOCOL}"

   Call un.AddDisabledDDEHandlerValues

   !verbose pop

 !macroend

 !macro un.AddDisabledDDEHandlerValues

   !ifndef un.AddDisabledDDEHandlerValues

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro AddDisabledDDEHandlerValues

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 ################################################################################

 # Macros for handling DLL registration

 !macro RegisterDLL DLL

   ; The x64 regsvr32.exe registers x86 DLL's properly on Windows Vista and above

   ; (not on Windows XP http://support.microsoft.com/kb/282747) so just use it

   ; when installing on an x64 systems even when installing an x86 application.

   ${If} ${RunningX64}

     ${DisableX64FSRedirection}

     ExecWait '"$SYSDIR\regsvr32.exe" /s "${DLL}"'

     ${EnableX64FSRedirection}

   ${Else}

     RegDLL "${DLL}"

   ${EndIf}

 !macroend

 !macro UnregisterDLL DLL

   ; The x64 regsvr32.exe registers x86 DLL's properly on Windows Vista and above

   ; (not on Windows XP http://support.microsoft.com/kb/282747) so just use it

   ; when installing on an x64 systems even when installing an x86 application.

   ${If} ${RunningX64}

     ${DisableX64FSRedirection}

     ExecWait '"$SYSDIR\regsvr32.exe" /s /u "${DLL}"'

     ${EnableX64FSRedirection}

   ${Else}

     UnRegDLL "${DLL}"

   ${EndIf}

 !macroend

 !define RegisterDLL `!insertmacro RegisterDLL`

 !define UnregisterDLL `!insertmacro UnregisterDLL`

 ################################################################################

 # Macros for retrieving existing install paths

 /**

  * Finds a second installation of the application so we can make informed

  * decisions about registry operations. This uses SHCTX to determine the

  * registry hive so you must call SetShellVarContext first.

  *

  * @param   _KEY

  *          The registry subkey (typically this will be Software\Mozilla).

  * @return  _RESULT

  *          false if a second install isn't found, path to the main exe if a

  *          second install is found.

  *

  * $R3 = stores the long path to $INSTDIR

  * $R4 = counter for the outer loop's EnumRegKey

  * $R5 = return value from ReadRegStr and RemoveQuotesFromPath

  * $R6 = return value from GetParent

  * $R7 = return value from the loop's EnumRegKey

  * $R8 = storage for _KEY

  * $R9 = _KEY and _RESULT

  */

 !macro GetSecondInstallPath

   !ifndef ${_MOZFUNC_UN}GetSecondInstallPath

     !define _MOZFUNC_UN_TMP ${_MOZFUNC_UN}

     !insertmacro ${_MOZFUNC_UN_TMP}GetLongPath

     !insertmacro ${_MOZFUNC_UN_TMP}GetParent

     !insertmacro ${_MOZFUNC_UN_TMP}RemoveQuotesFromPath

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN ${_MOZFUNC_UN_TMP}

     !undef _MOZFUNC_UN_TMP

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}GetSecondInstallPath "!insertmacro ${_MOZFUNC_UN}GetSecondInstallPathCall"

     Function ${_MOZFUNC_UN}GetSecondInstallPath

       Exch $R9

       Push $R8

       Push $R7

       Push $R6

       Push $R5

       Push $R4

       Push $R3

       ${${_MOZFUNC_UN}GetLongPath} "$INSTDIR" $R3

       StrCpy $R4 0       ; set the counter for the loop to 0

       StrCpy $R8 "$R9"   ; Registry key path to search

       StrCpy $R9 "false" ; default return value

       loop:

       EnumRegKey $R7 SHCTX $R8 $R4

       StrCmp $R7 "" end +1  ; if empty there are no more keys to enumerate

       IntOp $R4 $R4 + 1     ; increment the loop's counter

       ClearErrors

       ReadRegStr $R5 SHCTX "$R8\$R7\bin" "PathToExe"

       IfErrors loop

       ${${_MOZFUNC_UN}RemoveQuotesFromPath} "$R5" $R5

       IfFileExists "$R5" +1 loop

       ${${_MOZFUNC_UN}GetLongPath} "$R5" $R5

       ${${_MOZFUNC_UN}GetParent} "$R5" $R6

       StrCmp "$R6" "$R3" loop +1

       StrCmp "$R6\${FileMainEXE}" "$R5" +1 loop

       StrCpy $R9 "$R5"

       end:

       ClearErrors

       Pop $R3

       Pop $R4

       Pop $R5

       Pop $R6

       Pop $R7

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro GetSecondInstallPathCall _KEY _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Call GetSecondInstallPath

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.GetSecondInstallPathCall _KEY _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Call un.GetSecondInstallPath

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.GetSecondInstallPath

   !ifndef un.GetSecondInstallPath

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro GetSecondInstallPath

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Finds an existing installation path for the application based on the

  * application's executable name so we can default to using this path for the

  * install. If there is zero or more than one installation of the application

  * then we default to the default installation path. This uses SHCTX to

  * determine the registry hive to read from so you must call SetShellVarContext

  * first.

  *

  * @param   _KEY

  *          The registry subkey (typically this will be Software\Mozilla\App Name).

  * @return  _RESULT

  *          false if a single install location for this app name isn't found,

  *          path to the install directory if a single install location is found.

  *

  * $R5 = counter for the loop's EnumRegKey

  * $R6 = return value from EnumRegKey

  * $R7 = return value from ReadRegStr

  * $R8 = storage for _KEY

  * $R9 = _KEY and _RESULT

  */

 !macro GetSingleInstallPath

   !ifndef ${_MOZFUNC_UN}GetSingleInstallPath

     !define _MOZFUNC_UN_TMP ${_MOZFUNC_UN}

     !insertmacro ${_MOZFUNC_UN_TMP}GetLongPath

     !insertmacro ${_MOZFUNC_UN_TMP}GetParent

     !insertmacro ${_MOZFUNC_UN_TMP}RemoveQuotesFromPath

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN ${_MOZFUNC_UN_TMP}

     !undef _MOZFUNC_UN_TMP

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}GetSingleInstallPath "!insertmacro ${_MOZFUNC_UN}GetSingleInstallPathCall"

     Function ${_MOZFUNC_UN}GetSingleInstallPath

       Exch $R9

       Push $R8

       Push $R7

       Push $R6

       Push $R5

       StrCpy $R8 $R9

       StrCpy $R9 "false"

       StrCpy $R5 0  ; set the counter for the loop to 0

       loop:

       ClearErrors

       EnumRegKey $R6 SHCTX $R8 $R5

       IfErrors cleanup

       StrCmp $R6 "" cleanup +1  ; if empty there are no more keys to enumerate

       IntOp $R5 $R5 + 1         ; increment the loop's counter

       ClearErrors

       ReadRegStr $R7 SHCTX "$R8\$R6\Main" "PathToExe"

       IfErrors loop

       ${${_MOZFUNC_UN}RemoveQuotesFromPath} "$R7" $R7

       GetFullPathName $R7 "$R7"

       IfErrors loop

       StrCmp "$R9" "false" +1 +3

       StrCpy $R9 "$R7"

       GoTo Loop

       StrCpy $R9 "false"

       cleanup:

       StrCmp $R9 "false" end +1

       ${${_MOZFUNC_UN}GetLongPath} "$R9" $R9

       ${${_MOZFUNC_UN}GetParent} "$R9" $R9

       end:

       ClearErrors

       Pop $R5

       Pop $R6

       Pop $R7

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro GetSingleInstallPathCall _KEY _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Call GetSingleInstallPath

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.GetSingleInstallPathCall _KEY _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Call un.GetSingleInstallPath

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.GetSingleInstallPath

   !ifndef un.GetSingleInstallPath

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro GetSingleInstallPath

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 ################################################################################

 # Macros for working with the file system

 /**

  * Attempts to delete a file if it exists. This will fail if the file is in use.

  *

  * @param   _FILE

  *          The path to the file that is to be deleted.

  */

 !macro DeleteFile _FILE

   ${If} ${FileExists} "${_FILE}"

     Delete "${_FILE}"

   ${EndIf}

 !macroend

 !define DeleteFile "!insertmacro DeleteFile"

 /**

  * Removes a directory if it exists and is empty.

  *

  * @param   _DIR

  *          The path to the directory that is to be removed.

  */

 !macro RemoveDir _DIR

   ${If} ${FileExists} "${_DIR}"

     RmDir "${_DIR}"

   ${EndIf}

 !macroend

 !define RemoveDir "!insertmacro RemoveDir"

 /**

  * Checks whether it is possible to create and delete a directory and a file in

  * the install directory. Creation and deletion of files and directories are

  * checked since a user may have rights for one and not the other. If creation

  * and deletion of a file and a directory are successful this macro will return

  * true... if not, this it return false.

  *

  * @return  _RESULT

  *          true if files and directories can be created and deleted in the

  *          install directory otherwise false.

  *

  * $R8 = temporary filename in the installation directory returned from

  *       GetTempFileName.

  * $R9 = _RESULT

  */

 !macro CanWriteToInstallDir

   !ifndef ${_MOZFUNC_UN}CanWriteToInstallDir

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}CanWriteToInstallDir "!insertmacro ${_MOZFUNC_UN}CanWriteToInstallDirCall"

     Function ${_MOZFUNC_UN}CanWriteToInstallDir

       Push $R9

       Push $R8

       StrCpy $R9 "true"

       ; IfFileExists returns false for $INSTDIR when $INSTDIR is the root of a

       ; UNC path so always try to create $INSTDIR

       CreateDirectory "$INSTDIR\"

       GetTempFileName $R8 "$INSTDIR\"

       ${Unless} ${FileExists} $R8 ; Can files be created?

         StrCpy $R9 "false"

         Goto done

       ${EndUnless}

       Delete $R8

       ${If} ${FileExists} $R8 ; Can files be deleted?

         StrCpy $R9 "false"

         Goto done

       ${EndIf}

       CreateDirectory $R8

       ${Unless} ${FileExists} $R8  ; Can directories be created?

         StrCpy $R9 "false"

         Goto done

       ${EndUnless}

       RmDir $R8

       ${If} ${FileExists} $R8  ; Can directories be deleted?

         StrCpy $R9 "false"

         Goto done

       ${EndIf}

       done:

       RmDir "$INSTDIR\" ; Only remove $INSTDIR if it is empty

       ClearErrors

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro CanWriteToInstallDirCall _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Call CanWriteToInstallDir

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.CanWriteToInstallDirCall _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Call un.CanWriteToInstallDir

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.CanWriteToInstallDir

   !ifndef un.CanWriteToInstallDir

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro CanWriteToInstallDir

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Checks whether there is sufficient free space available for the installation

  * directory using GetDiskFreeSpaceExW which respects disk quotas. This macro

  * will calculate the size of all sections that are selected, compare that with

  * the free space available, and if there is sufficient free space it will

  * return true... if not, it will return false.

  *

  * @return  _RESULT

  *          "true" if there is sufficient free space otherwise "false".

  *

  * $R5 = return value from SectionGetSize

  * $R6 = return value from SectionGetFlags

  *       return value from an 'and' comparison of SectionGetFlags (1=selected)

  *       return value for lpFreeBytesAvailable from GetDiskFreeSpaceExW

  *       return value for System::Int64Op $R6 / 1024

  *       return value for System::Int64Op $R6 > $R8

  * $R7 = the counter for enumerating the sections

  *       the temporary file name for the directory created under $INSTDIR passed

  *       to GetDiskFreeSpaceExW.

  * $R8 = sum in KB of all selected sections

  * $R9 = _RESULT

  */

 !macro CheckDiskSpace

   !ifndef ${_MOZFUNC_UN}CheckDiskSpace

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}CheckDiskSpace "!insertmacro ${_MOZFUNC_UN}CheckDiskSpaceCall"

     Function ${_MOZFUNC_UN}CheckDiskSpace

       Push $R9

       Push $R8

       Push $R7

       Push $R6

       Push $R5

       ClearErrors

       StrCpy $R9 "true" ; default return value

       StrCpy $R8 "0"    ; sum in KB of all selected sections

       StrCpy $R7 "0"    ; counter for enumerating sections

       ; Enumerate the sections and sum up the sizes of the sections that are

       ; selected.

       SectionGetFlags $R7 $R6

       IfErrors +7 +1

       IntOp $R6 ${SF_SELECTED} & $R6

       IntCmp $R6 0 +3 +1 +1

       SectionGetSize $R7 $R5

       IntOp $R8 $R8 + $R5

       IntOp $R7 $R7 + 1

       GoTo -7

       ; The directory passed to GetDiskFreeSpaceExW must exist for the call to

       ; succeed.  Since the CanWriteToInstallDir macro is called prior to this

       ; macro the call to CreateDirectory will always succeed.

       ; IfFileExists returns false for $INSTDIR when $INSTDIR is the root of a

       ; UNC path so always try to create $INSTDIR

       CreateDirectory "$INSTDIR\"

       GetTempFileName $R7 "$INSTDIR\"

       Delete "$R7"

       CreateDirectory "$R7"

       System::Call 'kernel32::GetDiskFreeSpaceExW(w, *l, *l, *l) i(R7, .R6, ., .) .'

       ; Convert to KB for comparison with $R8 which is in KB

       System::Int64Op $R6 / 1024

       Pop $R6

       System::Int64Op $R6 > $R8

       Pop $R6

       IntCmp $R6 1 end +1 +1

       StrCpy $R9 "false"

       end:

       RmDir "$R7"

       RmDir "$INSTDIR\" ; Only remove $INSTDIR if it is empty

       ClearErrors

       Pop $R5

       Pop $R6

       Pop $R7

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro CheckDiskSpaceCall _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Call CheckDiskSpace

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.CheckDiskSpaceCall _RESULT

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Call un.CheckDiskSpace

   Pop ${_RESULT}

   !verbose pop

 !macroend

 !macro un.CheckDiskSpace

   !ifndef un.CheckDiskSpace

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro CheckDiskSpace

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

 * Returns the path found within a passed in string. The path is quoted or not

 * with the exception of an unquoted non 8dot3 path without arguments that is

 * also not a DefaultIcon path, is a 8dot3 path or not, has command line

 * arguments, or is a registry DefaultIcon path (e.g. <path to binary>,# where #

 * is the icon's resuorce id). The string does not need to be a valid path or

 * exist. It is up to the caller to pass in a string of one of the forms noted

 * above and to verify existence if necessary.

 *

 * Examples:

 * In:  C:\PROGRA~1\MOZILL~1\FIREFOX.EXE -flag "%1"

 * In:  C:\PROGRA~1\MOZILL~1\FIREFOX.EXE,0

 * In:  C:\PROGRA~1\MOZILL~1\FIREFOX.EXE

 * In:  "C:\PROGRA~1\MOZILL~1\FIREFOX.EXE"

 * In:  "C:\PROGRA~1\MOZILL~1\FIREFOX.EXE" -flag "%1"

 * Out: C:\PROGRA~1\MOZILL~1\FIREFOX.EXE

 *

 * In:  "C:\Program Files\Mozilla Firefox\firefox.exe" -flag "%1"

 * In:  C:\Program Files\Mozilla Firefox\firefox.exe,0

 * In:  "C:\Program Files\Mozilla Firefox\firefox.exe"

 * Out: C:\Program Files\Mozilla Firefox\firefox.exe

 *

 * @param   _IN_PATH

 *          The string containing the path.

 * @param   _OUT_PATH

 *          The register to store the path to.

 *

 * $R7 = counter for the outer loop's EnumRegKey

 * $R8 = return value from ReadRegStr

 * $R9 = _IN_PATH and _OUT_PATH

 */

 !macro GetPathFromString

   !ifndef ${_MOZFUNC_UN}GetPathFromString

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}GetPathFromString "!insertmacro ${_MOZFUNC_UN}GetPathFromStringCall"

     Function ${_MOZFUNC_UN}GetPathFromString

       Exch $R9

       Push $R8

       Push $R7

       StrCpy $R7 0          ; Set the counter to 0.

       ; Handle quoted paths with arguments.

       StrCpy $R8 $R9 1      ; Copy the first char.

       StrCmp $R8 '"' +2 +1  ; Is it a "?

       StrCmp $R8 "'" +1 +9  ; Is it a '?

       StrCpy $R9 $R9 "" 1   ; Remove the first char.

       IntOp $R7 $R7 + 1     ; Increment the counter.

       StrCpy $R8 $R9 1 $R7  ; Starting from the counter copy the next char.

       StrCmp $R8 "" end +1  ; Are there no more chars?

       StrCmp $R8 '"' +2 +1  ; Is it a " char?

       StrCmp $R8 "'" +1 -4  ; Is it a ' char?

       StrCpy $R9 $R9 $R7    ; Copy chars up to the counter.

       GoTo end

       ; Handle DefaultIcon paths. DefaultIcon paths are not quoted and end with

       ; a , and a number.

       IntOp $R7 $R7 - 1     ; Decrement the counter.

       StrCpy $R8 $R9 1 $R7  ; Copy one char from the end minus the counter.

       StrCmp $R8 '' +4 +1   ; Are there no more chars?

       StrCmp $R8 ',' +1 -3  ; Is it a , char?

       StrCpy $R9 $R9 $R7    ; Copy chars up to the end minus the counter.

       GoTo end

       ; Handle unquoted paths with arguments. An unquoted path with arguments

       ; must be an 8dot3 path.

       StrCpy $R7 -1          ; Set the counter to -1 so it will start at 0.

       IntOp $R7 $R7 + 1      ; Increment the counter.

       StrCpy $R8 $R9 1 $R7   ; Starting from the counter copy the next char.

       StrCmp $R8 "" end +1   ; Are there no more chars?

       StrCmp $R8 " " +1 -3   ; Is it a space char?

       StrCpy $R9 $R9 $R7     ; Copy chars up to the counter.

       end:

       ClearErrors

       Pop $R7

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro GetPathFromStringCall _IN_PATH _OUT_PATH

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_IN_PATH}"

   Call GetPathFromString

   Pop ${_OUT_PATH}

   !verbose pop

 !macroend

 !macro un.GetPathFromStringCall _IN_PATH _OUT_PATH

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_IN_PATH}"

   Call un.GetPathFromString

   Pop ${_OUT_PATH}

   !verbose pop

 !macroend

 !macro un.GetPathFromString

   !ifndef un.GetPathFromString

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro GetPathFromString

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Removes the quotes from each end of a string if present.

  *

  * @param   _IN_PATH

  *          The string containing the path.

  * @param   _OUT_PATH

  *          The register to store the long path.

  *

  * $R7 = storage for single character comparison

  * $R8 = storage for _IN_PATH

  * $R9 = _IN_PATH and _OUT_PATH

  */

 !macro RemoveQuotesFromPath

   !ifndef ${_MOZFUNC_UN}RemoveQuotesFromPath

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}RemoveQuotesFromPath "!insertmacro ${_MOZFUNC_UN}RemoveQuotesFromPathCall"

     Function ${_MOZFUNC_UN}RemoveQuotesFromPath

       Exch $R9

       Push $R8

       Push $R7

       StrCpy $R7 "$R9" 1

       StrCmp $R7 "$\"" +1 +2

       StrCpy $R9 "$R9" "" 1

       StrCpy $R7 "$R9" "" -1

       StrCmp $R7 "$\"" +1 +2

       StrCpy $R9 "$R9" -1

       Pop $R7

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro RemoveQuotesFromPathCall _IN_PATH _OUT_PATH

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_IN_PATH}"

   Call RemoveQuotesFromPath

   Pop ${_OUT_PATH}

   !verbose pop

 !macroend

 !macro un.RemoveQuotesFromPathCall _IN_PATH _OUT_PATH

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_IN_PATH}"

   Call un.RemoveQuotesFromPath

   Pop ${_OUT_PATH}

   !verbose pop

 !macroend

 !macro un.RemoveQuotesFromPath

   !ifndef un.RemoveQuotesFromPath

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro RemoveQuotesFromPath

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**

  * Returns the long path for an existing file or directory. GetLongPathNameW

  * may not be available on Win95 if Microsoft Layer for Unicode is not

  * installed and GetFullPathName only returns a long path for the last file or

  * directory that doesn't end with a \ in the path that it is passed. If the

  * path does not exist on the file system this will return an empty string. To

  * provide a consistent result trailing back-slashes are always removed.

  *

  * Note: 1024 used by GetLongPathNameW is the maximum NSIS string length.

  *

  * @param   _IN_PATH

  *          The string containing the path.

  * @param   _OUT_PATH

  *          The register to store the long path.

  *

  * $R4 = counter value when the previous \ was found

  * $R5 = directory or file name found during loop

  * $R6 = return value from GetLongPathNameW and loop counter

  * $R7 = long path from GetLongPathNameW and single char from path for comparison

  * $R8 = storage for _IN_PATH

  * $R9 = _IN_PATH _OUT_PATH

  */

 !macro GetLongPath

   !ifndef ${_MOZFUNC_UN}GetLongPath

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}GetLongPath "!insertmacro ${_MOZFUNC_UN}GetLongPathCall"

     Function ${_MOZFUNC_UN}GetLongPath

       Exch $R9

       Push $R8

       Push $R7

       Push $R6

       Push $R5

       Push $R4

       ClearErrors

       GetFullPathName $R8 "$R9"

       IfErrors end_GetLongPath +1 ; If the path doesn't exist return an empty string.

       System::Call 'kernel32::GetLongPathNameW(w R8, w .R7, i 1024)i .R6'

       StrCmp "$R7" "" +4 +1 ; Empty string when GetLongPathNameW is not present.

       StrCmp $R6 0 +3 +1    ; Should never equal 0 since the path exists.

       StrCpy $R9 "$R7"

       GoTo end_GetLongPath

       ; Do it the hard way.

       StrCpy $R4 0     ; Stores the position in the string of the last \ found.

       StrCpy $R6 -1    ; Set the counter to -1 so it will start at 0.

       loop_GetLongPath:

       IntOp $R6 $R6 + 1      ; Increment the counter.

       StrCpy $R7 $R8 1 $R6   ; Starting from the counter copy the next char.

       StrCmp $R7 "" +2 +1    ; Are there no more chars?

       StrCmp $R7 "\" +1 -3   ; Is it a \?

       ; Copy chars starting from the previously found \ to the counter.

       StrCpy $R5 $R8 $R6 $R4

       ; If this is the first \ found we want to swap R9 with R5 so a \ will

       ; be appended to the drive letter and colon (e.g. C: will become C:\).

       StrCmp $R4 0 +1 +3

       StrCpy $R9 $R5

       StrCpy $R5 ""

       GetFullPathName $R9 "$R9\$R5"

       StrCmp $R7 "" end_GetLongPath +1 ; Are there no more chars?

       ; Store the counter for the current \ and prefix it for StrCpy operations.

       StrCpy $R4 "+$R6"

       IntOp $R6 $R6 + 1      ; Increment the counter so we skip over the \.

       StrCpy $R8 $R8 "" $R6  ; Copy chars starting from the counter to the end.

       StrCpy $R6 -1          ; Reset the counter to -1 so it will start over at 0.

       GoTo loop_GetLongPath

       end_GetLongPath:

       ; If there is a trailing slash remove it

       StrCmp $R9 "" +4 +1

       StrCpy $R8 "$R9" "" -1

       StrCmp $R8 "\" +1 +2

       StrCpy $R9 "$R9" -1

       ClearErrors

       Pop $R4

       Pop $R5

       Pop $R6

       Pop $R7

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro GetLongPathCall _IN_PATH _OUT_PATH

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_IN_PATH}"

   Call GetLongPath

   Pop ${_OUT_PATH}

   !verbose pop

 !macroend

 !macro un.GetLongPathCall _IN_PATH _OUT_PATH

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_IN_PATH}"

   Call un.GetLongPath

   Pop ${_OUT_PATH}

   !verbose pop

 !macroend

 !macro un.GetLongPath

   !ifndef un.GetLongPath

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro GetLongPath

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 ################################################################################

 # Macros for cleaning up the registry and file system

 /**

  * Removes registry keys that reference this install location and for paths that

  * no longer exist. This uses SHCTX to determine the registry hive so you must

  * call SetShellVarContext first.

  *

  * @param   _KEY

  *          The registry subkey (typically this will be Software\Mozilla).

  *

  * XXXrstrong - there is the potential for Key: Software/Mozilla/AppName,

  * ValueName: CurrentVersion, ValueData: AppVersion to reference a key that is

  * no longer available due to this cleanup. This should be no worse than prior

  * to this reg cleanup since the referenced key would be for an app that is no

  * longer installed on the system.

  *

  * $R0 = on x64 systems set to 'false' at the beginning of the macro when

  *       enumerating the x86 registry view and set to 'true' when enumerating

  *       the x64 registry view.

  * $R1 = stores the long path to $INSTDIR

  * $R2 = return value from the stack from the GetParent and GetLongPath macros

  * $R3 = return value from the outer loop's EnumRegKey

  * $R4 = return value from the inner loop's EnumRegKey

  * $R5 = return value from ReadRegStr

  * $R6 = counter for the outer loop's EnumRegKey

  * $R7 = counter for the inner loop's EnumRegKey

  * $R8 = return value from the stack from the RemoveQuotesFromPath macro

  * $R9 = _KEY

  */

 !macro RegCleanMain

   !ifndef ${_MOZFUNC_UN}RegCleanMain

     !define _MOZFUNC_UN_TMP ${_MOZFUNC_UN}

     !insertmacro ${_MOZFUNC_UN_TMP}GetParent

     !insertmacro ${_MOZFUNC_UN_TMP}GetLongPath

     !insertmacro ${_MOZFUNC_UN_TMP}RemoveQuotesFromPath

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN ${_MOZFUNC_UN_TMP}

     !undef _MOZFUNC_UN_TMP

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !define ${_MOZFUNC_UN}RegCleanMain "!insertmacro ${_MOZFUNC_UN}RegCleanMainCall"

     Function ${_MOZFUNC_UN}RegCleanMain

       Exch $R9

       Push $R8

       Push $R7

       Push $R6

       Push $R5

       Push $R4

       Push $R3

       Push $R2

       Push $R1

       Push $R0

       ${${_MOZFUNC_UN}GetLongPath} "$INSTDIR" $R1

       StrCpy $R6 0  ; set the counter for the outer loop to 0

       ${If} ${RunningX64}

         StrCpy $R0 "false"

         ; Set the registry to the 32 bit registry for 64 bit installations or to

         ; the 64 bit registry for 32 bit installations at the beginning so it can

         ; easily be set back to the correct registry view when finished.

         !ifdef HAVE_64BIT_OS

           SetRegView 32

         !else

           SetRegView 64

         !endif

       ${EndIf}

       outerloop:

       EnumRegKey $R3 SHCTX $R9 $R6

       StrCmp $R3 "" end +1  ; if empty there are no more keys to enumerate

       IntOp $R6 $R6 + 1     ; increment the outer loop's counter

       ClearErrors

       ReadRegStr $R5 SHCTX "$R9\$R3\bin" "PathToExe"

       IfErrors 0 outercontinue

       StrCpy $R7 0  ; set the counter for the inner loop to 0

       innerloop:

       EnumRegKey $R4 SHCTX "$R9\$R3" $R7

       StrCmp $R4 "" outerloop +1  ; if empty there are no more keys to enumerate

       IntOp $R7 $R7 + 1  ; increment the inner loop's counter

       ClearErrors

       ReadRegStr $R5 SHCTX "$R9\$R3\$R4\Main" "PathToExe"

       IfErrors innerloop

       ${${_MOZFUNC_UN}RemoveQuotesFromPath} "$R5" $R8

       ${${_MOZFUNC_UN}GetParent} "$R8" $R2

       ${${_MOZFUNC_UN}GetLongPath} "$R2" $R2

       IfFileExists "$R2" +1 innerloop

       StrCmp "$R2" "$R1" +1 innerloop

       ClearErrors

       DeleteRegKey SHCTX "$R9\$R3\$R4"

       IfErrors innerloop

       IntOp $R7 $R7 - 1 ; decrement the inner loop's counter when the key is deleted successfully.

       ClearErrors

       DeleteRegKey /ifempty SHCTX "$R9\$R3"

       IfErrors innerloop outerdecrement

       outercontinue:

       ${${_MOZFUNC_UN}RemoveQuotesFromPath} "$R5" $R8

       ${${_MOZFUNC_UN}GetParent} "$R8" $R2

       ${${_MOZFUNC_UN}GetLongPath} "$R2" $R2

       IfFileExists "$R2" +1 outerloop

       StrCmp "$R2" "$R1" +1 outerloop

       ClearErrors

       DeleteRegKey SHCTX "$R9\$R3"

       IfErrors outerloop

       outerdecrement:

       IntOp $R6 $R6 - 1 ; decrement the outer loop's counter when the key is deleted successfully.

       GoTo outerloop

       end:

       ${If} ${RunningX64}

       ${AndIf} "$R0" == "false"

         ; Set the registry to the correct view.

         !ifdef HAVE_64BIT_OS

           SetRegView 64

         !else

           SetRegView 32

         !endif

         StrCpy $R6 0  ; set the counter for the outer loop to 0

         StrCpy $R0 "true"

         GoTo outerloop

       ${EndIf}

       ClearErrors

       Pop $R0

       Pop $R1

       Pop $R2

       Pop $R3

       Pop $R4

       Pop $R5

       Pop $R6

       Pop $R7

       Pop $R8

       Exch $R9

     FunctionEnd

     !verbose pop

   !endif

 !macroend

 !macro RegCleanMainCall _KEY

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Call RegCleanMain

   !verbose pop

 !macroend

 !macro un.RegCleanMainCall _KEY

   !verbose push

   !verbose ${_MOZFUNC_VERBOSE}

   Push "${_KEY}"

   Call un.RegCleanMain

   !verbose pop

 !macroend

 !macro un.RegCleanMain

   !ifndef un.RegCleanMain

     !verbose push

     !verbose ${_MOZFUNC_VERBOSE}

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN "un."

     !insertmacro RegCleanMain

     !undef _MOZFUNC_UN

     !define _MOZFUNC_UN

     !verbose pop

   !endif

 !macroend

 /**