NSIS: masalah dengan $ 0- $ 9, $ R0- $ R9

Tujuan artikel

Pengantar kecil

!define variable1 ''value 1''

• variabel statis lingkup global;
• Diinisialisasi setelah deklarasi;
• Metode Kontak: $ {variable1}

Var variable2

• Variabel dinamis lingkup global;
• Itu dinyatakan di mana saja dengan kode, tetapi di atas panggilan pertama;
• Ini diinisialisasi sebanyak yang diperlukan, tetapi hanya di dalam blok fungsi dan makro;
• Metode Akses: $ variabel2

Deskripsi masalah

Function F1
    StrCpy $0 "vladimir"
FunctionEnd

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

• Seseorang hanya dengan cermat mengamati semua variabel (orang-orang seperti itu perlu mendirikan sebuah monumen));
• Seseorang, terutama pencipta berbagai plug-in, setiap kali ingin menggunakan variabel apa pun yang disajikan, membuatnya Push ke stack, dan setelah akhir penggunaan mereka mengembalikan nilai primer dengan menelepon Pop;
• Dan seseorang menghasilkan variabel melalui Var, seperti dijelaskan di atas.

Solusi untuk masalah tersebut

!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. Fungsi F1 itu sendiri tidak disebut secara langsung,

   Call F1

   dan melalui pembungkus makro

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

2. Bahkan sebelum fungsi dipanggil langsung, itu akan dipanggil

   ${Dump}

   sebagai hasilnya, nilai saat ini dari variabel $ 0- $ 9, $ R0- $ R9 disimpan dalam Dump. Di bawah tenda ia memiliki banyak daftar, masing-masing terikat pada variabel targetnya;
3. Memuat pada stack semua variabel target untuk fungsi

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

   (jika diperlukan);
4. Fungsi akan dipanggil;
5. Fungsi akan menjalankan logikanya dan keluar;
6. Panggilan akan terjadi

   ${Undump}

   sebagai hasilnya, nilai-nilai variabel global yang disimpan pada panggilan terakhir $ {Dump} akan dikembalikan;
7. Membongkar hasil fungsi dari tumpukan

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

   (jika diperlukan);
8. Pembungkus makro pada fungsi F1 akan menyelesaikan pekerjaannya.

Kesimpulan