NSIS Wiki - User contributions [en]

Environmental Variables: append, prepend, and remove entries

2008-07-04T18:01:32Z

Turnec2: /* Function Code */ Removed redundant definitions (HKLM/CU)

{{PageAuthor|turnec2}}

== Description ==

;Function - EnvVarUpdate

;Version 1.0

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for such things as removing
pathnames associated with earlier revisions in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

;Design

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

=== Examples ===
==== Installer Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

==== Uninstaller Examples ====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyApp-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyApp-v1.0" ; Restore path of previous rev
</highlight-nsis>

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Function Code ==

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call ${UN}StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]
[[Category:System Related Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-04T17:48:43Z

Turnec2: /* Function Code */ Removed _unStrTokConstructor (not needed)

{{PageAuthor|turnec2}}

== Description ==

;Function - EnvVarUpdate

;Version 1.0

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for such things as removing
pathnames associated with earlier revisions in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

;Design

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

=== Examples ===
==== Installer Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

==== Uninstaller Examples ====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyApp-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyApp-v1.0" ; Restore path of previous rev
</highlight-nsis>

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Function Code ==

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call ${UN}StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]
[[Category:System Related Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-04T16:35:55Z

Turnec2: /* Uninstaller Examples */

{{PageAuthor|turnec2}}

== Description ==

;Function - EnvVarUpdate

;Version 1.0

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for such things as removing
pathnames associated with earlier revisions in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

;Design

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

=== Examples ===
==== Installer Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

==== Uninstaller Examples ====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyApp-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyApp-v1.0" ; Restore path of previous rev
</highlight-nsis>

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Function Code ==

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]
[[Category:System Related Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-04T16:33:57Z

Turnec2:

{{PageAuthor|turnec2}}

== Description ==

;Function - EnvVarUpdate

;Version 1.0

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for such things as removing
pathnames associated with earlier revisions in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

;Design

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

=== Examples ===
==== Installer Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

==== Uninstaller Examples ====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyLib-v1.0" ; Restore path of previous rev
</highlight-nsis>

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Function Code ==

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]
[[Category:System Related Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-04T16:22:51Z

Turnec2: /* Description */

{{PageAuthor|turnec2}}

== Description ==

;Function - EnvVarUpdate

;Version 1.0

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for such things as removing
pathnames associated with earlier revisions in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

;Design

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

=== Examples ===
==== Installer Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

==== Uninstaller Examples ====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyLib-v1.0" ; Restore path of previous rev
</highlight-nsis>

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Function Code ==

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path manipulation with all users/current user selection in run-time

2008-07-04T16:19:44Z

Turnec2: Added a bit more explanation

{{PageAuthor|turnec2}}

== EnvVarUpdate ==

The AddToPath and un.RemoveFromPath functions in this page have been obsoleted by EnvVarUpdate.
The un.RemoveFromPath routine can corrupt the contents of the PATH variable if the path being removed happens to be a subset of another. For example, if PATH contains "C:\Windows\system32\wbem" and you remove "C:\Windows\system32" the result is "\wbem". AddToPath does not prevent the duplication of entries if the user runs the installer multiple times (and the installer code does not otherwise check for duplicates). Nevertheless, these routines have been retained for Windows 9x/ME users in the next section since EnvVarUpdate does not support the update of variables in the autoexec.bat file.

See [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]] for more information.

== Function Code ==

[[http://nsis.sourceforge.net/Environmental_Variables:_append%2C_prepend%2C_and_remove_entries#Function_Code EnvVarUpdate function code]]

{{PageAuthor|e-circ}}
== Functions for Windows 95, 98, and ME ==

I adapted Path manipulation routines so you can select to change the path in the all users/current user profile in runtime.

The original message:

Here are two functions, one for adding directories to the search path of Windows and the other to remove them. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions do not set the reboot flag so that should be done manually.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier version of NSIS with a litte application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at this forum thread.

Usage example:

<highlight-nsis>
Section "Add to path"
Push $INSTDIR
Call AddToPath
SectionEnd

...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
SectionEnd
</highlight-nsis>

The functions in the flesh:
<highlight-nsis>
;----------------------------------------
; based upon a script of "Written by KiCHiK 2003-01-18 05:57:02"
;----------------------------------------
!verbose 3
!include "WinMessages.NSH"
!verbose 4
;====================================================
; get_NT_environment
; Returns: the selected environment
; Output : head of the stack
;====================================================
!macro select_NT_profile UN
Function ${UN}select_NT_profile
MessageBox MB_YESNO|MB_ICONQUESTION "Change the environment for all users?$\r$\nSaying no here will change the envrironment for the current user only.$\r$\n(Administrator permissions required for all users)" \
IDNO environment_single
DetailPrint "Selected environment for all users"
Push "all"
Return
environment_single:
DetailPrint "Selected environment for current user only."
Push "current"
Return
FunctionEnd
!macroend
!insertmacro select_NT_profile ""
!insertmacro select_NT_profile "un."
;----------------------------------------------------
!define NT_current_env 'HKCU "Environment"'
!define NT_all_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
;====================================================
; IsNT - Returns 1 if the current system is NT, 0
; otherwise.
; Output: head of the stack
;====================================================
!macro IsNT UN
Function ${UN}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."
;====================================================
; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot
;====================================================
Function AddToPath
Exch $0
Push $1
Push $2

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 0 END
GetFullPathName /SHORT $0 $0
FileWrite $1 "$\r$\nSET PATH=%PATH%;$0$\r$\n"
FileClose $1
Goto AddToPath_done

AddToPath_NT:
Push $4
Call select_NT_profile
Pop $4

AddToPath_NT_selection_done:
StrCmp $4 "current" read_path_NT_current
ReadRegStr $1 ${NT_all_env} "PATH"
Goto read_path_NT_resume
read_path_NT_current:
ReadRegStr $1 ${NT_current_env} "PATH"
read_path_NT_resume:
StrCpy $2 $0
StrCmp $1 "" AddToPath_NTdoIt
StrCpy $2 "$1;$0"
AddToPath_NTdoIt:
StrCmp $4 "current" write_path_NT_current
ClearErrors
WriteRegExpandStr ${NT_all_env} "PATH" $2
IfErrors 0 write_path_NT_resume
MessageBox MB_YESNO|MB_ICONQUESTION "The path could not be set for all users$\r$\nShould I try for the current user?" \
IDNO write_path_NT_failed
; change selection
StrCpy $4 "current"
Goto AddToPath_NT_selection_done
write_path_NT_current:
ClearErrors
WriteRegExpandStr ${NT_current_env} "PATH" $2
IfErrors 0 write_path_NT_resume
MessageBox MB_OK|MB_ICONINFORMATION "The path could not be set for the current user."
Goto write_path_NT_failed
write_path_NT_resume:
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
DetailPrint "added path for user ($4), $0"
write_path_NT_failed:

Pop $4
AddToPath_done:
Pop $2
Pop $1
Pop $0
FunctionEnd

;====================================================
; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack
;====================================================
Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoop
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoop
StrCmp $3 "$0" unRemoveFromPath_dosLoop
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
StrLen $2 $0
Call un.select_NT_profile
Pop $4

StrCmp $4 "current" un_read_path_NT_current
ReadRegStr $1 ${NT_all_env} "PATH"
Goto un_read_path_NT_resume
un_read_path_NT_current:
ReadRegStr $1 ${NT_current_env} "PATH"
un_read_path_NT_resume:

Push $1
Push $0
Call un.StrStr ; Find $0 in $1
Pop $0 ; pos of our dir
IntCmp $0 -1 unRemoveFromPath_done
; else, it is in path
StrCpy $3 $1 $0 ; $3 now has the part of the path before our dir
IntOp $2 $2 + $0 ; $2 now contains the pos after our dir in the path (';')
IntOp $2 $2 + 1 ; $2 now containts the pos after our dir and the semicolon.
StrLen $0 $1
StrCpy $1 $1 $0 $2
StrCpy $3 "$3$1"

StrCmp $4 "current" un_write_path_NT_current
WriteRegExpandStr ${NT_all_env} "PATH" $3
Goto un_write_path_NT_resume
un_write_path_NT_current:
WriteRegExpandStr ${NT_current_env} "PATH" $3
un_write_path_NT_resume:
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
unRemoveFromPath_done:
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Uninstall sutff
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;====================================================
; StrStr - Finds a given string in another given string.
; Returns -1 if not found and the pos if found.
; Input: head of the stack - string to find
; second in the stack - string to find in
; Output: head of the stack
;====================================================
Function un.StrStr
Push $0
Exch
Pop $0 ; $0 now have the string to find
Push $1
Exch 2
Pop $1 ; $1 now have the string to find in
Exch
Push $2
Push $3
Push $4
Push $5

StrCpy $2 -1
StrLen $3 $0
StrLen $4 $1
IntOp $4 $4 - $3

unStrStr_loop:
IntOp $2 $2 + 1
IntCmp $2 $4 0 0 unStrStrReturn_notFound
StrCpy $5 $1 $3 $2
StrCmp $5 $0 unStrStr_done unStrStr_loop

unStrStrReturn_notFound:
StrCpy $2 -1

unStrStr_done:
Pop $5
Pop $4
Pop $3
Exch $2
Exch 2
Pop $0
Pop $1
FunctionEnd
;====================================================
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Setting Environment Variables

2008-07-04T16:09:11Z

Turnec2: Added EnvVarUpdate info and restructured the TOC

{{PageAuthor|KiCHiK}}
== Setting Environmental Variables Temporarily ==

If you want to set an environment variable only for the installer process and its sub-processes use:
<highlight-nsis>System::Call 'Kernel32::SetEnvironmentVariableA(t, t) i("name", "value").r0'
StrCmp $0 0 error
ExecWait ProgThatReadsEnv.exe
Goto done
error:
MessageBox MB_OK "Can't set environment variable"
done:</highlight-nsis>

{{PageAuthor|turnec2}}
== Setting Environmental Variables Permanently ==
=== EnvVarUpdate ===

The WriteEnvStr and un.DeleteEnvStr functions in this page have been obsoleted by EnvVarUpdate.
The un.DeleteEnvStr function can corrupt the contents of the PATH variable if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove "C:\Windows\system32" the result is "\wbem". WriteEnvStr does not prevent the duplication of entries if the user runs the installer multiple times (and the installer code does not otherwise check for duplicates). However, these routines are retained for Windows 9x and ME in the next section since EnvVarUpdate does not support the update of variables in the autoexec.bat file.

See [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]] for more information.

==== Function Code ====

[[http://nsis.sourceforge.net/Environmental_Variables:_append%2C_prepend%2C_and_remove_entries#Function_Code EnvVarUpdate function code]]

{{PageAuthor|KiCHiK}}
=== Functions for Windows 95, 98, and ME ===
If you want to set an environment variable that will stick for every other process and after reboots too you should use the functions below. To use them either save them as a .NSH file and include them in your script, or just copy paste them in your script. If you choose to save them as a .NSH file use:
<highlight-nsis>!include WriteEnvStr.nsh # or the name you chose
# ...
Section "Add Env Var"
Push MyEnvVar
Push MyEnvVarValue
Call WriteEnvStr
SectionEnd
# ...
Section uninstall
# remove the variable
Push MyEnvVar
Call un.DeleteEnvStr
SectionEnd
</highlight-nsis>
If you want the environment variable to be available to all of the users using the computer define ALL_USERS before you include WriteEnvStr.nsh (or before the part of the script holding these functions if you didn't save it as a .NSH file). For example:
<highlight-nsis>!define ALL_USERS
!include WriteEnvStr.nsh # or the name you chose</highlight-nsis>

==== Function Code ====
'''Note:''' under Windows 9x a reboot is required for changes to take affect. The reboot flag will be set by these functions if a reboot is required.
'''Warning:''' this script will only work on NSIS 2.0b2 and above!
<highlight-nsis>!ifndef _WriteEnvStr_nsh
!define _WriteEnvStr_nsh

!include WinMessages.nsh

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

#
# WriteEnvStr - Writes an environment variable
# Note: Win9x systems requires reboot
#
# Example:
# Push "HOMEDIR" # name
# Push "C:\New Home Dir\" # value
# Call WriteEnvStr
#
Function WriteEnvStr
Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name
Push $2

Call IsNT
Pop $2
StrCmp $2 1 WriteEnvStr_NT
; Not on NT
StrCpy $2 $WINDIR 2 ; Copy drive of windows (c:)
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 0 END
FileWrite $2 "$\r$\nSET $0=$1$\r$\n"
FileClose $2
SetRebootFlag true
Goto WriteEnvStr_done

WriteEnvStr_NT:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} \
0 "STR:Environment" /TIMEOUT=5000

WriteEnvStr_done:
Pop $2
Pop $0
Pop $1
FunctionEnd

#
# un.DeleteEnvStr - Removes an environment variable
# Note: Win9x systems requires reboot
#
# Example:
# Push "HOMEDIR" # name
# Call un.DeleteEnvStr
#
Function un.DeleteEnvStr
Exch $0 ; $0 now has the name of the variable
Push $1
Push $2
Push $3
Push $4
Push $5

Call un.IsNT
Pop $1
StrCmp $1 1 DeleteEnvStr_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
StrCpy $0 "SET $0="
SetRebootFlag true

DeleteEnvStr_dosLoop:
FileRead $1 $3
StrLen $5 $0
StrCpy $5 $3 $5
StrCmp $5 $0 DeleteEnvStr_dosLoop
StrCmp $5 "" DeleteEnvStr_dosLoopEnd
FileWrite $2 $3
Goto DeleteEnvStr_dosLoop

DeleteEnvStr_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto DeleteEnvStr_done

DeleteEnvStr_NT:
DeleteRegValue ${WriteEnvStr_RegKey} $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} \
0 "STR:Environment" /TIMEOUT=5000

DeleteEnvStr_done:
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

#
# [un.]IsNT - Pushes 1 if running on NT, 0 if not
#
# Example:
# Call IsNT
# Pop $0
# StrCmp $0 1 +3
# MessageBox MB_OK "Not running on NT!"
# Goto +2
# MessageBox MB_OK "Running on NT!"
#
!macro IsNT UN
Function ${UN}IsNT
Push $0
ReadRegStr $0 HKLM \
"SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

!endif ; _WriteEnvStr_nsh
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path manipulation with all users/current user selection in run-time

2008-07-04T15:30:40Z

Turnec2:

{{PageAuthor|turnec2}}

== EnvVarUpdate ==

The AddToPath and un.RemoveFromPath functions in this page have been obsoleted by EnvVarUpdate.
These routines can corrupt the contents of the PATH variable if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove "C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if the user runs the installer multiple times (and the installer code does not check for duplicates).

See [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]] for more information.

== Function Code ==

[[http://nsis.sourceforge.net/Environmental_Variables:_append%2C_prepend%2C_and_remove_entries#Function_Code EnvVarUpdate function code]]

== Functions for Windows 95, 98, and ME ==

{{PageAuthor|e-circ}}

I adapted Path manipulation routines so you can select to change the path in the all users/current user profile in runtime.

The original message:

Here are two functions, one for adding directories to the search path of Windows and the other to remove them. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions do not set the reboot flag so that should be done manually.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier version of NSIS with a litte application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at this forum thread.

Usage example:

<highlight-nsis>
Section "Add to path"
Push $INSTDIR
Call AddToPath
SectionEnd

...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
SectionEnd
</highlight-nsis>

The functions in the flesh:
<highlight-nsis>
;----------------------------------------
; based upon a script of "Written by KiCHiK 2003-01-18 05:57:02"
;----------------------------------------
!verbose 3
!include "WinMessages.NSH"
!verbose 4
;====================================================
; get_NT_environment
; Returns: the selected environment
; Output : head of the stack
;====================================================
!macro select_NT_profile UN
Function ${UN}select_NT_profile
MessageBox MB_YESNO|MB_ICONQUESTION "Change the environment for all users?$\r$\nSaying no here will change the envrironment for the current user only.$\r$\n(Administrator permissions required for all users)" \
IDNO environment_single
DetailPrint "Selected environment for all users"
Push "all"
Return
environment_single:
DetailPrint "Selected environment for current user only."
Push "current"
Return
FunctionEnd
!macroend
!insertmacro select_NT_profile ""
!insertmacro select_NT_profile "un."
;----------------------------------------------------
!define NT_current_env 'HKCU "Environment"'
!define NT_all_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
;====================================================
; IsNT - Returns 1 if the current system is NT, 0
; otherwise.
; Output: head of the stack
;====================================================
!macro IsNT UN
Function ${UN}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."
;====================================================
; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot
;====================================================
Function AddToPath
Exch $0
Push $1
Push $2

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 0 END
GetFullPathName /SHORT $0 $0
FileWrite $1 "$\r$\nSET PATH=%PATH%;$0$\r$\n"
FileClose $1
Goto AddToPath_done

AddToPath_NT:
Push $4
Call select_NT_profile
Pop $4

AddToPath_NT_selection_done:
StrCmp $4 "current" read_path_NT_current
ReadRegStr $1 ${NT_all_env} "PATH"
Goto read_path_NT_resume
read_path_NT_current:
ReadRegStr $1 ${NT_current_env} "PATH"
read_path_NT_resume:
StrCpy $2 $0
StrCmp $1 "" AddToPath_NTdoIt
StrCpy $2 "$1;$0"
AddToPath_NTdoIt:
StrCmp $4 "current" write_path_NT_current
ClearErrors
WriteRegExpandStr ${NT_all_env} "PATH" $2
IfErrors 0 write_path_NT_resume
MessageBox MB_YESNO|MB_ICONQUESTION "The path could not be set for all users$\r$\nShould I try for the current user?" \
IDNO write_path_NT_failed
; change selection
StrCpy $4 "current"
Goto AddToPath_NT_selection_done
write_path_NT_current:
ClearErrors
WriteRegExpandStr ${NT_current_env} "PATH" $2
IfErrors 0 write_path_NT_resume
MessageBox MB_OK|MB_ICONINFORMATION "The path could not be set for the current user."
Goto write_path_NT_failed
write_path_NT_resume:
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
DetailPrint "added path for user ($4), $0"
write_path_NT_failed:

Pop $4
AddToPath_done:
Pop $2
Pop $1
Pop $0
FunctionEnd

;====================================================
; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack
;====================================================
Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoop
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoop
StrCmp $3 "$0" unRemoveFromPath_dosLoop
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
StrLen $2 $0
Call un.select_NT_profile
Pop $4

StrCmp $4 "current" un_read_path_NT_current
ReadRegStr $1 ${NT_all_env} "PATH"
Goto un_read_path_NT_resume
un_read_path_NT_current:
ReadRegStr $1 ${NT_current_env} "PATH"
un_read_path_NT_resume:

Push $1
Push $0
Call un.StrStr ; Find $0 in $1
Pop $0 ; pos of our dir
IntCmp $0 -1 unRemoveFromPath_done
; else, it is in path
StrCpy $3 $1 $0 ; $3 now has the part of the path before our dir
IntOp $2 $2 + $0 ; $2 now contains the pos after our dir in the path (';')
IntOp $2 $2 + 1 ; $2 now containts the pos after our dir and the semicolon.
StrLen $0 $1
StrCpy $1 $1 $0 $2
StrCpy $3 "$3$1"

StrCmp $4 "current" un_write_path_NT_current
WriteRegExpandStr ${NT_all_env} "PATH" $3
Goto un_write_path_NT_resume
un_write_path_NT_current:
WriteRegExpandStr ${NT_current_env} "PATH" $3
un_write_path_NT_resume:
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
unRemoveFromPath_done:
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Uninstall sutff
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;====================================================
; StrStr - Finds a given string in another given string.
; Returns -1 if not found and the pos if found.
; Input: head of the stack - string to find
; second in the stack - string to find in
; Output: head of the stack
;====================================================
Function un.StrStr
Push $0
Exch
Pop $0 ; $0 now have the string to find
Push $1
Exch 2
Pop $1 ; $1 now have the string to find in
Exch
Push $2
Push $3
Push $4
Push $5

StrCpy $2 -1
StrLen $3 $0
StrLen $4 $1
IntOp $4 $4 - $3

unStrStr_loop:
IntOp $2 $2 + 1
IntCmp $2 $4 0 0 unStrStrReturn_notFound
StrCpy $5 $1 $3 $2
StrCmp $5 $0 unStrStr_done unStrStr_loop

unStrStrReturn_notFound:
StrCpy $2 -1

unStrStr_done:
Pop $5
Pop $4
Pop $3
Exch $2
Exch 2
Pop $0
Pop $1
FunctionEnd
;====================================================
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path manipulation with all users/current user selection in run-time

2008-07-04T15:29:55Z

Turnec2:

Path manipulation with all users/current user selection in run-time

2008-07-04T15:27:39Z

Turnec2: Functions obsoleted by EnvVarUpdate except for Windows 95, 98, and ME

{{PageAuthor|turnec2}}

== EnvVarUpdate ==

The AddToPath and un.RemoveFromPath functions in this page have been obsoleted by EnvVarUpdate.
These routines can corrupt the contents of the PATH variable if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove "C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if the user runs the installer multiple times (and the installer code does check for duplicates).

See [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]] for more information.

== Function Code ==

[[http://nsis.sourceforge.net/Environmental_Variables:_append%2C_prepend%2C_and_remove_entries#Function_Code EnvVarUpdate function code]]

== Functions for Windows 95, 98, and ME ==

{{PageAuthor|e-circ}}

I adapted Path manipulation routines so you can select to change the path in the all users/current user profile in runtime.

The original message:

Here are two functions, one for adding directories to the search path of Windows and the other to remove them. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions do not set the reboot flag so that should be done manually.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier version of NSIS with a litte application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at this forum thread.

Usage example:

<highlight-nsis>
Section "Add to path"
Push $INSTDIR
Call AddToPath
SectionEnd

...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
SectionEnd
</highlight-nsis>

The functions in the flesh:
<highlight-nsis>
;----------------------------------------
; based upon a script of "Written by KiCHiK 2003-01-18 05:57:02"
;----------------------------------------
!verbose 3
!include "WinMessages.NSH"
!verbose 4
;====================================================
; get_NT_environment
; Returns: the selected environment
; Output : head of the stack
;====================================================
!macro select_NT_profile UN
Function ${UN}select_NT_profile
MessageBox MB_YESNO|MB_ICONQUESTION "Change the environment for all users?$\r$\nSaying no here will change the envrironment for the current user only.$\r$\n(Administrator permissions required for all users)" \
IDNO environment_single
DetailPrint "Selected environment for all users"
Push "all"
Return
environment_single:
DetailPrint "Selected environment for current user only."
Push "current"
Return
FunctionEnd
!macroend
!insertmacro select_NT_profile ""
!insertmacro select_NT_profile "un."
;----------------------------------------------------
!define NT_current_env 'HKCU "Environment"'
!define NT_all_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
;====================================================
; IsNT - Returns 1 if the current system is NT, 0
; otherwise.
; Output: head of the stack
;====================================================
!macro IsNT UN
Function ${UN}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."
;====================================================
; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot
;====================================================
Function AddToPath
Exch $0
Push $1
Push $2

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 0 END
GetFullPathName /SHORT $0 $0
FileWrite $1 "$\r$\nSET PATH=%PATH%;$0$\r$\n"
FileClose $1
Goto AddToPath_done

AddToPath_NT:
Push $4
Call select_NT_profile
Pop $4

AddToPath_NT_selection_done:
StrCmp $4 "current" read_path_NT_current
ReadRegStr $1 ${NT_all_env} "PATH"
Goto read_path_NT_resume
read_path_NT_current:
ReadRegStr $1 ${NT_current_env} "PATH"
read_path_NT_resume:
StrCpy $2 $0
StrCmp $1 "" AddToPath_NTdoIt
StrCpy $2 "$1;$0"
AddToPath_NTdoIt:
StrCmp $4 "current" write_path_NT_current
ClearErrors
WriteRegExpandStr ${NT_all_env} "PATH" $2
IfErrors 0 write_path_NT_resume
MessageBox MB_YESNO|MB_ICONQUESTION "The path could not be set for all users$\r$\nShould I try for the current user?" \
IDNO write_path_NT_failed
; change selection
StrCpy $4 "current"
Goto AddToPath_NT_selection_done
write_path_NT_current:
ClearErrors
WriteRegExpandStr ${NT_current_env} "PATH" $2
IfErrors 0 write_path_NT_resume
MessageBox MB_OK|MB_ICONINFORMATION "The path could not be set for the current user."
Goto write_path_NT_failed
write_path_NT_resume:
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
DetailPrint "added path for user ($4), $0"
write_path_NT_failed:

Pop $4
AddToPath_done:
Pop $2
Pop $1
Pop $0
FunctionEnd

;====================================================
; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack
;====================================================
Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoop
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoop
StrCmp $3 "$0" unRemoveFromPath_dosLoop
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
StrLen $2 $0
Call un.select_NT_profile
Pop $4

StrCmp $4 "current" un_read_path_NT_current
ReadRegStr $1 ${NT_all_env} "PATH"
Goto un_read_path_NT_resume
un_read_path_NT_current:
ReadRegStr $1 ${NT_current_env} "PATH"
un_read_path_NT_resume:

Push $1
Push $0
Call un.StrStr ; Find $0 in $1
Pop $0 ; pos of our dir
IntCmp $0 -1 unRemoveFromPath_done
; else, it is in path
StrCpy $3 $1 $0 ; $3 now has the part of the path before our dir
IntOp $2 $2 + $0 ; $2 now contains the pos after our dir in the path (';')
IntOp $2 $2 + 1 ; $2 now containts the pos after our dir and the semicolon.
StrLen $0 $1
StrCpy $1 $1 $0 $2
StrCpy $3 "$3$1"

StrCmp $4 "current" un_write_path_NT_current
WriteRegExpandStr ${NT_all_env} "PATH" $3
Goto un_write_path_NT_resume
un_write_path_NT_current:
WriteRegExpandStr ${NT_current_env} "PATH" $3
un_write_path_NT_resume:
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
unRemoveFromPath_done:
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Uninstall sutff
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;====================================================
; StrStr - Finds a given string in another given string.
; Returns -1 if not found and the pos if found.
; Input: head of the stack - string to find
; second in the stack - string to find in
; Output: head of the stack
;====================================================
Function un.StrStr
Push $0
Exch
Pop $0 ; $0 now have the string to find
Push $1
Exch 2
Pop $1 ; $1 now have the string to find in
Exch
Push $2
Push $3
Push $4
Push $5

StrCpy $2 -1
StrLen $3 $0
StrLen $4 $1
IntOp $4 $4 - $3

unStrStr_loop:
IntOp $2 $2 + 1
IntCmp $2 $4 0 0 unStrStrReturn_notFound
StrCpy $5 $1 $3 $2
StrCmp $5 $0 unStrStr_done unStrStr_loop

unStrStrReturn_notFound:
StrCpy $2 -1

unStrStr_done:
Pop $5
Pop $4
Pop $3
Exch $2
Exch 2
Pop $0
Pop $1
FunctionEnd
;====================================================
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-04T15:04:26Z

Turnec2:

{{PageAuthor|turnec2}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "Pathname"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Function Code ==

[[http://nsis.sourceforge.net/Environmental_Variables:_append%2C_prepend%2C_and_remove_entries#Function_Code EnvVarUpdate function code]]

== Functions for Windows 95, 98, and ME ==
{{PageAuthor|KiCHiK}}
The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the PATH variable within the autoexec.bat file.

NOTE: These routines can corrupt the contents of the PATH variable if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove "C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T16:13:22Z

Turnec2:

{{PageAuthor|turnec2}}

== Description ==

;Function - EnvVarUpdate

;Version 1.0

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

;Design

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

=== Examples ===
==== Installer Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

==== Uninstaller Examples ====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyLib-v1.0" ; Restore path of previous rev
</highlight-nsis>

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Function Code ==

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T16:00:39Z

Turnec2: /* Credits */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

==== Examples ====
===== Installer Examples =====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

===== Uninstaller Examples =====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyLib-v1.0" ; Restore path of previous rev
</highlight-nsis>

=== Credits ===

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T15:52:32Z

Turnec2: /* Examples */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

==== Examples ====
===== Installer Examples =====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools" ; Append
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32" ; Prepend
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0" ; Remove path of old rev
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0" ; Append the new one
</highlight-nsis>

===== Uninstaller Examples =====
<highlight-nsis>
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0" ; Remove path of latest rev
${un.EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\MyLib-v1.0" ; Restore path of previous rev
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T15:41:22Z

Turnec2: /* Parameters */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName (e.g., "C:\MyApp")

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T15:37:39Z

Turnec2: /* Description */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are permanently removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append, "P" = Prepend, "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T15:35:24Z

Turnec2: /* Description */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller.

The updated contents of the variable returned in ResultVar might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append, "P" = Prepend, "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T15:34:09Z

Turnec2: /* Description */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. The variable can be updated in either the "all users" section of the registry (HKLM) or the "current user" section (HKCU).

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of the variable before performing the requested operation. This step prevents the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller.

The string returned in ResultVar (the updated contents of the variable) might be useful for displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append, "P" = Prepend, "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T15:11:49Z

Turnec2: /* Syntax */

{{PageAuthor|turnec2}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "Pathname"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==
{{PageAuthor|KiCHiK}}
The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T15:08:23Z

Turnec2: /* Syntax */

{{PageAuthor|turnec2}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "PATH" "Action" "RegLoc" "Pathname"
</highlight-nsis>
or
<highlight-nsis>
Push "PATH"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==
{{PageAuthor|KiCHiK}}
The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T15:05:40Z

Turnec2: /* Syntax */

{{PageAuthor|turnec2}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "PATH" "Action" "RegLoc" "Pathname"

or

Push "PATH"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==
{{PageAuthor|KiCHiK}}
The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T15:03:59Z

Turnec2:

{{PageAuthor|turnec2}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "Pathname"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==
{{PageAuthor|KiCHiK}}
The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T14:55:56Z

Turnec2: /* Credits */

{{PageAuthor|turnec2KiCHiK}} {{PageAuthor|KiCHiK}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "Pathname"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso (deguix), and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==

The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T14:52:34Z

Turnec2:

{{PageAuthor|turnec2KiCHiK}} {{PageAuthor|KiCHiK}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "Pathname"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==

The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T14:51:38Z

Turnec2:

{{PageAuthor|turnec2|KiCHiK}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "Pathname"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==

The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T14:48:40Z

Turnec2: /* Parameters */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

:; ResultVar
::Updated environmental variable returned by the function

:; EnvVarName
:: Environmental variable name such as "PATH", "LIB", or "MYVAR"

:; Action
:: "A" = Append, "P" = Prepend, "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; PathString
:: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T14:47:00Z

Turnec2: /* Syntax */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"
</highlight-nsis>
or
<highlight-nsis>
Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Path Manipulation

2008-07-03T14:42:55Z

Turnec2:

{{PageAuthor|turnec2, KiCHiK}}

== Description ==

'''Version:''' 1.0

Append, prepend or remove a pathname from the PATH environmental variable in either the "all users" (HKLM) or the "current user" (HKCU) section of the registry.

Duplicates entries, leading and trailing spaces around each entry, and duplicate semicolons are removed from the contents of PATH before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname).

== Usage ==

=== Syntax ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "Pathname"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "Pathname"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

=== Parameters ===
:; ResultVar
:: Updated contents PATH returned by the function

:; EnvVarName
:: "PATH"

:; Action
:: "A" = Append
:: "P" = Prepend
:: "R" = Remove

:; RegLoc
:: "HKLM" = the "all users" section of the registry
:: "HKCU" = the "current user" section

:; Pathname
:: Pathname to add to or remove from the contents of PATH (e.g., "C:\MyApp")

=== Examples ===
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\Windows Resource Kits\Tools"
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "%WinDir%\System32"
${EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\Program Files\MyApp-v1.0"
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Program Files\MyApp-v2.0"

${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v1.0"
${un.EnvVarUpdate} $0 "PATH" "R" "HKLM" "C:\MyLib-v2.0"
</highlight-nsis>

== Dependencies ==

* '''EnvVarUpdate''' (available at [[Environmental_Variables:_append%2C_prepend%2C_and_remove_entries]])
* '''StrTok, StrContains, and StrReplace:''' Included in the EnvVarUpdate function code
* '''LogicLib header file:''' "LogicLib.nsh"

== Credits ==

* Version 1.0: Cal Turney (turnec2)
* Amir Szekely (KiCHiK) and e-circ for developing the forerunners of this function: AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr
* Diego Pedroso (deguix) for StrTok
* Kevin English (kenglish_hi)for StrContains
* Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace

== Functions for Windows 95, 98, and ME ==

The following routines, AddToPath, un.RemoveFromPath, AddToEnvVar, and un.RemoveFromEnvVar are provided for Windows 95, 98, or ME in that they support the update of the autoexec.bat file. Note that they can cause corruption of the PATH if the path being removed happens to be a subset of another path. For example, if PATH contains "C:\Windows\system32\wbem" and you remove
"C:\Windows\system32" the result is "\wbem". They also do not prevent duplication of entries if ,for example, the user runs the installer multiple times.

=== Description ===
Here are four functions, two for adding to and removing directories from the search path (i.e. PATH environment variable) of Windows and two more for adding to and removing directories from a user defined environment variable such as INCLUDE or LIB etc. These functions should work on every version of Windows including 95, 98, ME, NT, 2000, and XP.

For Windows NT/2000/XP they will write to HKEY_CURRENT_USER\Environment\PATH. For 9x/ME they will write to the autoexec.bat file.

Changes on 9x machines will take place after a reboot. These functions set the reboot flag if the path variable was changed on 9x.

These functions require NSIS 2.0b0 and above due to the usage of SendMessage with /TIMEOUT. It is possible to use it with earlier versions of NSIS with a little application I have created called RefreshEnv. It does exactly the same as SendMessage with /TIMEOUT. You can find it at [http://forums.winamp.com/showthread.php?s=&threadid=77904&highlight=refreshenv this forum thread].

The directory added to the path must exist prior to calling this function.

=== Usage Example ===
<highlight-nsis>Section "Add to path"
Push $INSTDIR
Call AddToPath

Push "LIB"
Push "c:\Mylibrary\lib"
Call AddToEnvVar

;likewise AddToPath could be
Push "PATH"
Push $INSTDIR
Call AddToEnvVar

SectionEnd

# ...

Section "uninstall"
# ...
Push $INSTDIR
Call un.RemoveFromPath
# ...
Push "LIB"
Push "c:\Mylibrary\lib"
Call un.RemoveFromEnvVar

;Likewise RemoveFromPath could be
Push "PATH"
Push $INSTDIR
Call un.RemoveFromEnvVar

SectionEnd</highlight-nsis>

=== The Functions ===
The functions in the flesh:

<highlight-nsis>!ifndef _AddToPath_nsh
!define _AddToPath_nsh

!verbose 3
!include "WinMessages.NSH"
!verbose 4

!ifndef WriteEnvStr_RegKey
!ifdef ALL_USERS
!define WriteEnvStr_RegKey \
'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!else
!define WriteEnvStr_RegKey 'HKCU "Environment"'
!endif
!endif

; AddToPath - Adds the given dir to the search path.
; Input - head of the stack
; Note - Win9x systems requires reboot

Function AddToPath
Exch $0
Push $1
Push $2
Push $3

# don't add if the path doesn't exist
IfFileExists "$0\*.*" "" AddToPath_done

ReadEnvStr $1 PATH
Push "$1;"
Push "$0;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$0\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
GetFullPathName /SHORT $3 $0
Push "$1;"
Push "$3;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done
Push "$1;"
Push "$3\;"
Call StrStr
Pop $2
StrCmp $2 "" "" AddToPath_done

Call IsNT
Pop $1
StrCmp $1 1 AddToPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" a
FileSeek $1 -1 END
FileReadByte $1 $2
IntCmp $2 26 0 +2 +2 # DOS EOF
FileSeek $1 -1 END # write over EOF
FileWrite $1 "$\r$\nSET PATH=%PATH%;$3$\r$\n"
FileClose $1
SetRebootFlag true
Goto AddToPath_done

AddToPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCmp $1 "" AddToPath_NTdoIt
Push $1
Call Trim
Pop $1
StrCpy $0 "$1;$0"
AddToPath_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToPath_done:
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; RemoveFromPath - Remove a given dir from the path
; Input: head of the stack

Function un.RemoveFromPath
Exch $0
Push $1
Push $2
Push $3
Push $4
Push $5
Push $6

IntFmt $6 "%c" 26 # DOS EOF

Call un.IsNT
Pop $1
StrCmp $1 1 unRemoveFromPath_NT
; Not on NT
StrCpy $1 $WINDIR 2
FileOpen $1 "$1\autoexec.bat" r
GetTempFileName $4
FileOpen $2 $4 w
GetFullPathName /SHORT $0 $0
StrCpy $0 "SET PATH=%PATH%;$0"
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoop:
FileRead $1 $3
StrCpy $5 $3 1 -1 # read last char
StrCmp $5 $6 0 +2 # if DOS EOF
StrCpy $3 $3 -1 # remove DOS EOF so we can compare
StrCmp $3 "$0$\r$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0$\n" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "$0" unRemoveFromPath_dosLoopRemoveLine
StrCmp $3 "" unRemoveFromPath_dosLoopEnd
FileWrite $2 $3
Goto unRemoveFromPath_dosLoop
unRemoveFromPath_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromPath_dosLoop

unRemoveFromPath_dosLoopEnd:
FileClose $2
FileClose $1
StrCpy $1 $WINDIR 2
Delete "$1\autoexec.bat"
CopyFiles /SILENT $4 "$1\autoexec.bat"
Delete $4
Goto unRemoveFromPath_done

unRemoveFromPath_NT:
ReadRegStr $1 ${WriteEnvStr_RegKey} "PATH"
StrCpy $5 $1 1 -1 # copy last char
StrCmp $5 ";" +2 # if last char != ;
StrCpy $1 "$1;" # append ;
Push $1
Push "$0;"
Call un.StrStr ; Find `$0;` in $1
Pop $2 ; pos of our dir
StrCmp $2 "" unRemoveFromPath_done
; else, it is in path
# $0 - path to add
# $1 - path var
StrLen $3 "$0;"
StrLen $4 $2
StrCpy $5 $1 -$4 # $5 is now the part before the path to remove
StrCpy $6 $2 "" $3 # $6 is now the part after the path to remove
StrCpy $3 $5$6

StrCpy $5 $3 1 -1 # copy last char
StrCmp $5 ";" 0 +2 # if last char == ;
StrCpy $3 $3 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} "PATH" $3
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromPath_done:
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

; AddToEnvVar - Adds the given value to the given environment var
; Input - head of the stack $0 environement variable $1=value to add
; Note - Win9x systems requires reboot

Function AddToEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Adding $1 to $0"
Push $2
Push $3
Push $4

ReadEnvStr $2 $0
Push "$2;"
Push "$1;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Push "$2;"
Push "$1\;"
Call StrStr
Pop $3
StrCmp $3 "" "" AddToEnvVar_done

Call IsNT
Pop $2
StrCmp $2 1 AddToEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" a
FileSeek $2 -1 END
FileReadByte $2 $3
IntCmp $3 26 0 +2 +2 # DOS EOF
FileSeek $2 -1 END # write over EOF
FileWrite $2 "$\r$\nSET $0=%$0%;$4$\r$\n"
FileClose $2
SetRebootFlag true
Goto AddToEnvVar_done

AddToEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $3 $2 1 -1 # copy last char
StrCmp $3 ";" 0 +2 # if last char == ;
StrCpy $2 $2 -1 # remove last char
StrCmp $2 "" AddToEnvVar_NTdoIt
StrCpy $1 "$2;$1"
AddToEnvVar_NTdoIt:
WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $1
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

AddToEnvVar_done:
Pop $4
Pop $3
Pop $2
Pop $0
Pop $1

FunctionEnd

; RemoveFromEnvVar - Remove a given value from a environment var
; Input: head of the stack

Function un.RemoveFromEnvVar

Exch $1 ; $1 has environment variable value
Exch
Exch $0 ; $0 has environment variable name

DetailPrint "Removing $1 from $0"
Push $2
Push $3
Push $4
Push $5
Push $6
Push $7

IntFmt $7 "%c" 26 # DOS EOF

Call un.IsNT
Pop $2
StrCmp $2 1 unRemoveFromEnvVar_NT
; Not on NT
StrCpy $2 $WINDIR 2
FileOpen $2 "$2\autoexec.bat" r
GetTempFileName $5
FileOpen $3 $5 w
GetFullPathName /SHORT $1 $1
StrCpy $1 "SET $0=%$0%;$1"
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoop:
FileRead $2 $4
StrCpy $6 $4 1 -1 # read last char
StrCmp $6 $7 0 +2 # if DOS EOF
StrCpy $4 $4 -1 # remove DOS EOF so we can compare
StrCmp $4 "$1$\r$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1$\n" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "$1" unRemoveFromEnvVar_dosLoopRemoveLine
StrCmp $4 "" unRemoveFromEnvVar_dosLoopEnd
FileWrite $3 $4
Goto unRemoveFromEnvVar_dosLoop
unRemoveFromEnvVar_dosLoopRemoveLine:
SetRebootFlag true
Goto unRemoveFromEnvVar_dosLoop

unRemoveFromEnvVar_dosLoopEnd:
FileClose $3
FileClose $2
StrCpy $2 $WINDIR 2
Delete "$2\autoexec.bat"
CopyFiles /SILENT $5 "$2\autoexec.bat"
Delete $5
Goto unRemoveFromEnvVar_done

unRemoveFromEnvVar_NT:
ReadRegStr $2 ${WriteEnvStr_RegKey} $0
StrCpy $6 $2 1 -1 # copy last char
StrCmp $6 ";" +2 # if last char != ;
StrCpy $2 "$2;" # append ;
Push $2
Push "$1;"
Call un.StrStr ; Find `$1;` in $2
Pop $3 ; pos of our dir
StrCmp $3 "" unRemoveFromEnvVar_done
; else, it is in path
# $1 - path to add
# $2 - path var
StrLen $4 "$1;"
StrLen $5 $3
StrCpy $6 $2 -$5 # $6 is now the part before the path to remove
StrCpy $7 $3 "" $4 # $7 is now the part after the path to remove
StrCpy $4 $6$7

StrCpy $6 $4 1 -1 # copy last char
StrCmp $6 ";" 0 +2 # if last char == ;
StrCpy $4 $4 -1 # remove last char

WriteRegExpandStr ${WriteEnvStr_RegKey} $0 $4

; delete reg value if null
StrCmp $4 "" 0 +2 # if null delete reg
DeleteRegValue ${WriteEnvStr_RegKey} $0

SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000

unRemoveFromEnvVar_done:
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Pop $0
FunctionEnd

!ifndef IsNT_KiCHiK
!define IsNT_KiCHiK

###########################################
# Utility Functions #
###########################################

; IsNT
; no input
; output, top of the stack = 1 if NT or 0 if not
;
; Usage:
; Call IsNT
; Pop $R0
; ($R0 at this point is 1 or 0)

!macro IsNT un
Function ${un}IsNT
Push $0
ReadRegStr $0 HKLM "SOFTWARE\Microsoft\Windows NT\CurrentVersion" CurrentVersion
StrCmp $0 "" 0 IsNT_yes
; we are not NT.
Pop $0
Push 0
Return

IsNT_yes:
; NT!!!
Pop $0
Push 1
FunctionEnd
!macroend
!insertmacro IsNT ""
!insertmacro IsNT "un."

!endif ; IsNT_KiCHiK

; StrStr
; input, top of stack = string to search for
; top of stack-1 = string to search in
; output, top of stack (replaces with the portion of the string remaining)
; modifies no other variables.
;
; Usage:
; Push "this is a long ass string"
; Push "ass"
; Call StrStr
; Pop $R0
; ($R0 at this point is "ass string")

!macro StrStr un
Function ${un}StrStr
Exch $R1 ; st=haystack,old$R1, $R1=needle
Exch ; st=old$R1,haystack
Exch $R2 ; st=old$R1,old$R2, $R2=haystack
Push $R3
Push $R4
Push $R5
StrLen $R3 $R1
StrCpy $R4 0
; $R1=needle
; $R2=haystack
; $R3=len(needle)
; $R4=cnt
; $R5=tmp
loop:
StrCpy $R5 $R2 $R3 $R4
StrCmp $R5 $R1 done
StrCmp $R5 "" done
IntOp $R4 $R4 + 1
Goto loop
done:
StrCpy $R1 $R2 "" $R4
Pop $R5
Pop $R4
Pop $R3
Pop $R2
Exch $R1
FunctionEnd
!macroend
!insertmacro StrStr ""
!insertmacro StrStr "un."

!endif ; _AddToPath_nsh

Function Trim ; Added by Pelaca
Exch $R1
Push $R2
Loop:
StrCpy $R2 "$R1" 1 -1
StrCmp "$R2" " " RTrim
StrCmp "$R2" "$\n" RTrim
StrCmp "$R2" "$\r" RTrim
StrCmp "$R2" ";" RTrim
GoTo Done
RTrim:
StrCpy $R1 "$R1" -1
Goto Loop
Done:
Pop $R2
Exch $R1
FunctionEnd
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T13:06:25Z

Turnec2:

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T02:03:08Z

Turnec2:

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T02:00:08Z

Turnec2: /* Usage */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===

==== Syntax ====
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:56:34Z

Turnec2: /* Design */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read the contents of EnvVarName from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# Remove all instances of the target path/string regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If Action is "R" (remove), skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:51:09Z

Turnec2: /* Function Code */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of the target path/string are removed from the variable regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" (remove) or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
; NOTE: Do not substitute 'StrReplaceV4' for this function. It will fail due to the way I call it.
;
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:43:52Z

Turnec2: /* Credits */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of the target path/string are removed from the variable regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" (remove) or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0: Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:42:17Z

Turnec2: /* Design */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of the target path/string are removed from the variable regardless of the operation because this not only eliminates duplicate entries, it also allows for the search order of the target entry to be changed from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" (remove) or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:38:30Z

Turnec2: /* Design */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because this not only eliminates duplicate entries, it also allows one to change the search order of the target entry from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated variable to RegLoc even if the Action is "R" (remove) or the target is not found because this allows for the elimination of duplicate semicolons, spaces around semicolons, spaces preceding the first entry, and spaces following the last entry.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:28:31Z

Turnec2: /* Function Code */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because this not only eliminates duplicate entries, it also allows one to change the search order of the target entry from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
; "Export" our change
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:25:24Z

Turnec2: /* Function Code */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because this not only eliminates duplicate entries, it also allows one to change the search order of the target entry from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar>' to '<EnvVar>'
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:23:08Z

Turnec2: /* Parameters */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because this not only eliminates duplicate entries, it also allows one to change the search order of the target entry from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = the "all users" section of the registry
: "HKCU" = the "current user" section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-03T01:21:15Z

Turnec2: /* Design */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because this not only eliminates duplicate entries, it also allows one to change the search order of the target entry from first to last and vice versa.
# If the operation is Remove, skip this step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = All users section of registry, "
: "HKCU" = current user section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:36:46Z

Turnec2:

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===
<highlight-nsis>
${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"
</highlight-nsis>
==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = All users section of registry, "
: "HKCU" = current user section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====
<highlight-nsis>
${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command
</highlight-nsis>

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:33:15Z

Turnec2: /* Parameters */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYVAR"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = All users section of registry, "
: "HKCU" = current user section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:31:57Z

Turnec2: /* Parameters */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYAPP"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = All users section of registry, "HKCU" = current user section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:30:58Z

Turnec2: /* Parameters */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYAPP"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = All users section of registry, "HKCU" = current user section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:30:17Z

Turnec2: /* Parameters */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Parameters ====

; ResultVar
:Updated environmental variable returned by the function

; EnvVarName
: Environmental variable name such as "PATH", "LIB", or "MYAPP"

; Action
: "A" = Append, "P" = Prepend, "R" = Remove

; RegLoc
: "HKLM" = All users section of registry, "HKCU" = current user section

; PathString
: A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:27:27Z

Turnec2: /* Usage */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Parameters ====

'''ResultVar'''
Updated environmental variable returned by the function
'''EnvVarName'''
Environmental variable name such as "PATH", "LIB", or "MYAPP"
'''Action'''
"A" = Append, "P" = Prepend, "R" = Remove
'''RegLoc'''
"HKLM" = All users section of registry, "HKCU" = current user section
'''PathString'''
A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:25:40Z

Turnec2: /* Syntax */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

==== Parameters ====

ResultVar - Updated environmental variable returned by the function
EnvVarName - Environmental variable name such as "PATH", "LIB", or "MYAPP"
Action - "A" = Append, "P" = Prepend, "R" = Remove
RegLoc - "HKLM" = All users section of registry, "HKCU" = current user section
PathString - A pathname or string to add to or remove from the contents of EnvVarName

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:24:04Z

Turnec2: /* Description */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

==== Syntax ====

ResultVar - Updated environmental variable returned by the function
EnvVarName - Environmental variable name such as "PATH", "LIB", or "MYAPP"
Action - "A" = Append, "P" = Prepend, "R" = Remove
RegLoc - "HKLM" = All users section of registry, "HKCU" = current user section
PathString - A pathname or string to add to or remove from the contents of EnvVarName

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:22:46Z

Turnec2:

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

==== Syntax ====

ResultVar - Updated environmental variable returned by the function
EnvVarName - Environmental variable name such as "PATH", "LIB", or "MYAPP"
Action - "A" = Append, "P" = Prepend, "R" = Remove
RegLoc - "HKLM" = All users section of registry, "HKCU" = current user section
PathString - A pathname or string to add to or remove from the contents of EnvVarName

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]

Environmental Variables: append, prepend, and remove entries

2008-07-02T23:21:52Z

Turnec2: /* Syntax */

{{PageAuthor|turnec2}}

== Function: EnvVarUpdate ==

=== Description ===

'''Version:''' 1.0

'''Dependencies:''' LogicLib header file ("LogicLib.nsh")

Append, prepend or remove a pathname or string from an environmental variable such as
PATH, LIB, CLASSPATH, PATHEXT, or a variable of your own. Duplicates entries, leading
and trailing spaces around each entry, and duplicate semicolons are removed from the
contents of the variable before performing the requested operation. This step prevents
the corruption of the variable's contents (e.g., when removing a target pathname that
is a subset of another pathname). The variable can be updated in either the "all users"
section of the registry (HKLM) or the "current user" section (HKCU).

The function can be called from an installer or uninstaller. The "remove" subfunction
is normally not required for installers; however, it might be useful for removing
entries, such as pathnames associated with earlier revisions, in the event that the user
has failed to run the uninstaller. The string returned in ResultVar might be useful for
displaying to the user, writing to a log file, or verification.

Three existing string functions are included in the function code. While these routines could have simply been added to list of dependencies, code for each is included to prevent possible failures caused by future modifications of these routines.

==== Design ====

# Read EnvVar from RegLoc
# Remove duplicate semicolons and spaces around semicolons
# All instances of target path/string are removed from the variable regardles of the operation because not only duplicate entries are eliminated but also allows one to change the search order of the target from first to last and vice versa.
# If the operation is Remove, skip the step, or else prepend or append the target per the requested Action.
# Write the updated Envar to RegLoc. The variable is written even if the Action is "R" (remove) or the target is not found, in order to eliminate duplicate semicolons and spaces around semicolons.

=== Usage ===

${EnvVarUpdate} "ResultVar" "EnvVarName" "Action" "RegLoc" "PathString"

==== Syntax ====

ResultVar - Updated environmental variable returned by the function
EnvVarName - Environmental variable name such as "PATH", "LIB", or "MYAPP"
Action - "A" = Append, "P" = Prepend, "R" = Remove
RegLoc - "HKLM" = All users section of registry, "HKCU" = current user section
PathString - A pathname or string to add to or remove from the contents of EnvVarName

or

Push "EnvVarName"
Push "Action"
Push "RegLoc"
Push "PathString"
Call EnvVarUpdate
Pop "ResultVar"

==== Examples ====

${EnvVarUpdate} $0 "PATH" "A" "HKLM" "C:\Target" ; Append a path to PATH in HKLM
${EnvVarUpdate} $0 "PATH" "P" "HKCU" "C:\Target" ; Prepend target path to PATH in HKCU
${EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Remove an entry from LIB in HKLM
${un.EnvVarUpdate} $0 "LIB" "R" "HKLM" "C:\MyLib" ; Uninstaller command

=== Credits ===

Version 1.0 - Cal Turney (turnec2)

* This function was inspired by (and replaces) AddToPath, un.RemoveFromPath, AddToEnvVar, un.RemoveFromEnvVar, WriteEnvStr, and un.DeleteEnvStr written by KiCHiK and updated by e-circ.

* Thanks to Diego Pedroso (deguix) for StrTok; Kevin English (kenglish_hi)for StrContains; and Hendri Adriaens (Smile2Me), Diego Pedroso, and Dan Fuhry (dandaman32) for StrReplace.

=== Function Code ===

<highlight-nsis>
!ifndef ENVVARUPDATE_FUNCTION
!define ENVVARUPDATE_FUNCTION
!verbose push
!verbose 3
!include "LogicLib.nsh"
!include "WinMessages.NSH"

!define all_users_env 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define current_user_only_env 'HKCU "Environment"'

; ---------------------------------- Macro Definitions ----------------------------------------
!macro _EnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define EnvVarUpdate '!insertmacro "_EnvVarUpdateConstructor"'

!macro _unEnvVarUpdateConstructor ResultVar EnvVarName Action Regloc PathString
Push "${EnvVarName}"
Push "${Action}"
Push "${RegLoc}"
Push "${PathString}"
Call un.EnvVarUpdate
Pop "${ResultVar}"
!macroend
!define un.EnvVarUpdate '!insertmacro "_unEnvVarUpdateConstructor"'

!macro _StrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call StrTok
Pop "${ResultVar}"
!macroend
!define StrTok '!insertmacro "_StrTokConstructor"'

!macro _unStrTokConstructor ResultVar String Separators ResultPart SkipEmptyParts
Push "${String}"
Push "${Separators}"
Push "${ResultPart}"
Push "${SkipEmptyParts}"
Call un.StrTok
Pop "${ResultVar}"
!macroend
!define un.StrTok '!insertmacro "_unStrTokConstructor"'

!macro _StrContainsConstructor OUT NEEDLE HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Call ${UN}StrContains
Pop "${OUT}"
!macroend
!define StrContains '!insertmacro "_StrContainsConstructor"'

!macro _strReplaceConstructor OUT NEEDLE NEEDLE2 HAYSTACK
Push "${HAYSTACK}"
Push "${NEEDLE}"
Push "${NEEDLE2}"
Call ${UN}StrReplace
Pop "${OUT}"
!macroend
!define StrReplace '!insertmacro "_strReplaceConstructor"'

; ---------------------------------- Macro Definitions end-------------------------------------

;----------------------------------- EnvVarUpdate start----------------------------------------
!define hklm_all_users 'HKLM "SYSTEM\CurrentControlSet\Control\Session Manager\Environment"'
!define hkcu_current_user 'HKCU "Environment"'

!macro EnvVarUpdate UN

Function ${UN}EnvVarUpdate

Push $0
Exch 4
Exch $1
Exch 3
Exch $2
Exch 2
Exch $3
Exch
Exch $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

/* After this point:
-------------------------
$0 = ResultVar (returned)
$1 = EnvVarName (input)
$2 = Action (input)
$3 = RegLoc (input)
$4 = PathString (input)
$5 = Orig EnvVar (read from registry)
$6 = Len of $0 (temp)
$7 = tempstr1 (temp)
$8 = Entry counter (temp)
$9 = tempstr2 (temp)
$R0 = tempChar (temp) */

; Step 1: Read contents of EnvVarName from RegLoc
;
; Check for empty EnvVarName
${If} $1 == ""
SetErrors
DetailPrint "ERROR: EnvVarName is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for valid Action
${If} $2 != "A"
${AndIf} $2 != "P"
${AndIf} $2 != "R"
SetErrors
DetailPrint "ERROR: Invalid Action - must be A, P, or R"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

${If} $3 == HKLM
ReadRegStr $5 ${hklm_all_users} $1 ; Get EnvVarName from all users into $5
${ElseIf} $3 == HKCU
ReadRegStr $5 ${hkcu_current_user} $1 ; Read EnvVarName from current user into $5
${Else}
SetErrors
DetailPrint 'ERROR: Action is [$3] but must be "HKLM" or HKCU"'
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Check for empty PathString
${If} $4 == ""
SetErrors
DetailPrint "ERROR: PathString is blank"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Make sure we've got some work to do
${If} $5 == ""
${AndIf} $2 == "R"
SetErrors
DetailPrint "$1 is empty - Nothing to remove"
Goto EnvVarUpdate_Restore_Vars
${EndIf}

; Step 2: Scrub EnvVar
;
StrCpy $0 $5 ; Copy the contents to $0
; Remove spaces around semicolons (NOTE: spaces before the 1st entry or
; after the last one are not removed here but instead in Step 3)
${If} $0 != "" ; If EnvVar is not empty ...
${Do}
${StrContains} $7 " ;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 " ;" ";" $0 ; Remove '<space>;'
${Loop}
${Do}
${StrContains} $7 "; " $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 "; " ";" $0 ; Remove ';<space>'
${Loop}
${Do}
${StrContains} $7 ";;" $0
${If} $7 == ""
${ExitDo}
${EndIf}
${StrReplace} $0 ";;" ";" $0
${Loop}

; Remove a leading or trailing semicolon from EnvVar
StrCpy $7 $0 1 0
${If} $7 == ";"
StrCpy $0 $0 "" 1 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
StrLen $6 $0
IntOp $6 $6 - 1
StrCpy $7 $0 1 $6
${If} $7 == ";"
StrCpy $0 $0 $6 ; Change ';<EnvVar> to <EnvVar>
${EndIf}
; DetailPrint "Scrubbed $1: [$0]" ; Uncomment to debug
${EndIf}

/* Step 3. Remove all instances of the target path/string (even if "A" or "P")
$6 = bool flag (1 = found and removed PathString)
$7 = a string (e.g. path) delimited by semicolon(s)
$8 = entry counter starting at 0
$9 = copy of $0
$R0 = tempChar */

${If} $5 != "" ; If EnvVar is not empty ...
StrCpy $9 $0
StrCpy $0 ""
StrCpy $8 0
StrCpy $6 0

${Do}
${${UN}StrTok} $7 $9 ";" $8 "0" ; $7 = next entry, $8 = entry counter

${If} $7 == "" ; If we've run out of entries,
${ExitDo} ; were done
${EndIf} ;

; Remove leading and trailing spaces from this entry (critical step for Action=Remove)
${Do}
StrCpy $R0 $7 1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 "" 1 ; Remove leading space
${Loop}
${Do}
StrCpy $R0 $7 1 -1
${If} $R0 != " "
${ExitDo}
${EndIf}
StrCpy $7 $7 -1 ; Remove trailing space
${Loop}
${If} $7 == $4 ; If string matches, remove it by not appending it
StrCpy $6 1 ; Set 'found' flag
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 == "" ; and the 1st string being added to $0,
StrCpy $0 $7 ; copy it to $0 without a prepended semicolon
${ElseIf} $7 != $4 ; If string does NOT match
${AndIf} $0 != "" ; and this is NOT the 1st string to be added to $0,
StrCpy $0 $0;$7 ; append path to $0 with a prepended semicolon
${EndIf} ;

IntOp $8 $8 + 1 ; Bump counter
${Loop} ; Check for duplicates until we run out of paths
${EndIf}

; Step 4: Perform the requested Action
;
${If} $2 != "R" ; If Append or Prepend
${If} $6 == 1 ; And if we found the target
DetailPrint "Target is already present in $1. It will be removed and"
${EndIf}
${If} $0 == "" ; If EnvVar is (now) empty
StrCpy $0 $4 ; just copy PathString to EnvVar
${If} $6 == 0 ; If found flag is either 0
${OrIf} $6 == "" ; or blank (if EnvVarName is empty)
DetailPrint "$1 was empty and has been updated with the target"
${EndIf}
${ElseIf} $2 == "A" ; If Append (and EnvVar is not empty),
StrCpy $0 $0;$4 ; append PathString
${If} $6 == 1
DetailPrint "appended to $1"
${Else}
DetailPrint "Target was appended to $1"
${EndIf}
${Else} ; If Prepend (and EnvVar is not empty),
StrCpy $0 $4;$0 ; prepend PathString
${If} $6 == 1
DetailPrint "prepended to $1"
${Else}
DetailPrint "Target was prepended to $1"
${EndIf}
${EndIf}
${Else} ; If Action = Remove
${If} $6 == 1 ; and we found the target
DetailPrint "Target was found and removed from $1"
${Else}
DetailPrint "Target was NOT found in $1 (nothing to remove)"
${EndIf}
${If} $0 == ""
DetailPrint "$1 is now empty"
${EndIf}
${EndIf}

; Step 5: Update the registry at RegLoc with the updated EnvVar and announce the change
;
ClearErrors
${If} $3 == HKLM
WriteRegExpandStr ${hklm_all_users} $1 $0 ; Write it in all users section
${ElseIf} $3 == HKCU
WriteRegExpandStr ${hkcu_current_user} $1 $0 ; Write it to current user section
IfErrors 0 +3
MessageBox MB_OK|MB_ICONEXCLAMATION "Could not write updated $1 to $3"
DetailPrint "Could not write updated $1 to $3"
IfErrors +2 0
SendMessage ${HWND_BROADCAST} ${WM_WININICHANGE} 0 "STR:Environment" /TIMEOUT=5000 ; "Export" our change
${EndIf}

EnvVarUpdate_Restore_Vars:
;
; Restore the user's variables and return ResultVar
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $3
Pop $2
Pop $1
Push $0 ; Push my $0 (ResultVar)
Exch
Pop $0 ; Restore his $0

FunctionEnd

!macroend ; EnvVarUpdate UN
!insertmacro EnvVarUpdate ""
!insertmacro EnvVarUpdate "un."
;----------------------------------- EnvVarUpdate end----------------------------------------

;-------------------------------------- StrTok start ------------------------------------------
; Written by Diego Pedroso (deguix)
;
!macro StrTok UN

Function ${UN}StrTok

/*After this point:
------------------------------------------
$0 = SkipEmptyParts (input)
$1 = ResultPart (input)
$2 = Separators (input)
$3 = String (input)
$4 = SeparatorsLen (temp)
$5 = StrLen (temp)
$6 = StartCharPos (temp)
$7 = TempStr (temp)
$8 = CurrentLoop
$9 = CurrentSepChar
$R0 = CurrentSepCharNum */

;Get input from user
Exch $0
Exch
Exch $1
Exch
Exch 2
Exch $2
Exch 2
Exch 3
Exch $3
Exch 3
Push $4
Push $5
Push $6
Push $7
Push $8
Push $9
Push $R0

;Parameter defaults
${IfThen} $2 == `` ${|} StrCpy $2 `|` ${|}
${IfThen} $1 == `` ${|} StrCpy $1 `L` ${|}
${IfThen} $0 == `` ${|} StrCpy $0 `0` ${|}

;Get "String" and "Separators" length
StrLen $4 $2
StrLen $5 $3
;Start "StartCharPos" and "ResultPart" counters
StrCpy $6 0
StrCpy $8 -1

;Loop until "ResultPart" is met, "Separators" is found or
;"String" reaches its end
ResultPartLoop: ;"CurrentLoop" Loop

;Increase "CurrentLoop" counter
IntOp $8 $8 + 1

StrSearchLoop:
${Do} ;"String" Loop
;Remove everything before and after the searched part ("TempStr")
StrCpy $7 $3 1 $6

;Verify if it's the "String" end
${If} $6 >= $5
;If "CurrentLoop" is what the user wants, remove the part
;after "TempStr" and itself and get out of here
${If} $8 == $1
${OrIf} $1 == `L`
StrCpy $3 $3 $6
${Else} ;If not, empty "String" and get out of here
StrCpy $3 ``
${EndIf}
StrCpy $R0 `End`
${ExitDo}
${EndIf}

;Start "CurrentSepCharNum" counter (for "Separators" Loop)
StrCpy $R0 0

${Do} ;"Separators" Loop
;Use one "Separators" character at a time
${If} $R0 <> 0
StrCpy $9 $2 1 $R0
${Else}
StrCpy $9 $2 1
${EndIf}

;Go to the next "String" char if it's "Separators" end
${IfThen} $R0 >= $4 ${|} ${ExitDo} ${|}

;Or, if "TempStr" equals "CurrentSepChar", then...
${If} $7 == $9
StrCpy $7 $3 $6

;If "String" is empty because this result part doesn't
;contain data, verify if "SkipEmptyParts" is activated,
;so we don't return the output to user yet

${If} $7 == ``
${AndIf} $0 = 1 ;${TRUE}
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto StrSearchLoop
${ElseIf} $8 == $1
StrCpy $3 $3 $6
StrCpy $R0 "End"
${ExitDo}
${EndIf} ;If not, go to the next result part
IntOp $6 $6 + 1
StrCpy $3 $3 `` $6
StrCpy $6 0
Goto ResultPartLoop
${EndIf}

;Increase "CurrentSepCharNum" counter
IntOp $R0 $R0 + 1
${Loop}
${IfThen} $R0 == "End" ${|} ${ExitDo} ${|}

;Increase "StartCharPos" counter
IntOp $6 $6 + 1
${Loop}

/*After this point:
------------------------------------------
$3 = ResultVar (output)*/

;Return output to user
Pop $R0
Pop $9
Pop $8
Pop $7
Pop $6
Pop $5
Pop $4
Pop $0
Pop $1
Pop $2
Exch $3
FunctionEnd

!macroend ; StrTok UN
!insertmacro StrTok ""
!insertmacro StrTok "un."

;----------------------------------------- StrTok end -------------------------------------------

;---------------------------------------- StrContains start -------------------------------------
; StrContains
; This function does a case sensitive searches for an occurrence of a substring in a string.
; It returns the substring if it is found; otherwise, it returns null("").
; Usage: ${StrContains} "$result_var" "Needle" "Haystack"
; Written by kenglish_hi
; Adapted from StrReplace written by dandaman32

Var STR_HAYSTACK
Var STR_NEEDLE
Var STR_CONTAINS_VAR_1
Var STR_CONTAINS_VAR_2
Var STR_CONTAINS_VAR_3
Var STR_CONTAINS_VAR_4
Var STR_RETURN_VAR

!macro StrContains UN

Function ${UN}StrContains

Exch $STR_NEEDLE
Exch
Exch $STR_HAYSTACK
; Uncomment to debug
;MessageBox MB_OK 'STR_NEEDLE = $STR_NEEDLE STR_HAYSTACK = $STR_HAYSTACK '
StrCpy $STR_RETURN_VAR ""
StrCpy $STR_CONTAINS_VAR_1 -1
StrLen $STR_CONTAINS_VAR_2 $STR_NEEDLE
StrLen $STR_CONTAINS_VAR_4 $STR_HAYSTACK
loop:
IntOp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_1 + 1
StrCpy $STR_CONTAINS_VAR_3 $STR_HAYSTACK $STR_CONTAINS_VAR_2 $STR_CONTAINS_VAR_1
StrCmp $STR_CONTAINS_VAR_3 $STR_NEEDLE found
StrCmp $STR_CONTAINS_VAR_1 $STR_CONTAINS_VAR_4 done
Goto loop
found:
StrCpy $STR_RETURN_VAR $STR_NEEDLE
Goto done
done:
Pop $STR_HAYSTACK ;Prevent "invalid opcode" errors and keep the stack intact
Exch $STR_RETURN_VAR
FunctionEnd

!macroend
!insertmacro StrContains ""
!insertmacro StrContains "un."
;--------------------------------------- StrContains end ---------------------------------------

;--------------------------------------- StrReplace start --------------------------------------
;================================================================================
; StrReplace
; Replaces all occurences of a given needle within a haystack with another string
; Usage: ${StrReplace} "$result_var" "SubString" "RepString" "String"
; Written by dandaman32
;================================================================================

Var STR_REPLACE_VAR_0
Var STR_REPLACE_VAR_1
Var STR_REPLACE_VAR_2
Var STR_REPLACE_VAR_3
Var STR_REPLACE_VAR_4
Var STR_REPLACE_VAR_5
Var STR_REPLACE_VAR_6
Var STR_REPLACE_VAR_7
Var STR_REPLACE_VAR_8

!macro StrReplace UN

Function ${UN}StrReplace

Exch $STR_REPLACE_VAR_2
Exch 1
Exch $STR_REPLACE_VAR_1
Exch 2
Exch $STR_REPLACE_VAR_0
StrCpy $STR_REPLACE_VAR_3 -1
StrLen $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_1
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
loop:
IntOp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_3 + 1
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_4 $STR_REPLACE_VAR_3
StrCmp $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_1 found
StrCmp $STR_REPLACE_VAR_3 $STR_REPLACE_VAR_6 done
Goto loop
found:
StrCpy $STR_REPLACE_VAR_5 $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_3
IntOp $STR_REPLACE_VAR_8 $STR_REPLACE_VAR_3 + $STR_REPLACE_VAR_4
StrCpy $STR_REPLACE_VAR_7 $STR_REPLACE_VAR_0 "" $STR_REPLACE_VAR_8
StrCpy $STR_REPLACE_VAR_0 $STR_REPLACE_VAR_5$STR_REPLACE_VAR_2$STR_REPLACE_VAR_7
StrLen $STR_REPLACE_VAR_6 $STR_REPLACE_VAR_0
Goto loop
done:
Pop $STR_REPLACE_VAR_1 ; Prevent "invalid opcode" errors and keep the
Pop $STR_REPLACE_VAR_1 ; stack as it was before the function was called
Exch $STR_REPLACE_VAR_0

FunctionEnd

!macroend ; StrContains UN
!insertmacro StrReplace ""
!insertmacro StrReplace "un."

;----------------------------------------- StrReplace end ---------------------------------------

!verbose pop
!endif
</highlight-nsis>

[[Category:Disk, Path & File Functions]]