NSIS: $ 0- $ 9, $ R0- $ R9 के साथ समस्या

लेख का उद्देश्य

छोटा सा परिचय

!define variable1 ''value 1''

• वैश्विक दायरे का स्थिर चर;
• घोषणा पर प्रारंभिक;
• संपर्क विधि: $ {variable1}

Var variable2

• वैश्विक दायरे का गतिशील चर;
• यह कोड द्वारा कहीं भी घोषित किया जाता है, लेकिन पहली कॉल के ऊपर;
• इसे आवश्यक रूप से कई बार आरंभीकृत किया जाता है, लेकिन केवल फ़ंक्शन ब्लॉक और मैक्रोज़ के अंदर;
• पहुँच विधि: $ variable2

समस्या का विवरण

Function F1
    StrCpy $0 "vladimir"
FunctionEnd

Function F2
    StrCpy $0 "alexei"
    Call F1
    ${If} $0 == "alexei" ; //  $0  "vladimir"
        ; // -  ...
    ${EndIf}
FunctionEnd

• किसी ने बस सभी चर को ध्यान से देखा (ऐसे लोगों को एक स्मारक बनाने की आवश्यकता है);
• किसी ने, मुख्य रूप से विभिन्न प्लग-इन के रचनाकारों, प्रत्येक बार प्रस्तुत किए गए किसी भी चर का उपयोग करना चाहते हैं, इसे स्टैक पर पुश किया, और उपयोग के अंत के बाद वे पॉप कॉल करके प्राथमिक मूल्य लौटाते हैं;
• और किसी ने वर के माध्यम से चर का उत्पादन किया, जैसा कि ऊपर वर्णित है।

समस्या का समाधान

!verbose 3
!include NSISList.nsh	;      *

/*
  Dump, :

!define F1 "!insertmacro _F1"
!macro _F1 [paramIn1 paramIn2 ... paramInN] [paramOut1 paramOut1 ... paramOutM]
    ${Dump}
    [Push ${paramIn1}
	Push ${paramIn2}
	...
	Push ${paramInN}]
    !ifdef __UNINSTALL__
        Call un.F1
    !else
        Call F1
    !endif
    ${Undump}
    [Pop ${paramOut1}
	Pop ${paramOut2}
	...
	Pop ${paramOutM}]
!macroend

!macro Func_F1 un
    Function ${un}F1
        ;  ...
        ;         $0-$9, $R0-$R9.
        ;        .
    FunctionEnd
!macroend
!insertmacro Func_F1 ""
!insertmacro Func_F1 "un."

*/

/**   Dump */
!define InitDump "!insertmacro _InitDump"
!macro _InitDump
    !ifdef __UNINSTALL__
        Call un.InitDump
    !else
        Call InitDump
    !endif
!macroend

!macro Func_InitDump un
    Function ${un}InitDump
        #  $0-$9
        ${List.Create} d0
        ${List.Create} d1
        ${List.Create} d2
        ${List.Create} d3
        ${List.Create} d4
        ${List.Create} d5
        ${List.Create} d6
        ${List.Create} d7
        ${List.Create} d8
        ${List.Create} d9
        #  $R0-$R10
        ${List.Create} dR0
        ${List.Create} dR1
        ${List.Create} dR2
        ${List.Create} dR3
        ${List.Create} dR4
        ${List.Create} dR5
        ${List.Create} dR6
        ${List.Create} dR7
        ${List.Create} dR8
        ${List.Create} dR9
    FunctionEnd
!macroend
!insertmacro Func_InitDump ""
!insertmacro Func_InitDump "un."


/**     nsis-  Dump */
!define Dump "!insertmacro _Dump"
!macro _Dump
    !ifdef __UNINSTALL__
        Call un.Dump
    !else
        Call Dump
    !endif
!macroend

!macro Func_Dump un
    Function ${un}Dump
        # $0-$9
        ${List.Add} d0 $0
        ${List.Add} d1 $1
        ${List.Add} d2 $2
        ${List.Add} d3 $3
        ${List.Add} d4 $4
        ${List.Add} d5 $5
        ${List.Add} d6 $6
        ${List.Add} d7 $7
        ${List.Add} d8 $8
        ${List.Add} d9 $9
        # R0-R9
        ${List.Add} dR0 $R0
        ${List.Add} dR1 $R1
        ${List.Add} dR2 $R2
        ${List.Add} dR3 $R3
        ${List.Add} dR4 $R4
        ${List.Add} dR5 $R5
        ${List.Add} dR6 $R6
        ${List.Add} dR7 $R7
        ${List.Add} dR8 $R8
        ${List.Add} dR9 $R9
    FunctionEnd
!macroend
!insertmacro Func_Dump ""
!insertmacro Func_Dump "un."


/**     nsis-  Dump */
!define Undump "!insertmacro _Undump"
!macro _Undump
    !ifdef __UNINSTALL__
        Call un.Undump
    !else
        Call Undump
    !endif
!macroend

!macro Func_Undump un
    Function ${un}Undump
        # $0-$9
        ${List.Pop} $0 d0
        ${List.Pop} $1 d1
        ${List.Pop} $2 d2
        ${List.Pop} $3 d3
        ${List.Pop} $4 d4
        ${List.Pop} $5 d5
        ${List.Pop} $6 d6
        ${List.Pop} $7 d7
        ${List.Pop} $8 d8
        ${List.Pop} $9 d9
        # R0-R9
        ${List.Pop} $R0 dR0
        ${List.Pop} $R1 dR1
        ${List.Pop} $R2 dR2
        ${List.Pop} $R3 dR3
        ${List.Pop} $R4 dR4
        ${List.Pop} $R5 dR5
        ${List.Pop} $R6 dR6
        ${List.Pop} $R7 dR7
        ${List.Pop} $R8 dR8
        ${List.Pop} $R9 dR9
    FunctionEnd
!macroend
!insertmacro Func_Undump ""
!insertmacro Func_Undump "un."

1. एफ 1 फ़ंक्शन को सीधे नहीं कहा जाता है,

   Call F1

   और मैक्रो रैपर के माध्यम से

   ${F1} [paramIn1 [paramIn2]...[paramInN]] [paramOut1 [paramOut2]...[paramOutM]]

2. फ़ंक्शन को सीधे कॉल करने से पहले भी इसे कॉल किया जाएगा

   ${Dump}

   परिणामस्वरूप, डंप में चर $ 0- $ 9, $ R0- $ R9 के वर्तमान मूल्यों को बचाया जाता है। हुड के तहत उसके पास बहुत सारी सूचियां हैं, प्रत्येक को उसके लक्ष्य चर से बांधा गया है;
3. स्टैक पर लोड हो रहा है फ़ंक्शन के लिए सभी लक्ष्य चर

   Push ${paramIn1} Push ${paramIn2} ... Push ${paramInN}

   (यदि इसकी आवश्यकता है);
4. समारोह कहा जाएगा;
5. फ़ंक्शन अपने तर्क और निकास को निष्पादित करेगा;
6. पुकार होगी

   ${Undump}

   परिणामस्वरूप, $ {Dump} के अंतिम कॉल पर संग्रहीत वैश्विक चर के मूल्यों को बहाल किया जाएगा;
7. स्टैक से फ़ंक्शन परिणाम को लोड करना

   Pop ${paramOut1} Pop ${paramOut2} ... Pop ${paramOutM}

   (यदि इसकी आवश्यकता है);
8. एफ 1 फ़ंक्शन पर मैक्रो आवरण अपने काम को पूरा करेगा।

निष्कर्ष