tests/nsis3/share/nsis/Include/LogicLib.nsh
; NSIS LOGIC LIBRARY - LogicLib.nsh
; Version 2.6 - 08/12/2007
; By dselkirk@hotmail.com
; and eccles@users.sf.net
; with IfNot support added by Message
;
; Questions/Comments -
; See http://forums.winamp.com/showthread.php?s=&postid=1116241
;
; Description:
; Provides the use of various logic statements within NSIS.
;
; Usage:
; The following "statements" are available:
; If|IfNot|Unless..{ElseIf|ElseIfNot|ElseUnless}..[Else]..EndIf|EndUnless
; - Conditionally executes a block of statements, depending on the value
; of an expression. IfNot and Unless are equivalent and
; interchangeable, as are ElseIfNot and ElseUnless.
; AndIf|AndIfNot|AndUnless|OrIf|OrIfNot|OrUnless
; - Adds any number of extra conditions to If, IfNot, Unless, ElseIf,
; ElseIfNot and ElseUnless statements.
; IfThen|IfNotThen..|..|
; - Conditionally executes an inline statement, depending on the value
; of an expression.
; IfCmd..||..|
; - Conditionally executes an inline statement, depending on a true
; value of the provided NSIS function.
; Select..{Case[2|3|4|5]}..[CaseElse|Default]..EndSelect
; - Executes one of several blocks of statements, depending on the value
; of an expression.
; Switch..{Case|CaseElse|Default}..EndSwitch
; - Jumps to one of several labels, depending on the value of an
; expression.
; Do[While|Until]..{ExitDo|Continue|Break}..Loop[While|Until]
; - Repeats a block of statements until stopped, or depending on the
; value of an expression.
; While..{ExitWhile|Continue|Break}..EndWhile
; - An alias for DoWhile..Loop (for backwards-compatibility)
; For[Each]..{ExitFor|Continue|Break}..Next
; - Repeats a block of statements varying the value of a variable.
;
; The following "expressions" are available:
; Standard (built-in) string tests (which are case-insensitive):
; a == b; a != b
; Additional case-insensitive string tests (using System.dll):
; a S< b; a S>= b; a S> b; a S<= b
; Case-sensitive string tests:
; a S== b; a S!= b
; Standard (built-in) signed integer tests:
; a = b; a <> b; a < b; a >= b; a > b; a <= b; a & b
; Standard (built-in) unsigned integer tests:
; a U< b; a U>= b; a U> b; a U<= b
; 64-bit integer tests (using System.dll):
; a L= b; a L<> b; a L< b; a L>= b; a L> b; a L<= b
; ptrdiff_t integer tests
; a P= b; a P<> b; a P< b; a P>= b; a P> b; a P<= b
; size_t integer tests
; a Z= b; a Z<> b; a Z< b; a Z>= b; a Z> b; a Z<= b
; Built-in NSIS flag tests:
; ${Abort}; ${Errors}; ${RebootFlag}; ${Silent}
; Built-in NSIS other tests:
; ${FileExists} a
; Any conditional NSIS instruction test:
; ${Cmd} a
; Section flag tests:
; ${SectionIsSelected} a; ${SectionIsSectionGroup} a;
; ${SectionIsSectionGroupEnd} a; ${SectionIsBold} a;
; ${SectionIsReadOnly} a; ${SectionIsExpanded} a;
; ${SectionIsPartiallySelected} a
;
; Examples:
; See LogicLib.nsi in the Examples folder for lots of example usage.
!verbose push
!verbose 3
!ifndef LOGICLIB_VERBOSITY
!define LOGICLIB_VERBOSITY 3
!endif
!define _LOGICLIB_VERBOSITY ${LOGICLIB_VERBOSITY}
!undef LOGICLIB_VERBOSITY
!verbose ${_LOGICLIB_VERBOSITY}
!ifndef LOGICLIB
!define LOGICLIB
!define | "'"
!define || "' '"
!define LOGICLIB_COUNTER 0
!include Sections.nsh
!macro _LOGICLIB_TEMP
!ifndef _LOGICLIB_TEMP
!define _LOGICLIB_TEMP
Var /GLOBAL _LOGICLIB_TEMP ; Temporary variable to aid the more elaborate logic tests
!endif
!macroend
!macro LogicLib_JumpToBranch _Jump _Skip
StrCmp "" "" `${_Jump}` ${_Skip}
!macroend
!macro _IncreaseCounter
!define /redef /math LOGICLIB_COUNTER `${LOGICLIB_COUNTER}` + 1
!macroend
!macro _PushLogic
!insertmacro _PushScope Logic _LogicLib_Label_${LOGICLIB_COUNTER}
!insertmacro _IncreaseCounter
!macroend
!macro _PopLogic
!insertmacro _PopScope Logic
!macroend
!macro _PushScope Type label
!ifdef _${Type} ; If we already have a statement
!define _Cur${Type} ${_${Type}}
!undef _${Type}
!define _${Type} ${label}
!define ${_${Type}}Prev${Type} ${_Cur${Type}} ; Save the current logic
!undef _Cur${Type}
!else
!define _${Type} ${label} ; Initialise for first statement
!endif
!macroend
!macro _PopScope Type
!ifndef _${Type}
!error "Cannot use _Pop${Type} without a preceding _Push${Type}"
!endif
!ifdef ${_${Type}}Prev${Type} ; If a previous statement was active then restore it
!define _Cur${Type} ${_${Type}}
!undef _${Type}
!define _${Type} ${${_Cur${Type}}Prev${Type}}
!undef ${_Cur${Type}}Prev${Type}
!undef _Cur${Type}
!else
!undef _${Type}
!endif
!macroend
; String tests
!macro _== _a _b _t _f
StrCmp `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _!= _a _b _t _f
!insertmacro _== `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
; Case-sensitive string tests
!macro _S== _a _b _t _f
StrCmpS `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _S!= _a _b _t _f
!insertmacro _S== `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
; Extra string tests (cannot do these case-sensitively - I tried and lstrcmp still ignored the case)
!macro _StrCmpI _a _b _e _l _m
!insertmacro _LOGICLIB_TEMP
System::Call `kernel32::lstrcmpi(ts, ts) i.s` `${_a}` `${_b}`
Pop $_LOGICLIB_TEMP
IntCmp $_LOGICLIB_TEMP 0 `${_e}` `${_l}` `${_m}`
!macroend
!macro _S< _a _b _t _f
!insertmacro _StrCmpI `${_a}` `${_b}` `${_f}` `${_t}` `${_f}`
!macroend
!macro _S>= _a _b _t _f
!insertmacro _S< `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
!macro _S> _a _b _t _f
!insertmacro _StrCmpI `${_a}` `${_b}` `${_f}` `${_f}` `${_t}`
!macroend
!macro _S<= _a _b _t _f
!insertmacro _S> `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
; Integer tests
!macro _= _a _b _t _f
IntCmp `${_a}` `${_b}` `${_t}` `${_f}` `${_f}`
!macroend
!macro _<> _a _b _t _f
!insertmacro _= `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
!macro _< _a _b _t _f
IntCmp `${_a}` `${_b}` `${_f}` `${_t}` `${_f}`
!macroend
!macro _>= _a _b _t _f
!insertmacro _< `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
!macro _> _a _b _t _f
IntCmp `${_a}` `${_b}` `${_f}` `${_f}` `${_t}`
!macroend
!macro _<= _a _b _t _f
!insertmacro _> `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
!macro _& _a _b _t _f
!insertmacro _LOGICLIB_TEMP
IntOp $_LOGICLIB_TEMP `${_a}` & `${_b}`
!insertmacro _<> $_LOGICLIB_TEMP 0 `${_t}` `${_f}`
!macroend
; Unsigned integer tests (NB: no need for extra equality tests)
!macro _U< _a _b _t _f
IntCmpU `${_a}` `${_b}` `${_f}` `${_t}` `${_f}`
!macroend
!macro _U>= _a _b _t _f
!insertmacro _U< `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
!macro _U> _a _b _t _f
IntCmpU `${_a}` `${_b}` `${_f}` `${_f}` `${_t}`
!macroend
!macro _U<= _a _b _t _f
!insertmacro _U> `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
; Int64 tests
!macro _Int64Cmp _a _o _b _t _f
!insertmacro _LOGICLIB_TEMP
System::Int64Op `${_a}` `${_o}` `${_b}`
Pop $_LOGICLIB_TEMP
!insertmacro _= $_LOGICLIB_TEMP 0 `${_f}` `${_t}`
!macroend
!macro _L= _a _b _t _f
!insertmacro _Int64Cmp `${_a}` = `${_b}` `${_t}` `${_f}`
!macroend
!macro _L<> _a _b _t _f
!insertmacro _L= `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
!macro _L< _a _b _t _f
!insertmacro _Int64Cmp `${_a}` < `${_b}` `${_t}` `${_f}`
!macroend
!macro _L>= _a _b _t _f
!insertmacro _L< `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
!macro _L> _a _b _t _f
!insertmacro _Int64Cmp `${_a}` > `${_b}` `${_t}` `${_f}`
!macroend
!macro _L<= _a _b _t _f
!insertmacro _L> `${_a}` `${_b}` `${_f}` `${_t}`
!macroend
; ptrdiff_t & size_t tests
!macro LogicLib_PtrDiffTest _o _a _b _t _f
!if "${NSIS_PTR_SIZE}" <= 4
!insertmacro _${_o} `${_a}` `${_b}` `${_t}` `${_f}`
!else
!insertmacro _L${_o} `${_a}` `${_b}` `${_t}` `${_f}`
!endif
!macroend
!macro _P= _a _b _t _f
!insertmacro LogicLib_PtrDiffTest = `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _P<> _a _b _t _f
!insertmacro LogicLib_PtrDiffTest <> `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _P< _a _b _t _f
!insertmacro LogicLib_PtrDiffTest < `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _P>= _a _b _t _f
!insertmacro LogicLib_PtrDiffTest >= `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _P> _a _b _t _f
!insertmacro LogicLib_PtrDiffTest > `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _P<= _a _b _t _f
!insertmacro LogicLib_PtrDiffTest <= `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!include Util.nsh
!macro _Z= _a _b _t _f
!insertmacro LogicLib_PtrDiffTest = `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _Z<> _a _b _t _f
!insertmacro LogicLib_PtrDiffTest <> `${_a}` `${_b}` `${_t}` `${_f}`
!macroend
!macro _Z< _a _b _t _f
!insertmacro IntPtrCmpU `${_a}` `${_b}` `${_f}` `${_t}` `${_f}`
!macroend
!macro _Z>= _a _b _t _f
!insertmacro IntPtrCmpU `${_a}` `${_b}` `${_t}` `${_f}` `${_t}`
!macroend
!macro _Z> _a _b _t _f
!insertmacro IntPtrCmpU `${_a}` `${_b}` `${_f}` `${_f}` `${_t}`
!macroend
!macro _Z<= _a _b _t _f
!insertmacro IntPtrCmpU `${_a}` `${_b}` `${_t}` `${_t}` `${_f}`
!macroend
; Flag tests
!macro _Abort _a _b _t _f
IfAbort `${_t}` `${_f}`
!macroend
!define Abort `"" Abort ""`
!macro _Errors _a _b _t _f
IfErrors `${_t}` `${_f}`
!macroend
!define Errors `"" Errors ""`
!macro _FileExists _a _b _t _f
IfFileExists `${_b}` `${_t}` `${_f}`
!macroend
!define FileExists `"" FileExists`
!macro _RebootFlag _a _b _t _f
IfRebootFlag `${_t}` `${_f}`
!macroend
!define RebootFlag `"" RebootFlag ""`
!macro _Silent _a _b _t _f
IfSilent `${_t}` `${_f}`
!macroend
!define Silent `"" Silent ""`
; "Any instruction" test
!macro _Cmd _a _b _t _f
!define _t=${_t}
!ifdef _t= ; If no true label then make one
!define __t _LogicLib_Label_${LOGICLIB_COUNTER}
!insertmacro _IncreaseCounter
!else
!define __t ${_t}
!endif
${_b} ${__t}
!define _f=${_f}
!ifndef _f= ; If a false label then go there
Goto ${_f}
!endif
!undef _f=${_f}
!ifdef _t= ; If we made our own true label then place it
${__t}:
!endif
!undef __t
!undef _t=${_t}
!macroend
!define Cmd `"" Cmd`
; Section flag test
!macro _SectionFlagIsSet _a _b _t _f
!insertmacro _LOGICLIB_TEMP
SectionGetFlags `${_b}` $_LOGICLIB_TEMP
IntOp $_LOGICLIB_TEMP $_LOGICLIB_TEMP & `${_a}`
!insertmacro _= $_LOGICLIB_TEMP `${_a}` `${_t}` `${_f}`
!macroend
!define SectionIsSelected `${SF_SELECTED} SectionFlagIsSet`
!define SectionIsSubSection `${SF_SUBSEC} SectionFlagIsSet`
!define SectionIsSubSectionEnd `${SF_SUBSECEND} SectionFlagIsSet`
!define SectionIsSectionGroup `${SF_SECGRP} SectionFlagIsSet`
!define SectionIsSectionGroupEnd `${SF_SECGRPEND} SectionFlagIsSet`
!define SectionIsBold `${SF_BOLD} SectionFlagIsSet`
!define SectionIsReadOnly `${SF_RO} SectionFlagIsSet`
!define SectionIsExpanded `${SF_EXPAND} SectionFlagIsSet`
!define SectionIsPartiallySelected `${SF_PSELECTED} SectionFlagIsSet`
!define IfCmd `!insertmacro _IfThen "" Cmd ${|}`
!macro _If _c _a _o _b
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!insertmacro _PushLogic
!define ${_Logic}If
!define ${_Logic}Else _LogicLib_ElseLabel_${LOGICLIB_COUNTER} ; Get a label for the Else
!insertmacro _IncreaseCounter
!define _c=${_c}
!ifdef _c=true ; If is true
!insertmacro _${_o} `${_a}` `${_b}` "" ${${_Logic}Else}
!else ; If condition is false
!insertmacro _${_o} `${_a}` `${_b}` ${${_Logic}Else} ""
!endif
!undef _c=${_c}
!verbose pop
!macroend
!define If `!insertmacro _If true`
!define Unless `!insertmacro _If false`
!define IfNot `!insertmacro _If false`
!macro _And _c _a _o _b
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}If
!error "Cannot use And without a preceding If or IfNot/Unless"
!endif
!ifndef ${_Logic}Else
!error "Cannot use And following an Else"
!endif
!define _c=${_c}
!ifdef _c=true ; If is true
!insertmacro _${_o} `${_a}` `${_b}` "" ${${_Logic}Else}
!else ; If condition is false
!insertmacro _${_o} `${_a}` `${_b}` ${${_Logic}Else} ""
!endif
!undef _c=${_c}
!verbose pop
!macroend
!define AndIf `!insertmacro _And true`
!define AndUnless `!insertmacro _And false`
!define AndIfNot `!insertmacro _And false`
!macro _Or _c _a _o _b
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}If
!error "Cannot use Or without a preceding If or IfNot/Unless"
!endif
!ifndef ${_Logic}Else
!error "Cannot use Or following an Else"
!endif
!define _label _LogicLib_Label_${LOGICLIB_COUNTER} ; Skip this test as we already
!insertmacro _IncreaseCounter
Goto ${_label} ; have a successful result
${${_Logic}Else}: ; Place the Else label
!undef ${_Logic}Else ; and remove it
!define ${_Logic}Else _LogicLib_ElseLabel_${LOGICLIB_COUNTER} ; Get a label for the next Else and perform the new If
!insertmacro _IncreaseCounter
!define _c=${_c}
!ifdef _c=true ; If is true
!insertmacro _${_o} `${_a}` `${_b}` "" ${${_Logic}Else}
!else ; If condition is false
!insertmacro _${_o} `${_a}` `${_b}` ${${_Logic}Else} ""
!endif
!undef _c=${_c}
${_label}:
!undef _label
!verbose pop
!macroend
!define OrIf `!insertmacro _Or true`
!define OrUnless `!insertmacro _Or false`
!define OrIfNot `!insertmacro _Or false`
!macro _Else
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}If
!error "Cannot use Else without a preceding If or IfNot/Unless"
!endif
!ifndef ${_Logic}Else
!error "Cannot use Else following an Else"
!endif
!ifndef ${_Logic}EndIf ; First Else for this If?
!define ${_Logic}EndIf _LogicLib_EndIfLabel_${LOGICLIB_COUNTER} ; Get a label for the EndIf
!insertmacro _IncreaseCounter
!endif
Goto ${${_Logic}EndIf} ; Go to the EndIf
${${_Logic}Else}: ; Place the Else label
!undef ${_Logic}Else ; and remove it
!verbose pop
!macroend
!define Else `!insertmacro _Else`
!macro _ElseIf _c _a _o _b
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${Else} ; Perform the Else
!define ${_Logic}Else _LogicLib_ElseLabel_${LOGICLIB_COUNTER} ; Get a label for the next Else and perform the new If
!insertmacro _IncreaseCounter
!define _c=${_c}
!ifdef _c=true ; If is true
!insertmacro _${_o} `${_a}` `${_b}` "" ${${_Logic}Else}
!else ; If condition is false
!insertmacro _${_o} `${_a}` `${_b}` ${${_Logic}Else} ""
!endif
!undef _c=${_c}
!verbose pop
!macroend
!define ElseIf `!insertmacro _ElseIf true`
!define ElseUnless `!insertmacro _ElseIf false`
!define ElseIfNot `!insertmacro _ElseIf false`
!macro _EndIf _n
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}If
!error "Cannot use End${_n} without a preceding If or IfNot/Unless"
!endif
!ifdef ${_Logic}Else
${${_Logic}Else}: ; Place the Else label
!undef ${_Logic}Else ; and remove it
!endif
!ifdef ${_Logic}EndIf
${${_Logic}EndIf}: ; Place the EndIf
!undef ${_Logic}EndIf ; and remove it
!endif
!undef ${_Logic}If
!insertmacro _PopLogic
!verbose pop
!macroend
!define EndIf `!insertmacro _EndIf If`
!define EndUnless `!insertmacro _EndIf Unless`
!macro _IfThen _a _o _b _t
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${If} `${_a}` `${_o}` `${_b}`
${_t}
${EndIf}
!verbose pop
!macroend
!define IfThen `!insertmacro _IfThen`
!macro _IfNotThen _a _o _b _t
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${IfNot} `${_a}` `${_o}` `${_b}`
${_t}
${EndIf}
!verbose pop
!macroend
!define IfNotThen `!insertmacro _IfNotThen`
!macro _ForEach _v _f _t _o _s
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
StrCpy "${_v}" "${_f}" ; Assign the initial value
Goto +2 ; Skip the loop expression for the first iteration
!define _DoLoopExpression `IntOp "${_v}" "${_v}" "${_o}" "${_s}"` ; Define the loop expression
!define _o=${_o}
!ifdef _o=+ ; Check the loop expression operator
!define __o > ; to determine the correct loop condition
!else ifdef _o=-
!define __o <
!else
!error "Unsupported ForEach step operator (must be + or -)"
!endif
!undef _o=${_o}
!insertmacro _Do For false `${_v}` `${__o}` `${_t}` ; Let Do do the rest
!undef __o
!verbose pop
!macroend
!define ForEach `!insertmacro _ForEach`
!macro _For _v _f _t
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${ForEach} `${_v}` `${_f}` `${_t}` + 1 ; Pass on to ForEach
!verbose pop
!macroend
!define For `!insertmacro _For`
!define ExitFor `!insertmacro _Goto ExitFor For`
!define Next `!insertmacro _Loop For Next "" "" "" ""`
!define While `!insertmacro _Do While true`
!define ExitWhile `!insertmacro _Goto ExitWhile While`
!define EndWhile `!insertmacro _Loop While EndWhile "" "" "" ""`
!macro _Do _n _c _a _o _b
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!insertmacro _PushLogic
!define ${_Logic}${_n} _LogicLib_Label_${LOGICLIB_COUNTER} ; Get a label for the start of the loop
!insertmacro _IncreaseCounter
${${_Logic}${_n}}:
!insertmacro _PushScope Exit${_n} _LogicLib_Label_${LOGICLIB_COUNTER} ; Get a label for the end of the loop
!insertmacro _IncreaseCounter
!insertmacro _PushScope Break ${_Exit${_n}} ; Break goes to the end of the loop
!ifdef _DoLoopExpression
${_DoLoopExpression} ; Special extra parameter for inserting code
!undef _DoLoopExpression ; between the Continue label and the loop condition
!endif
!define _c=${_c}
!ifdef _c= ; No starting condition
!insertmacro _PushScope Continue _LogicLib_Label_${LOGICLIB_COUNTER} ; Get a label for Continue at the end of the loop
!insertmacro _IncreaseCounter
!else
!insertmacro _PushScope Continue ${${_Logic}${_n}} ; Continue goes to the start of the loop
!ifdef _c=true ; If is true
!insertmacro _${_o} `${_a}` `${_b}` "" ${_Exit${_n}}
!else ; If condition is false
!insertmacro _${_o} `${_a}` `${_b}` ${_Exit${_n}} ""
!endif
!endif
!undef _c=${_c}
!define ${_Logic}Condition ${_c} ; Remember the condition used
!verbose pop
!macroend
!define Do `!insertmacro _Do Do "" "" "" ""`
!define DoWhile `!insertmacro _Do Do true`
!define DoUntil `!insertmacro _Do Do false`
!macro _Goto _n _s
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _${_n}
!error "Cannot use ${_n} without a preceding ${_s}"
!endif
Goto ${_${_n}}
!verbose pop
!macroend
!define ExitDo `!insertmacro _Goto ExitDo Do`
!macro _Loop _n _e _c _a _o _b
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}${_n}
!error "Cannot use ${_e} without a preceding ${_n}"
!endif
!define _c=${${_Logic}Condition}
!ifdef _c= ; If Do had no condition place the Continue label
${_Continue}:
!endif
!undef _c=${${_Logic}Condition}
!define _c=${_c}
!ifdef _c= ; No ending condition
Goto ${${_Logic}${_n}}
!else ifdef _c=true ; If condition is true
!insertmacro _${_o} `${_a}` `${_b}` ${${_Logic}${_n}} ${_Exit${_n}}
!else ; If condition is false
!insertmacro _${_o} `${_a}` `${_b}` ${_Exit${_n}} ${${_Logic}${_n}}
!endif
!undef _c=${_c}
Goto ${_Continue} ; Just to ensure it is referenced at least once
Goto ${_Exit${_n}} ; Just to ensure it is referenced at least once
${_Exit${_n}}: ; Place the loop exit point
!undef ${_Logic}Condition
!insertmacro _PopScope Continue
!insertmacro _PopScope Break
!insertmacro _PopScope Exit${_n}
!undef ${_Logic}${_n}
!insertmacro _PopLogic
!verbose pop
!macroend
!define Loop `!insertmacro _Loop Do Loop "" "" "" ""`
!define LoopWhile `!insertmacro _Loop Do LoopWhile true`
!define LoopUntil `!insertmacro _Loop Do LoopUntil false`
!define Continue `!insertmacro _Goto Continue "For or Do or While"`
!define Break `!insertmacro _Goto Break "For or Do or While"`
!macro _Select _a
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!insertmacro _PushLogic
!define ${_Logic}Select `${_a}` ; Remember the left hand side of the comparison
!verbose pop
!macroend
!define Select `!insertmacro _Select`
!macro _Select_CaseElse
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}Select
!error "Cannot use Case without a preceding Select"
!endif
!ifdef ${_Logic}EndSelect ; This is set only after the first case
!ifndef ${_Logic}Else
!error "Cannot use Case following a CaseElse"
!endif
Goto ${${_Logic}EndSelect} ; Go to EndSelect (Ends the previous Case)
!define /IfNDef _LogicLib_EndSelectLabelUsed_${_Logic}
${${_Logic}Else}: ; Place the Else label
!undef ${_Logic}Else ; and remove it
!else
!define ${_Logic}EndSelect _LogicLib_EndSelectLabel_${LOGICLIB_COUNTER} ; Get a label for the EndSelect
!insertmacro _IncreaseCounter
!endif
!verbose pop
!macroend
!define CaseElse `!insertmacro _CaseElse`
!define Case_Else `!insertmacro _CaseElse` ; Compatibility with 2.2 and earlier
!define Default `!insertmacro _CaseElse` ; For the C-minded
!macro _Select_Case _a
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${CaseElse} ; Perform the CaseElse
!define ${_Logic}Else _LogicLib_NextSelectCaseLabel_${LOGICLIB_COUNTER} ; Get a label for the next Else and perform the new Case
!insertmacro _IncreaseCounter
!insertmacro _== `${${_Logic}Select}` `${_a}` "" ${${_Logic}Else}
!verbose pop
!macroend
!define Case `!insertmacro _Case`
!macro _Case2 _a _b
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${CaseElse} ; Perform the CaseElse
!define ${_Logic}Else _LogicLib_NextSelectCaseLabel_${LOGICLIB_COUNTER} ; Get a label for the next Else and perform the new Case
!insertmacro _IncreaseCounter
!insertmacro _== `${${_Logic}Select}` `${_a}` +2 ""
!insertmacro _== `${${_Logic}Select}` `${_b}` "" ${${_Logic}Else}
!verbose pop
!macroend
!define Case2 `!insertmacro _Case2`
!macro _Case3 _a _b _c
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${CaseElse} ; Perform the CaseElse
!define ${_Logic}Else _LogicLib_NextSelectCaseLabel_${LOGICLIB_COUNTER} ; Get a label for the next Else and perform the new Case
!insertmacro _IncreaseCounter
!insertmacro _== `${${_Logic}Select}` `${_a}` +3 ""
!insertmacro _== `${${_Logic}Select}` `${_b}` +2 ""
!insertmacro _== `${${_Logic}Select}` `${_c}` "" ${${_Logic}Else}
!verbose pop
!macroend
!define Case3 `!insertmacro _Case3`
!macro _Case4 _a _b _c _d
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${CaseElse} ; Perform the CaseElse
!define ${_Logic}Else _LogicLib_NextSelectCaseLabel_${LOGICLIB_COUNTER} ; Get a label for the next Else and perform the new Case
!insertmacro _IncreaseCounter
!insertmacro _== `${${_Logic}Select}` `${_a}` +4 ""
!insertmacro _== `${${_Logic}Select}` `${_b}` +3 ""
!insertmacro _== `${${_Logic}Select}` `${_c}` +2 ""
!insertmacro _== `${${_Logic}Select}` `${_d}` "" ${${_Logic}Else}
!verbose pop
!macroend
!define Case4 `!insertmacro _Case4`
!macro _Case5 _a _b _c _d _e
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
${CaseElse} ; Perform the CaseElse
!define ${_Logic}Else _LogicLib_NextSelectCaseLabel_${LOGICLIB_COUNTER} ; Get a label for the next Else and perform the new Case
!insertmacro _IncreaseCounter
!insertmacro _== `${${_Logic}Select}` `${_a}` +5 ""
!insertmacro _== `${${_Logic}Select}` `${_b}` +4 ""
!insertmacro _== `${${_Logic}Select}` `${_c}` +3 ""
!insertmacro _== `${${_Logic}Select}` `${_d}` +2 ""
!insertmacro _== `${${_Logic}Select}` `${_e}` "" ${${_Logic}Else}
!verbose pop
!macroend
!define Case5 `!insertmacro _Case5`
!macro _EndSelect
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}Select
!error "Cannot use EndSelect without a preceding Select"
!endif
!ifdef ${_Logic}Else
${${_Logic}Else}: ; Place the Else label
!undef ${_Logic}Else ; and remove it
!endif
!ifdef ${_Logic}EndSelect ; This won't be set if there weren't any cases
!ifdef _LogicLib_EndSelectLabelUsed_${_Logic} ; There is no jump to ${${_Logic}EndSelect}: if there is only one Case
${${_Logic}EndSelect}: ; Place the EndSelect
!undef _LogicLib_EndSelectLabelUsed_${_Logic}
!endif
!undef ${_Logic}EndSelect ; and remove it
!endif
!undef ${_Logic}Select
!insertmacro _PopLogic
!verbose pop
!macroend
!define EndSelect `!insertmacro _EndSelect`
!macro _Switch _a
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!insertmacro _PushLogic
!insertmacro _PushScope Switch ${_Logic} ; Keep a separate stack for switch data
!insertmacro _PushScope Break _LogicLib_Label_${LOGICLIB_COUNTER} ; Get a label for beyond the end of the switch
!insertmacro _IncreaseCounter
!define ${_Switch}Var `${_a}` ; Remember the left hand side of the comparison
!tempfile ${_Switch}Tmp ; Create a temporary file
!define ${_Logic}Switch _LogicLib_Label_${LOGICLIB_COUNTER} ; Get a label for the end of the switch
!insertmacro _IncreaseCounter
Goto ${${_Logic}Switch} ; and go there
!verbose pop
!macroend
!define Switch `!insertmacro _Switch`
!macro _Case _a
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifdef _Logic & ${_Logic}Select ; Check for an active Select
!insertmacro _Select_Case `${_a}`
!else ifndef _Switch ; If not then check for an active Switch
!error "Cannot use Case without a preceding Select or Switch"
!else
!define _label _LogicLib_Label_${LOGICLIB_COUNTER} ; Get a label for this case,
!insertmacro _IncreaseCounter
${_label}: ; place it and add it's check to the temp file
!appendfile "${${_Switch}Tmp}" `!insertmacro _== $\`${${_Switch}Var}$\` $\`${_a}$\` ${_label} ""$\n`
!undef _label
!endif
!verbose pop
!macroend
!macro _CaseElse
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifdef _Logic & ${_Logic}Select ; Check for an active Select
!insertmacro _Select_CaseElse
!else ifndef _Switch ; If not then check for an active Switch
!error "Cannot use Case without a preceding Select or Switch"
!else ifdef ${_Switch}Else ; Already had a default case?
!error "Cannot use CaseElse following a CaseElse"
!else
!define ${_Switch}Else _LogicLib_Label_${LOGICLIB_COUNTER} ; Get a label for the default case,
!insertmacro _IncreaseCounter
${${_Switch}Else}: ; and place it
!endif
!verbose pop
!macroend
!macro _EndSwitch
!verbose push
!verbose ${LOGICLIB_VERBOSITY}
!ifndef _Logic | ${_Logic}Switch
!error "Cannot use EndSwitch without a preceding Switch"
!endif
Goto ${_Break} ; Skip the jump table
${${_Logic}Switch}: ; Place the end of the switch
!undef ${_Logic}Switch
!include "${${_Switch}Tmp}" ; Include the jump table
!delfile "${${_Switch}Tmp}" ; and clear it up
!ifdef ${_Switch}Else ; Was there a default case?
Goto ${${_Switch}Else} ; then go there if all else fails
!undef ${_Switch}Else
!endif
!undef ${_Switch}Tmp
!undef ${_Switch}Var
${_Break}: ; Place the break label
!insertmacro _PopScope Break
!insertmacro _PopScope Switch
!insertmacro _PopLogic
!verbose pop
!macroend
!define EndSwitch `!insertmacro _EndSwitch`
!endif ; LOGICLIB
!verbose 3
!define LOGICLIB_VERBOSITY ${_LOGICLIB_VERBOSITY}
!undef _LOGICLIB_VERBOSITY
!verbose pop