Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 1 | " Test the :disassemble command, and compilation as a side effect |
| 2 | |
Bram Moolenaar | f51cb4e | 2020-03-01 17:55:14 +0100 | [diff] [blame] | 3 | source check.vim |
Bram Moolenaar | 06b7722 | 2022-01-25 15:51:56 +0000 | [diff] [blame] | 4 | source vim9.vim |
Bram Moolenaar | f51cb4e | 2020-03-01 17:55:14 +0100 | [diff] [blame] | 5 | |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 6 | func NotCompiled() |
| 7 | echo "not" |
| 8 | endfunc |
| 9 | |
| 10 | let s:scriptvar = 4 |
| 11 | let g:globalvar = 'g' |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 12 | let b:buffervar = 'b' |
| 13 | let w:windowvar = 'w' |
| 14 | let t:tabpagevar = 't' |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 15 | |
| 16 | def s:ScriptFuncLoad(arg: string) |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 17 | var local = 1 |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 18 | buffers |
Bram Moolenaar | e498429 | 2020-12-13 14:19:25 +0100 | [diff] [blame] | 19 | echo |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 20 | echo arg |
| 21 | echo local |
Bram Moolenaar | 8a1c101 | 2020-05-07 14:07:25 +0200 | [diff] [blame] | 22 | echo &lines |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 23 | echo v:version |
| 24 | echo s:scriptvar |
| 25 | echo g:globalvar |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 26 | echo get(g:, "global") |
Bram Moolenaar | 03290b8 | 2020-12-19 16:30:44 +0100 | [diff] [blame] | 27 | echo g:auto#var |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 28 | echo b:buffervar |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 29 | echo get(b:, "buffer") |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 30 | echo w:windowvar |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 31 | echo get(w:, "window") |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 32 | echo t:tabpagevar |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 33 | echo get(t:, "tab") |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 34 | echo &tabstop |
| 35 | echo $ENVVAR |
| 36 | echo @z |
| 37 | enddef |
| 38 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 39 | def Test_disassemble_load() |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 40 | assert_fails('disass NoFunc', 'E1061:') |
Bram Moolenaar | 451c2e3 | 2020-08-15 16:33:28 +0200 | [diff] [blame] | 41 | assert_fails('disass NotCompiled', 'E1091:') |
Bram Moolenaar | 21456cd | 2020-02-13 21:29:32 +0100 | [diff] [blame] | 42 | assert_fails('disass', 'E471:') |
| 43 | assert_fails('disass [', 'E475:') |
Bram Moolenaar | 9b7bf9e | 2020-07-11 22:14:59 +0200 | [diff] [blame] | 44 | assert_fails('disass 234', 'E129:') |
| 45 | assert_fails('disass <XX>foo', 'E129:') |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 46 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 47 | var res = execute('disass s:ScriptFuncLoad') |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 48 | assert_match('<SNR>\d*_ScriptFuncLoad.*' .. |
Bram Moolenaar | e498429 | 2020-12-13 14:19:25 +0100 | [diff] [blame] | 49 | 'buffers\_s*' .. |
| 50 | '\d\+ EXEC \+buffers\_s*' .. |
| 51 | 'echo\_s*' .. |
| 52 | 'echo arg\_s*' .. |
| 53 | '\d\+ LOAD arg\[-1\]\_s*' .. |
| 54 | '\d\+ ECHO 1\_s*' .. |
| 55 | 'echo local\_s*' .. |
| 56 | '\d\+ LOAD $0\_s*' .. |
| 57 | '\d\+ ECHO 1\_s*' .. |
| 58 | 'echo &lines\_s*' .. |
| 59 | '\d\+ LOADOPT &lines\_s*' .. |
| 60 | '\d\+ ECHO 1\_s*' .. |
| 61 | 'echo v:version\_s*' .. |
| 62 | '\d\+ LOADV v:version\_s*' .. |
| 63 | '\d\+ ECHO 1\_s*' .. |
| 64 | 'echo s:scriptvar\_s*' .. |
| 65 | '\d\+ LOADS s:scriptvar from .*test_vim9_disassemble.vim\_s*' .. |
| 66 | '\d\+ ECHO 1\_s*' .. |
| 67 | 'echo g:globalvar\_s*' .. |
| 68 | '\d\+ LOADG g:globalvar\_s*' .. |
| 69 | '\d\+ ECHO 1\_s*' .. |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 70 | 'echo get(g:, "global")\_s*' .. |
| 71 | '\d\+ LOAD g:\_s*' .. |
| 72 | '\d\+ PUSHS "global"\_s*' .. |
Bram Moolenaar | 03290b8 | 2020-12-19 16:30:44 +0100 | [diff] [blame] | 73 | '\d\+ BCALL get(argc 2)\_s*' .. |
| 74 | '\d\+ ECHO 1\_s*' .. |
| 75 | 'echo g:auto#var\_s*' .. |
| 76 | '\d\+ LOADAUTO g:auto#var\_s*' .. |
| 77 | '\d\+ ECHO 1\_s*' .. |
| 78 | 'echo b:buffervar\_s*' .. |
| 79 | '\d\+ LOADB b:buffervar\_s*' .. |
| 80 | '\d\+ ECHO 1\_s*' .. |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 81 | 'echo get(b:, "buffer")\_s*' .. |
| 82 | '\d\+ LOAD b:\_s*' .. |
| 83 | '\d\+ PUSHS "buffer"\_s*' .. |
| 84 | '\d\+ BCALL get(argc 2).*' .. |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 85 | ' LOADW w:windowvar.*' .. |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 86 | 'echo get(w:, "window")\_s*' .. |
| 87 | '\d\+ LOAD w:\_s*' .. |
| 88 | '\d\+ PUSHS "window"\_s*' .. |
| 89 | '\d\+ BCALL get(argc 2).*' .. |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 90 | ' LOADT t:tabpagevar.*' .. |
Bram Moolenaar | 2f8ce0a | 2020-07-19 19:47:35 +0200 | [diff] [blame] | 91 | 'echo get(t:, "tab")\_s*' .. |
| 92 | '\d\+ LOAD t:\_s*' .. |
| 93 | '\d\+ PUSHS "tab"\_s*' .. |
| 94 | '\d\+ BCALL get(argc 2).*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 95 | ' LOADENV $ENVVAR.*' .. |
| 96 | ' LOADREG @z.*', |
| 97 | res) |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 98 | enddef |
| 99 | |
Bram Moolenaar | cfe435d | 2020-04-25 20:02:55 +0200 | [diff] [blame] | 100 | def s:EditExpand() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 101 | var filename = "file" |
| 102 | var filenr = 123 |
Bram Moolenaar | cfe435d | 2020-04-25 20:02:55 +0200 | [diff] [blame] | 103 | edit the`=filename``=filenr`.txt |
| 104 | enddef |
| 105 | |
| 106 | def Test_disassemble_exec_expr() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 107 | var res = execute('disass s:EditExpand') |
Bram Moolenaar | 7c5ad34 | 2020-08-12 15:48:55 +0200 | [diff] [blame] | 108 | assert_match('<SNR>\d*_EditExpand\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 109 | ' var filename = "file"\_s*' .. |
Bram Moolenaar | 7c5ad34 | 2020-08-12 15:48:55 +0200 | [diff] [blame] | 110 | '\d PUSHS "file"\_s*' .. |
| 111 | '\d STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 112 | ' var filenr = 123\_s*' .. |
Bram Moolenaar | 7c5ad34 | 2020-08-12 15:48:55 +0200 | [diff] [blame] | 113 | '\d STORE 123 in $1\_s*' .. |
| 114 | ' edit the`=filename``=filenr`.txt\_s*' .. |
| 115 | '\d PUSHS "edit the"\_s*' .. |
| 116 | '\d LOAD $0\_s*' .. |
| 117 | '\d LOAD $1\_s*' .. |
| 118 | '\d 2STRING stack\[-1\]\_s*' .. |
| 119 | '\d\+ PUSHS ".txt"\_s*' .. |
| 120 | '\d\+ EXECCONCAT 4\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 121 | '\d\+ RETURN void', |
Bram Moolenaar | 7c5ad34 | 2020-08-12 15:48:55 +0200 | [diff] [blame] | 122 | res) |
| 123 | enddef |
| 124 | |
Bram Moolenaar | 2067733 | 2021-06-06 17:02:53 +0200 | [diff] [blame] | 125 | if has('python3') |
| 126 | def s:PyHeredoc() |
| 127 | python3 << EOF |
| 128 | print('hello') |
| 129 | EOF |
| 130 | enddef |
| 131 | |
| 132 | def Test_disassemble_python_heredoc() |
| 133 | var res = execute('disass s:PyHeredoc') |
| 134 | assert_match('<SNR>\d*_PyHeredoc.*' .. |
| 135 | " python3 << EOF^@ print('hello')^@EOF\\_s*" .. |
| 136 | '\d EXEC_SPLIT python3 << EOF^@ print(''hello'')^@EOF\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 137 | '\d RETURN void', |
Bram Moolenaar | 2067733 | 2021-06-06 17:02:53 +0200 | [diff] [blame] | 138 | res) |
| 139 | enddef |
| 140 | endif |
| 141 | |
Bram Moolenaar | 4c13721 | 2021-04-19 16:48:48 +0200 | [diff] [blame] | 142 | def s:Substitute() |
| 143 | var expr = "abc" |
| 144 | :%s/a/\=expr/&g#c |
| 145 | enddef |
| 146 | |
| 147 | def Test_disassemble_substitute() |
| 148 | var res = execute('disass s:Substitute') |
| 149 | assert_match('<SNR>\d*_Substitute.*' .. |
| 150 | ' var expr = "abc"\_s*' .. |
| 151 | '\d PUSHS "abc"\_s*' .. |
| 152 | '\d STORE $0\_s*' .. |
| 153 | ' :%s/a/\\=expr/&g#c\_s*' .. |
| 154 | '\d SUBSTITUTE :%s/a/\\=expr/&g#c\_s*' .. |
| 155 | ' 0 LOAD $0\_s*' .. |
| 156 | ' -------------\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 157 | '\d RETURN void', |
Bram Moolenaar | 4c13721 | 2021-04-19 16:48:48 +0200 | [diff] [blame] | 158 | res) |
| 159 | enddef |
| 160 | |
Bram Moolenaar | f18332f | 2021-05-07 17:55:55 +0200 | [diff] [blame] | 161 | |
| 162 | def s:SearchPair() |
| 163 | var col = 8 |
| 164 | searchpair("{", "", "}", "", "col('.') > col") |
| 165 | enddef |
| 166 | |
| 167 | def Test_disassemble_seachpair() |
| 168 | var res = execute('disass s:SearchPair') |
| 169 | assert_match('<SNR>\d*_SearchPair.*' .. |
| 170 | ' var col = 8\_s*' .. |
| 171 | '\d STORE 8 in $0\_s*' .. |
| 172 | ' searchpair("{", "", "}", "", "col(''.'') > col")\_s*' .. |
| 173 | '\d PUSHS "{"\_s*' .. |
| 174 | '\d PUSHS ""\_s*' .. |
| 175 | '\d PUSHS "}"\_s*' .. |
| 176 | '\d PUSHS ""\_s*' .. |
| 177 | '\d INSTR\_s*' .. |
| 178 | ' 0 PUSHS "."\_s*' .. |
| 179 | ' 1 BCALL col(argc 1)\_s*' .. |
| 180 | ' 2 LOAD $0\_s*' .. |
| 181 | ' 3 COMPARENR >\_s*' .. |
| 182 | ' -------------\_s*' .. |
| 183 | '\d BCALL searchpair(argc 5)\_s*' .. |
| 184 | '\d DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 185 | '\d RETURN void', |
Bram Moolenaar | f18332f | 2021-05-07 17:55:55 +0200 | [diff] [blame] | 186 | res) |
| 187 | enddef |
| 188 | |
| 189 | |
Bram Moolenaar | 2d1c57e | 2021-04-19 20:50:03 +0200 | [diff] [blame] | 190 | def s:RedirVar() |
| 191 | var result: string |
| 192 | redir =>> result |
| 193 | echo "text" |
| 194 | redir END |
| 195 | enddef |
| 196 | |
| 197 | def Test_disassemble_redir_var() |
| 198 | var res = execute('disass s:RedirVar') |
| 199 | assert_match('<SNR>\d*_RedirVar.*' .. |
| 200 | ' var result: string\_s*' .. |
| 201 | '\d PUSHS "\[NULL\]"\_s*' .. |
| 202 | '\d STORE $0\_s*' .. |
| 203 | ' redir =>> result\_s*' .. |
| 204 | '\d REDIR\_s*' .. |
| 205 | ' echo "text"\_s*' .. |
| 206 | '\d PUSHS "text"\_s*' .. |
| 207 | '\d ECHO 1\_s*' .. |
| 208 | ' redir END\_s*' .. |
| 209 | '\d LOAD $0\_s*' .. |
| 210 | '\d REDIR END\_s*' .. |
| 211 | '\d CONCAT\_s*' .. |
| 212 | '\d STORE $0\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 213 | '\d RETURN void', |
Bram Moolenaar | 2d1c57e | 2021-04-19 20:50:03 +0200 | [diff] [blame] | 214 | res) |
| 215 | enddef |
| 216 | |
Bram Moolenaar | 5f7d4c0 | 2021-05-05 21:31:39 +0200 | [diff] [blame] | 217 | def s:Cexpr() |
| 218 | var errors = "list of errors" |
| 219 | cexpr errors |
| 220 | enddef |
| 221 | |
| 222 | def Test_disassemble_cexpr() |
| 223 | var res = execute('disass s:Cexpr') |
| 224 | assert_match('<SNR>\d*_Cexpr.*' .. |
| 225 | ' var errors = "list of errors"\_s*' .. |
| 226 | '\d PUSHS "list of errors"\_s*' .. |
| 227 | '\d STORE $0\_s*' .. |
| 228 | ' cexpr errors\_s*' .. |
| 229 | '\d CEXPR pre cexpr\_s*' .. |
| 230 | '\d LOAD $0\_s*' .. |
| 231 | '\d CEXPR core cexpr "cexpr errors"\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 232 | '\d RETURN void', |
Bram Moolenaar | 5f7d4c0 | 2021-05-05 21:31:39 +0200 | [diff] [blame] | 233 | res) |
| 234 | enddef |
| 235 | |
Bram Moolenaar | 7c5ad34 | 2020-08-12 15:48:55 +0200 | [diff] [blame] | 236 | def s:YankRange() |
| 237 | norm! m[jjm] |
| 238 | :'[,']yank |
| 239 | enddef |
| 240 | |
| 241 | def Test_disassemble_yank_range() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 242 | var res = execute('disass s:YankRange') |
Bram Moolenaar | 7c5ad34 | 2020-08-12 15:48:55 +0200 | [diff] [blame] | 243 | assert_match('<SNR>\d*_YankRange.*' .. |
| 244 | ' norm! m\[jjm\]\_s*' .. |
| 245 | '\d EXEC norm! m\[jjm\]\_s*' .. |
| 246 | ' :''\[,''\]yank\_s*' .. |
| 247 | '\d EXEC :''\[,''\]yank\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 248 | '\d RETURN void', |
Bram Moolenaar | cfe435d | 2020-04-25 20:02:55 +0200 | [diff] [blame] | 249 | res) |
| 250 | enddef |
| 251 | |
Bram Moolenaar | c3516f7 | 2020-09-08 22:45:35 +0200 | [diff] [blame] | 252 | def s:PutExpr() |
| 253 | :3put ="text" |
| 254 | enddef |
| 255 | |
| 256 | def Test_disassemble_put_expr() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 257 | var res = execute('disass s:PutExpr') |
Bram Moolenaar | c3516f7 | 2020-09-08 22:45:35 +0200 | [diff] [blame] | 258 | assert_match('<SNR>\d*_PutExpr.*' .. |
| 259 | ' :3put ="text"\_s*' .. |
| 260 | '\d PUSHS "text"\_s*' .. |
| 261 | '\d PUT = 3\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 262 | '\d RETURN void', |
Bram Moolenaar | c3516f7 | 2020-09-08 22:45:35 +0200 | [diff] [blame] | 263 | res) |
| 264 | enddef |
| 265 | |
Bram Moolenaar | 0859787 | 2020-12-10 19:43:40 +0100 | [diff] [blame] | 266 | def s:PutRange() |
| 267 | :$-2put a |
| 268 | enddef |
| 269 | |
| 270 | def Test_disassemble_put_range() |
| 271 | var res = execute('disass s:PutRange') |
| 272 | assert_match('<SNR>\d*_PutRange.*' .. |
| 273 | ' :$-2put a\_s*' .. |
| 274 | '\d RANGE $-2\_s*' .. |
| 275 | '\d PUT a range\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 276 | '\d RETURN void', |
Bram Moolenaar | 0859787 | 2020-12-10 19:43:40 +0100 | [diff] [blame] | 277 | res) |
| 278 | enddef |
| 279 | |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 280 | def s:ScriptFuncPush() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 281 | var localbool = true |
| 282 | var localspec = v:none |
| 283 | var localblob = 0z1234 |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 284 | if has('float') |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 285 | var localfloat = 1.234 |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 286 | endif |
| 287 | enddef |
| 288 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 289 | def Test_disassemble_push() |
Bram Moolenaar | 06b7722 | 2022-01-25 15:51:56 +0000 | [diff] [blame] | 290 | mkdir('Xdir/autoload', 'p') |
| 291 | var save_rtp = &rtp |
| 292 | exe 'set rtp^=' .. getcwd() .. '/Xdir' |
| 293 | |
| 294 | var lines =<< trim END |
| 295 | vim9script |
| 296 | END |
| 297 | writefile(lines, 'Xdir/autoload/autoscript.vim') |
| 298 | |
| 299 | lines =<< trim END |
| 300 | vim9script |
| 301 | import autoload 'autoscript.vim' |
| 302 | |
| 303 | def s:AutoloadFunc() |
| 304 | &operatorfunc = autoscript.Opfunc |
| 305 | enddef |
| 306 | |
| 307 | var res = execute('disass s:AutoloadFunc') |
| 308 | assert_match('<SNR>\d*_AutoloadFunc.*' .. |
| 309 | '&operatorfunc = autoscript.Opfunc\_s*' .. |
| 310 | '0 AUTOLOAD autoscript#Opfunc\_s*' .. |
| 311 | '1 STOREFUNCOPT &operatorfunc\_s*' .. |
| 312 | '2 RETURN void', |
| 313 | res) |
| 314 | END |
| 315 | CheckScriptSuccess(lines) |
| 316 | |
| 317 | delete('Xdir', 'rf') |
| 318 | &rtp = save_rtp |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 319 | enddef |
| 320 | |
| 321 | def s:ScriptFuncStore() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 322 | var localnr = 1 |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 323 | localnr = 2 |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 324 | var localstr = 'abc' |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 325 | localstr = 'xyz' |
| 326 | v:char = 'abc' |
| 327 | s:scriptvar = 'sv' |
| 328 | g:globalvar = 'gv' |
Bram Moolenaar | 03290b8 | 2020-12-19 16:30:44 +0100 | [diff] [blame] | 329 | g:auto#var = 'av' |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 330 | b:buffervar = 'bv' |
| 331 | w:windowvar = 'wv' |
| 332 | t:tabpagevar = 'tv' |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 333 | &tabstop = 8 |
Bram Moolenaar | dcb53be | 2021-12-09 14:23:43 +0000 | [diff] [blame] | 334 | &opfunc = (t) => len(t) |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 335 | $ENVVAR = 'ev' |
| 336 | @z = 'rv' |
| 337 | enddef |
| 338 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 339 | def Test_disassemble_store() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 340 | var res = execute('disass s:ScriptFuncStore') |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 341 | assert_match('<SNR>\d*_ScriptFuncStore.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 342 | 'var localnr = 1.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 343 | 'localnr = 2.*' .. |
| 344 | ' STORE 2 in $0.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 345 | 'var localstr = ''abc''.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 346 | 'localstr = ''xyz''.*' .. |
| 347 | ' STORE $1.*' .. |
| 348 | 'v:char = ''abc''.*' .. |
| 349 | 'STOREV v:char.*' .. |
| 350 | 's:scriptvar = ''sv''.*' .. |
| 351 | ' STORES s:scriptvar in .*test_vim9_disassemble.vim.*' .. |
| 352 | 'g:globalvar = ''gv''.*' .. |
| 353 | ' STOREG g:globalvar.*' .. |
Bram Moolenaar | 03290b8 | 2020-12-19 16:30:44 +0100 | [diff] [blame] | 354 | 'g:auto#var = ''av''.*' .. |
| 355 | ' STOREAUTO g:auto#var.*' .. |
Bram Moolenaar | d3aac29 | 2020-04-19 14:32:17 +0200 | [diff] [blame] | 356 | 'b:buffervar = ''bv''.*' .. |
| 357 | ' STOREB b:buffervar.*' .. |
| 358 | 'w:windowvar = ''wv''.*' .. |
| 359 | ' STOREW w:windowvar.*' .. |
| 360 | 't:tabpagevar = ''tv''.*' .. |
| 361 | ' STORET t:tabpagevar.*' .. |
Bram Moolenaar | dcb53be | 2021-12-09 14:23:43 +0000 | [diff] [blame] | 362 | '&tabstop = 8\_s*' .. |
| 363 | '\d\+ PUSHNR 8\_s*' .. |
| 364 | '\d\+ STOREOPT &tabstop\_s*' .. |
| 365 | '&opfunc = (t) => len(t)\_s*' .. |
| 366 | '\d\+ FUNCREF <lambda>\d\+\_s*' .. |
| 367 | '\d\+ STOREFUNCOPT &opfunc\_s*' .. |
| 368 | '$ENVVAR = ''ev''\_s*' .. |
| 369 | '\d\+ PUSHS "ev"\_s*' .. |
| 370 | '\d\+ STOREENV $ENVVAR\_s*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 371 | '@z = ''rv''.*' .. |
Bram Moolenaar | dcb53be | 2021-12-09 14:23:43 +0000 | [diff] [blame] | 372 | '\d\+ STOREREG @z.*', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 373 | res) |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 374 | enddef |
| 375 | |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 376 | def s:ScriptFuncStoreMember() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 377 | var locallist: list<number> = [] |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 378 | locallist[0] = 123 |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 379 | var localdict: dict<number> = {} |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 380 | localdict["a"] = 456 |
Bram Moolenaar | 51e9332 | 2021-04-17 20:44:56 +0200 | [diff] [blame] | 381 | var localblob: blob = 0z1122 |
| 382 | localblob[1] = 33 |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 383 | enddef |
| 384 | |
| 385 | def Test_disassemble_store_member() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 386 | var res = execute('disass s:ScriptFuncStoreMember') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 387 | assert_match('<SNR>\d*_ScriptFuncStoreMember\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 388 | 'var locallist: list<number> = []\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 389 | '\d NEWLIST size 0\_s*' .. |
Bram Moolenaar | aa210a3 | 2021-01-02 15:41:03 +0100 | [diff] [blame] | 390 | '\d SETTYPE list<number>\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 391 | '\d STORE $0\_s*' .. |
| 392 | 'locallist\[0\] = 123\_s*' .. |
| 393 | '\d PUSHNR 123\_s*' .. |
| 394 | '\d PUSHNR 0\_s*' .. |
| 395 | '\d LOAD $0\_s*' .. |
Bram Moolenaar | 51e9332 | 2021-04-17 20:44:56 +0200 | [diff] [blame] | 396 | '\d STOREINDEX list\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 397 | 'var localdict: dict<number> = {}\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 398 | '\d NEWDICT size 0\_s*' .. |
Bram Moolenaar | aa210a3 | 2021-01-02 15:41:03 +0100 | [diff] [blame] | 399 | '\d SETTYPE dict<number>\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 400 | '\d STORE $1\_s*' .. |
| 401 | 'localdict\["a"\] = 456\_s*' .. |
| 402 | '\d\+ PUSHNR 456\_s*' .. |
| 403 | '\d\+ PUSHS "a"\_s*' .. |
| 404 | '\d\+ LOAD $1\_s*' .. |
Bram Moolenaar | 51e9332 | 2021-04-17 20:44:56 +0200 | [diff] [blame] | 405 | '\d\+ STOREINDEX dict\_s*' .. |
| 406 | 'var localblob: blob = 0z1122\_s*' .. |
| 407 | '\d\+ PUSHBLOB 0z1122\_s*' .. |
| 408 | '\d\+ STORE $2\_s*' .. |
| 409 | 'localblob\[1\] = 33\_s*' .. |
| 410 | '\d\+ PUSHNR 33\_s*' .. |
| 411 | '\d\+ PUSHNR 1\_s*' .. |
| 412 | '\d\+ LOAD $2\_s*' .. |
| 413 | '\d\+ STOREINDEX blob\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 414 | '\d\+ RETURN void', |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 415 | res) |
| 416 | enddef |
| 417 | |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 418 | def s:ScriptFuncStoreIndex() |
| 419 | var d = {dd: {}} |
| 420 | d.dd[0] = 0 |
| 421 | enddef |
| 422 | |
| 423 | def Test_disassemble_store_index() |
| 424 | var res = execute('disass s:ScriptFuncStoreIndex') |
| 425 | assert_match('<SNR>\d*_ScriptFuncStoreIndex\_s*' .. |
| 426 | 'var d = {dd: {}}\_s*' .. |
| 427 | '\d PUSHS "dd"\_s*' .. |
| 428 | '\d NEWDICT size 0\_s*' .. |
| 429 | '\d NEWDICT size 1\_s*' .. |
| 430 | '\d STORE $0\_s*' .. |
| 431 | 'd.dd\[0\] = 0\_s*' .. |
| 432 | '\d PUSHNR 0\_s*' .. |
| 433 | '\d PUSHNR 0\_s*' .. |
| 434 | '\d LOAD $0\_s*' .. |
| 435 | '\d MEMBER dd\_s*' .. |
Bram Moolenaar | b1b6f4d | 2021-09-13 18:25:54 +0200 | [diff] [blame] | 436 | '\d\+ USEDICT\_s*' .. |
| 437 | '\d\+ STOREINDEX any\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 438 | '\d\+ RETURN void', |
Bram Moolenaar | 4f5e397 | 2020-12-21 17:30:50 +0100 | [diff] [blame] | 439 | res) |
| 440 | enddef |
| 441 | |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 442 | def s:ListAssign() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 443 | var x: string |
| 444 | var y: string |
| 445 | var l: list<any> |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 446 | [x, y; l] = g:stringlist |
| 447 | enddef |
| 448 | |
| 449 | def Test_disassemble_list_assign() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 450 | var res = execute('disass s:ListAssign') |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 451 | assert_match('<SNR>\d*_ListAssign\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 452 | 'var x: string\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 453 | '\d PUSHS "\[NULL\]"\_s*' .. |
| 454 | '\d STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 455 | 'var y: string\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 456 | '\d PUSHS "\[NULL\]"\_s*' .. |
| 457 | '\d STORE $1\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 458 | 'var l: list<any>\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 459 | '\d NEWLIST size 0\_s*' .. |
Bram Moolenaar | 6e48b84 | 2021-08-10 22:52:02 +0200 | [diff] [blame] | 460 | '\d SETTYPE list<any>\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 461 | '\d STORE $2\_s*' .. |
| 462 | '\[x, y; l\] = g:stringlist\_s*' .. |
| 463 | '\d LOADG g:stringlist\_s*' .. |
Bram Moolenaar | 5e65423 | 2020-09-16 15:22:00 +0200 | [diff] [blame] | 464 | '\d CHECKTYPE list<any> stack\[-1\]\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 465 | '\d CHECKLEN >= 2\_s*' .. |
| 466 | '\d\+ ITEM 0\_s*' .. |
Bram Moolenaar | 4270d8b | 2021-08-07 16:30:42 +0200 | [diff] [blame] | 467 | '\d\+ CHECKTYPE string stack\[-1\] arg 1\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 468 | '\d\+ STORE $0\_s*' .. |
| 469 | '\d\+ ITEM 1\_s*' .. |
Bram Moolenaar | 4270d8b | 2021-08-07 16:30:42 +0200 | [diff] [blame] | 470 | '\d\+ CHECKTYPE string stack\[-1\] arg 2\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 471 | '\d\+ STORE $1\_s*' .. |
| 472 | '\d\+ SLICE 2\_s*' .. |
Bram Moolenaar | 10d6f18 | 2022-01-04 15:54:38 +0000 | [diff] [blame] | 473 | '\d\+ SETTYPE list<any>\_s*' .. |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 474 | '\d\+ STORE $2\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 475 | '\d\+ RETURN void', |
Bram Moolenaar | 0779fab | 2020-06-18 22:18:18 +0200 | [diff] [blame] | 476 | res) |
| 477 | enddef |
| 478 | |
Bram Moolenaar | 035bd1c | 2021-06-21 19:44:11 +0200 | [diff] [blame] | 479 | def s:ListAssignWithOp() |
| 480 | var a = 2 |
| 481 | var b = 3 |
| 482 | [a, b] += [4, 5] |
| 483 | enddef |
| 484 | |
| 485 | def Test_disassemble_list_assign_with_op() |
| 486 | var res = execute('disass s:ListAssignWithOp') |
| 487 | assert_match('<SNR>\d*_ListAssignWithOp\_s*' .. |
| 488 | 'var a = 2\_s*' .. |
| 489 | '\d STORE 2 in $0\_s*' .. |
| 490 | 'var b = 3\_s*' .. |
| 491 | '\d STORE 3 in $1\_s*' .. |
| 492 | '\[a, b\] += \[4, 5\]\_s*' .. |
| 493 | '\d\+ PUSHNR 4\_s*' .. |
| 494 | '\d\+ PUSHNR 5\_s*' .. |
| 495 | '\d\+ NEWLIST size 2\_s*' .. |
Bram Moolenaar | 035bd1c | 2021-06-21 19:44:11 +0200 | [diff] [blame] | 496 | '\d\+ LOAD $0\_s*' .. |
| 497 | '\d\+ ITEM 0 with op\_s*' .. |
| 498 | '\d\+ OPNR +\_s*' .. |
| 499 | '\d\+ STORE $0\_s*' .. |
| 500 | '\d\+ LOAD $1\_s*' .. |
| 501 | '\d\+ ITEM 1 with op\_s*' .. |
| 502 | '\d\+ OPNR +\_s*' .. |
| 503 | '\d\+ STORE $1\_s*' .. |
| 504 | '\d\+ DROP\_s*' .. |
| 505 | '\d\+ RETURN void', |
| 506 | res) |
| 507 | enddef |
| 508 | |
Bram Moolenaar | 1dcae59 | 2020-10-19 19:02:42 +0200 | [diff] [blame] | 509 | def s:ListAdd() |
| 510 | var l: list<number> = [] |
| 511 | add(l, 123) |
| 512 | add(l, g:aNumber) |
| 513 | enddef |
| 514 | |
| 515 | def Test_disassemble_list_add() |
| 516 | var res = execute('disass s:ListAdd') |
| 517 | assert_match('<SNR>\d*_ListAdd\_s*' .. |
| 518 | 'var l: list<number> = []\_s*' .. |
| 519 | '\d NEWLIST size 0\_s*' .. |
Bram Moolenaar | aa210a3 | 2021-01-02 15:41:03 +0100 | [diff] [blame] | 520 | '\d SETTYPE list<number>\_s*' .. |
Bram Moolenaar | 1dcae59 | 2020-10-19 19:02:42 +0200 | [diff] [blame] | 521 | '\d STORE $0\_s*' .. |
| 522 | 'add(l, 123)\_s*' .. |
| 523 | '\d LOAD $0\_s*' .. |
| 524 | '\d PUSHNR 123\_s*' .. |
| 525 | '\d LISTAPPEND\_s*' .. |
| 526 | '\d DROP\_s*' .. |
| 527 | 'add(l, g:aNumber)\_s*' .. |
| 528 | '\d LOAD $0\_s*' .. |
| 529 | '\d\+ LOADG g:aNumber\_s*' .. |
| 530 | '\d\+ CHECKTYPE number stack\[-1\]\_s*' .. |
| 531 | '\d\+ LISTAPPEND\_s*' .. |
| 532 | '\d\+ DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 533 | '\d\+ RETURN void', |
Bram Moolenaar | 1dcae59 | 2020-10-19 19:02:42 +0200 | [diff] [blame] | 534 | res) |
| 535 | enddef |
| 536 | |
Bram Moolenaar | 80b0e5e | 2020-10-19 20:45:36 +0200 | [diff] [blame] | 537 | def s:BlobAdd() |
| 538 | var b: blob = 0z |
| 539 | add(b, 123) |
| 540 | add(b, g:aNumber) |
| 541 | enddef |
| 542 | |
| 543 | def Test_disassemble_blob_add() |
| 544 | var res = execute('disass s:BlobAdd') |
| 545 | assert_match('<SNR>\d*_BlobAdd\_s*' .. |
| 546 | 'var b: blob = 0z\_s*' .. |
| 547 | '\d PUSHBLOB 0z\_s*' .. |
| 548 | '\d STORE $0\_s*' .. |
| 549 | 'add(b, 123)\_s*' .. |
| 550 | '\d LOAD $0\_s*' .. |
| 551 | '\d PUSHNR 123\_s*' .. |
| 552 | '\d BLOBAPPEND\_s*' .. |
| 553 | '\d DROP\_s*' .. |
| 554 | 'add(b, g:aNumber)\_s*' .. |
| 555 | '\d LOAD $0\_s*' .. |
| 556 | '\d\+ LOADG g:aNumber\_s*' .. |
| 557 | '\d\+ CHECKTYPE number stack\[-1\]\_s*' .. |
| 558 | '\d\+ BLOBAPPEND\_s*' .. |
| 559 | '\d\+ DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 560 | '\d\+ RETURN void', |
Bram Moolenaar | 80b0e5e | 2020-10-19 20:45:36 +0200 | [diff] [blame] | 561 | res) |
| 562 | enddef |
| 563 | |
Bram Moolenaar | f62d739 | 2021-04-14 12:40:00 +0200 | [diff] [blame] | 564 | def s:BlobIndexSlice() |
| 565 | var b: blob = 0z112233 |
| 566 | echo b[1] |
| 567 | echo b[1 : 2] |
| 568 | enddef |
| 569 | |
| 570 | def Test_disassemble_blob_index_slice() |
| 571 | var res = execute('disass s:BlobIndexSlice') |
| 572 | assert_match('<SNR>\d*_BlobIndexSlice\_s*' .. |
| 573 | 'var b: blob = 0z112233\_s*' .. |
| 574 | '\d PUSHBLOB 0z112233\_s*' .. |
| 575 | '\d STORE $0\_s*' .. |
| 576 | 'echo b\[1\]\_s*' .. |
| 577 | '\d LOAD $0\_s*' .. |
| 578 | '\d PUSHNR 1\_s*' .. |
| 579 | '\d BLOBINDEX\_s*' .. |
| 580 | '\d ECHO 1\_s*' .. |
| 581 | 'echo b\[1 : 2\]\_s*' .. |
| 582 | '\d LOAD $0\_s*' .. |
| 583 | '\d PUSHNR 1\_s*' .. |
| 584 | '\d\+ PUSHNR 2\_s*' .. |
| 585 | '\d\+ BLOBSLICE\_s*' .. |
| 586 | '\d\+ ECHO 1\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 587 | '\d\+ RETURN void', |
Bram Moolenaar | f62d739 | 2021-04-14 12:40:00 +0200 | [diff] [blame] | 588 | res) |
| 589 | enddef |
| 590 | |
Bram Moolenaar | d72c1bf | 2020-04-19 16:28:59 +0200 | [diff] [blame] | 591 | def s:ScriptFuncUnlet() |
| 592 | g:somevar = "value" |
| 593 | unlet g:somevar |
| 594 | unlet! g:somevar |
Bram Moolenaar | 7bdaea6 | 2020-04-19 18:27:26 +0200 | [diff] [blame] | 595 | unlet $SOMEVAR |
Bram Moolenaar | d72c1bf | 2020-04-19 16:28:59 +0200 | [diff] [blame] | 596 | enddef |
| 597 | |
| 598 | def Test_disassemble_unlet() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 599 | var res = execute('disass s:ScriptFuncUnlet') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 600 | assert_match('<SNR>\d*_ScriptFuncUnlet\_s*' .. |
| 601 | 'g:somevar = "value"\_s*' .. |
| 602 | '\d PUSHS "value"\_s*' .. |
| 603 | '\d STOREG g:somevar\_s*' .. |
| 604 | 'unlet g:somevar\_s*' .. |
| 605 | '\d UNLET g:somevar\_s*' .. |
| 606 | 'unlet! g:somevar\_s*' .. |
| 607 | '\d UNLET! g:somevar\_s*' .. |
| 608 | 'unlet $SOMEVAR\_s*' .. |
| 609 | '\d UNLETENV $SOMEVAR\_s*', |
Bram Moolenaar | d72c1bf | 2020-04-19 16:28:59 +0200 | [diff] [blame] | 610 | res) |
| 611 | enddef |
| 612 | |
Bram Moolenaar | aacc966 | 2021-08-13 19:40:51 +0200 | [diff] [blame] | 613 | def s:LockLocal() |
| 614 | var d = {a: 1} |
| 615 | lockvar d.a |
| 616 | enddef |
| 617 | |
| 618 | def Test_disassemble_locl_local() |
| 619 | var res = execute('disass s:LockLocal') |
| 620 | assert_match('<SNR>\d*_LockLocal\_s*' .. |
| 621 | 'var d = {a: 1}\_s*' .. |
| 622 | '\d PUSHS "a"\_s*' .. |
| 623 | '\d PUSHNR 1\_s*' .. |
| 624 | '\d NEWDICT size 1\_s*' .. |
| 625 | '\d STORE $0\_s*' .. |
| 626 | 'lockvar d.a\_s*' .. |
| 627 | '\d LOAD $0\_s*' .. |
Bram Moolenaar | 70c43d8 | 2022-01-26 21:01:15 +0000 | [diff] [blame^] | 628 | '\d LOCKUNLOCK lockvar 2 d.a\_s*', |
Bram Moolenaar | aacc966 | 2021-08-13 19:40:51 +0200 | [diff] [blame] | 629 | res) |
| 630 | enddef |
| 631 | |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 632 | def s:ScriptFuncTry() |
| 633 | try |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 634 | echo "yes" |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 635 | catch /fail/ |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 636 | echo "no" |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 637 | finally |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 638 | throw "end" |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 639 | endtry |
| 640 | enddef |
| 641 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 642 | def Test_disassemble_try() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 643 | var res = execute('disass s:ScriptFuncTry') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 644 | assert_match('<SNR>\d*_ScriptFuncTry\_s*' .. |
| 645 | 'try\_s*' .. |
Bram Moolenaar | 7e82c5f | 2021-02-21 21:32:45 +0100 | [diff] [blame] | 646 | '\d TRY catch -> \d\+, finally -> \d\+, endtry -> \d\+\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 647 | 'echo "yes"\_s*' .. |
| 648 | '\d PUSHS "yes"\_s*' .. |
| 649 | '\d ECHO 1\_s*' .. |
| 650 | 'catch /fail/\_s*' .. |
| 651 | '\d JUMP -> \d\+\_s*' .. |
| 652 | '\d PUSH v:exception\_s*' .. |
| 653 | '\d PUSHS "fail"\_s*' .. |
| 654 | '\d COMPARESTRING =\~\_s*' .. |
| 655 | '\d JUMP_IF_FALSE -> \d\+\_s*' .. |
| 656 | '\d CATCH\_s*' .. |
| 657 | 'echo "no"\_s*' .. |
| 658 | '\d\+ PUSHS "no"\_s*' .. |
| 659 | '\d\+ ECHO 1\_s*' .. |
| 660 | 'finally\_s*' .. |
Bram Moolenaar | 7e82c5f | 2021-02-21 21:32:45 +0100 | [diff] [blame] | 661 | '\d\+ FINALLY\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 662 | 'throw "end"\_s*' .. |
| 663 | '\d\+ PUSHS "end"\_s*' .. |
| 664 | '\d\+ THROW\_s*' .. |
| 665 | 'endtry\_s*' .. |
| 666 | '\d\+ ENDTRY', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 667 | res) |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 668 | enddef |
| 669 | |
| 670 | def s:ScriptFuncNew() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 671 | var ll = [1, "two", 333] |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 672 | var dd = {one: 1, two: "val"} |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 673 | enddef |
| 674 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 675 | def Test_disassemble_new() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 676 | var res = execute('disass s:ScriptFuncNew') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 677 | assert_match('<SNR>\d*_ScriptFuncNew\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 678 | 'var ll = \[1, "two", 333\]\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 679 | '\d PUSHNR 1\_s*' .. |
| 680 | '\d PUSHS "two"\_s*' .. |
| 681 | '\d PUSHNR 333\_s*' .. |
| 682 | '\d NEWLIST size 3\_s*' .. |
| 683 | '\d STORE $0\_s*' .. |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 684 | 'var dd = {one: 1, two: "val"}\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 685 | '\d PUSHS "one"\_s*' .. |
| 686 | '\d PUSHNR 1\_s*' .. |
| 687 | '\d PUSHS "two"\_s*' .. |
| 688 | '\d PUSHS "val"\_s*' .. |
| 689 | '\d NEWDICT size 2\_s*', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 690 | res) |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 691 | enddef |
| 692 | |
Bram Moolenaar | 6e94978 | 2020-04-13 17:21:00 +0200 | [diff] [blame] | 693 | def FuncWithArg(arg: any) |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 694 | echo arg |
| 695 | enddef |
| 696 | |
| 697 | func UserFunc() |
| 698 | echo 'nothing' |
| 699 | endfunc |
| 700 | |
| 701 | func UserFuncWithArg(arg) |
| 702 | echo a:arg |
| 703 | endfunc |
| 704 | |
| 705 | def s:ScriptFuncCall(): string |
| 706 | changenr() |
| 707 | char2nr("abc") |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 708 | Test_disassemble_new() |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 709 | FuncWithArg(343) |
| 710 | ScriptFuncNew() |
| 711 | s:ScriptFuncNew() |
| 712 | UserFunc() |
| 713 | UserFuncWithArg("foo") |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 714 | var FuncRef = function("UserFunc") |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 715 | FuncRef() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 716 | var FuncRefWithArg = function("UserFuncWithArg") |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 717 | FuncRefWithArg("bar") |
| 718 | return "yes" |
| 719 | enddef |
| 720 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 721 | def Test_disassemble_call() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 722 | var res = execute('disass s:ScriptFuncCall') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 723 | assert_match('<SNR>\d\+_ScriptFuncCall\_s*' .. |
| 724 | 'changenr()\_s*' .. |
| 725 | '\d BCALL changenr(argc 0)\_s*' .. |
| 726 | '\d DROP\_s*' .. |
| 727 | 'char2nr("abc")\_s*' .. |
| 728 | '\d PUSHS "abc"\_s*' .. |
| 729 | '\d BCALL char2nr(argc 1)\_s*' .. |
| 730 | '\d DROP\_s*' .. |
| 731 | 'Test_disassemble_new()\_s*' .. |
| 732 | '\d DCALL Test_disassemble_new(argc 0)\_s*' .. |
| 733 | '\d DROP\_s*' .. |
| 734 | 'FuncWithArg(343)\_s*' .. |
| 735 | '\d\+ PUSHNR 343\_s*' .. |
| 736 | '\d\+ DCALL FuncWithArg(argc 1)\_s*' .. |
| 737 | '\d\+ DROP\_s*' .. |
| 738 | 'ScriptFuncNew()\_s*' .. |
| 739 | '\d\+ DCALL <SNR>\d\+_ScriptFuncNew(argc 0)\_s*' .. |
| 740 | '\d\+ DROP\_s*' .. |
| 741 | 's:ScriptFuncNew()\_s*' .. |
| 742 | '\d\+ DCALL <SNR>\d\+_ScriptFuncNew(argc 0)\_s*' .. |
| 743 | '\d\+ DROP\_s*' .. |
| 744 | 'UserFunc()\_s*' .. |
| 745 | '\d\+ UCALL UserFunc(argc 0)\_s*' .. |
| 746 | '\d\+ DROP\_s*' .. |
| 747 | 'UserFuncWithArg("foo")\_s*' .. |
| 748 | '\d\+ PUSHS "foo"\_s*' .. |
| 749 | '\d\+ UCALL UserFuncWithArg(argc 1)\_s*' .. |
| 750 | '\d\+ DROP\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 751 | 'var FuncRef = function("UserFunc")\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 752 | '\d\+ PUSHS "UserFunc"\_s*' .. |
| 753 | '\d\+ BCALL function(argc 1)\_s*' .. |
| 754 | '\d\+ STORE $0\_s*' .. |
| 755 | 'FuncRef()\_s*' .. |
| 756 | '\d\+ LOAD $\d\_s*' .. |
| 757 | '\d\+ PCALL (argc 0)\_s*' .. |
| 758 | '\d\+ DROP\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 759 | 'var FuncRefWithArg = function("UserFuncWithArg")\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 760 | '\d\+ PUSHS "UserFuncWithArg"\_s*' .. |
| 761 | '\d\+ BCALL function(argc 1)\_s*' .. |
| 762 | '\d\+ STORE $1\_s*' .. |
| 763 | 'FuncRefWithArg("bar")\_s*' .. |
| 764 | '\d\+ PUSHS "bar"\_s*' .. |
| 765 | '\d\+ LOAD $\d\_s*' .. |
| 766 | '\d\+ PCALL (argc 1)\_s*' .. |
| 767 | '\d\+ DROP\_s*' .. |
| 768 | 'return "yes"\_s*' .. |
| 769 | '\d\+ PUSHS "yes"\_s*' .. |
| 770 | '\d\+ RETURN', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 771 | res) |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 772 | enddef |
| 773 | |
Bram Moolenaar | 85d5e2b | 2020-10-10 14:13:01 +0200 | [diff] [blame] | 774 | |
| 775 | def s:CreateRefs() |
| 776 | var local = 'a' |
| 777 | def Append(arg: string) |
| 778 | local ..= arg |
| 779 | enddef |
| 780 | g:Append = Append |
| 781 | def Get(): string |
| 782 | return local |
| 783 | enddef |
| 784 | g:Get = Get |
| 785 | enddef |
| 786 | |
| 787 | def Test_disassemble_closure() |
| 788 | CreateRefs() |
| 789 | var res = execute('disass g:Append') |
| 790 | assert_match('<lambda>\d\_s*' .. |
| 791 | 'local ..= arg\_s*' .. |
Bram Moolenaar | ab36052 | 2021-01-10 14:02:28 +0100 | [diff] [blame] | 792 | '\d LOADOUTER level 1 $0\_s*' .. |
Bram Moolenaar | 85d5e2b | 2020-10-10 14:13:01 +0200 | [diff] [blame] | 793 | '\d LOAD arg\[-1\]\_s*' .. |
| 794 | '\d CONCAT\_s*' .. |
Bram Moolenaar | ab36052 | 2021-01-10 14:02:28 +0100 | [diff] [blame] | 795 | '\d STOREOUTER level 1 $0\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 796 | '\d RETURN void', |
Bram Moolenaar | 85d5e2b | 2020-10-10 14:13:01 +0200 | [diff] [blame] | 797 | res) |
| 798 | |
| 799 | res = execute('disass g:Get') |
| 800 | assert_match('<lambda>\d\_s*' .. |
| 801 | 'return local\_s*' .. |
Bram Moolenaar | ab36052 | 2021-01-10 14:02:28 +0100 | [diff] [blame] | 802 | '\d LOADOUTER level 1 $0\_s*' .. |
Bram Moolenaar | 85d5e2b | 2020-10-10 14:13:01 +0200 | [diff] [blame] | 803 | '\d RETURN', |
| 804 | res) |
| 805 | |
| 806 | unlet g:Append |
| 807 | unlet g:Get |
| 808 | enddef |
Bram Moolenaar | b68b346 | 2020-05-06 21:06:30 +0200 | [diff] [blame] | 809 | |
Bram Moolenaar | 8ed0458 | 2020-02-22 19:07:28 +0100 | [diff] [blame] | 810 | |
Bram Moolenaar | bd5da37 | 2020-03-31 23:13:10 +0200 | [diff] [blame] | 811 | def EchoArg(arg: string): string |
| 812 | return arg |
| 813 | enddef |
| 814 | def RefThis(): func |
| 815 | return function('EchoArg') |
| 816 | enddef |
| 817 | def s:ScriptPCall() |
| 818 | RefThis()("text") |
| 819 | enddef |
| 820 | |
| 821 | def Test_disassemble_pcall() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 822 | var res = execute('disass s:ScriptPCall') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 823 | assert_match('<SNR>\d\+_ScriptPCall\_s*' .. |
| 824 | 'RefThis()("text")\_s*' .. |
| 825 | '\d DCALL RefThis(argc 0)\_s*' .. |
| 826 | '\d PUSHS "text"\_s*' .. |
| 827 | '\d PCALL top (argc 1)\_s*' .. |
| 828 | '\d PCALL end\_s*' .. |
| 829 | '\d DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 830 | '\d RETURN void', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 831 | res) |
Bram Moolenaar | bd5da37 | 2020-03-31 23:13:10 +0200 | [diff] [blame] | 832 | enddef |
| 833 | |
| 834 | |
Bram Moolenaar | a26b970 | 2020-04-18 19:53:28 +0200 | [diff] [blame] | 835 | def s:FuncWithForwardCall(): string |
| 836 | return g:DefinedLater("yes") |
Bram Moolenaar | 7eeefd4 | 2020-02-26 21:24:23 +0100 | [diff] [blame] | 837 | enddef |
| 838 | |
| 839 | def DefinedLater(arg: string): string |
| 840 | return arg |
| 841 | enddef |
| 842 | |
| 843 | def Test_disassemble_update_instr() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 844 | var res = execute('disass s:FuncWithForwardCall') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 845 | assert_match('FuncWithForwardCall\_s*' .. |
| 846 | 'return g:DefinedLater("yes")\_s*' .. |
| 847 | '\d PUSHS "yes"\_s*' .. |
Bram Moolenaar | 822ba24 | 2020-05-24 23:00:18 +0200 | [diff] [blame] | 848 | '\d DCALL DefinedLater(argc 1)\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 849 | '\d RETURN', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 850 | res) |
Bram Moolenaar | 7eeefd4 | 2020-02-26 21:24:23 +0100 | [diff] [blame] | 851 | |
Bram Moolenaar | f5be8cd | 2020-07-17 20:36:00 +0200 | [diff] [blame] | 852 | # Calling the function will change UCALL into the faster DCALL |
Bram Moolenaar | 7eeefd4 | 2020-02-26 21:24:23 +0100 | [diff] [blame] | 853 | assert_equal('yes', FuncWithForwardCall()) |
| 854 | |
Bram Moolenaar | a26b970 | 2020-04-18 19:53:28 +0200 | [diff] [blame] | 855 | res = execute('disass s:FuncWithForwardCall') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 856 | assert_match('FuncWithForwardCall\_s*' .. |
| 857 | 'return g:DefinedLater("yes")\_s*' .. |
| 858 | '\d PUSHS "yes"\_s*' .. |
| 859 | '\d DCALL DefinedLater(argc 1)\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 860 | '\d RETURN', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 861 | res) |
Bram Moolenaar | 7eeefd4 | 2020-02-26 21:24:23 +0100 | [diff] [blame] | 862 | enddef |
| 863 | |
| 864 | |
Bram Moolenaar | 9ce47ec | 2021-04-20 22:16:39 +0200 | [diff] [blame] | 865 | def FuncWithDefault(l: number, arg: string = "default", nr = 77): string |
Bram Moolenaar | 38a3bfa | 2021-03-29 22:14:55 +0200 | [diff] [blame] | 866 | return arg .. nr |
Bram Moolenaar | 8ed0458 | 2020-02-22 19:07:28 +0100 | [diff] [blame] | 867 | enddef |
| 868 | |
| 869 | def Test_disassemble_call_default() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 870 | var res = execute('disass FuncWithDefault') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 871 | assert_match('FuncWithDefault\_s*' .. |
Bram Moolenaar | 9ce47ec | 2021-04-20 22:16:39 +0200 | [diff] [blame] | 872 | ' arg = "default"\_s*' .. |
Bram Moolenaar | 38a3bfa | 2021-03-29 22:14:55 +0200 | [diff] [blame] | 873 | '\d JUMP_IF_ARG_SET arg\[-2\] -> 3\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 874 | '\d PUSHS "default"\_s*' .. |
Bram Moolenaar | 38a3bfa | 2021-03-29 22:14:55 +0200 | [diff] [blame] | 875 | '\d STORE arg\[-2]\_s*' .. |
Bram Moolenaar | 9ce47ec | 2021-04-20 22:16:39 +0200 | [diff] [blame] | 876 | ' nr = 77\_s*' .. |
Bram Moolenaar | 38a3bfa | 2021-03-29 22:14:55 +0200 | [diff] [blame] | 877 | '3 JUMP_IF_ARG_SET arg\[-1\] -> 6\_s*' .. |
| 878 | '\d PUSHNR 77\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 879 | '\d STORE arg\[-1]\_s*' .. |
Bram Moolenaar | 9ce47ec | 2021-04-20 22:16:39 +0200 | [diff] [blame] | 880 | ' return arg .. nr\_s*' .. |
Bram Moolenaar | 38a3bfa | 2021-03-29 22:14:55 +0200 | [diff] [blame] | 881 | '6 LOAD arg\[-2]\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 882 | '\d LOAD arg\[-1]\_s*' .. |
Bram Moolenaar | 38a3bfa | 2021-03-29 22:14:55 +0200 | [diff] [blame] | 883 | '\d 2STRING stack\[-1]\_s*' .. |
| 884 | '\d\+ CONCAT\_s*' .. |
| 885 | '\d\+ RETURN', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 886 | res) |
Bram Moolenaar | 8ed0458 | 2020-02-22 19:07:28 +0100 | [diff] [blame] | 887 | enddef |
| 888 | |
| 889 | |
Bram Moolenaar | 158906c | 2020-02-06 20:39:45 +0100 | [diff] [blame] | 890 | def HasEval() |
| 891 | if has("eval") |
| 892 | echo "yes" |
| 893 | else |
| 894 | echo "no" |
| 895 | endif |
| 896 | enddef |
| 897 | |
| 898 | def HasNothing() |
| 899 | if has("nothing") |
| 900 | echo "yes" |
| 901 | else |
| 902 | echo "no" |
| 903 | endif |
| 904 | enddef |
| 905 | |
| 906 | def HasSomething() |
| 907 | if has("nothing") |
| 908 | echo "nothing" |
| 909 | elseif has("something") |
| 910 | echo "something" |
| 911 | elseif has("eval") |
| 912 | echo "eval" |
| 913 | elseif has("less") |
| 914 | echo "less" |
| 915 | endif |
| 916 | enddef |
| 917 | |
Bram Moolenaar | 8cebd43 | 2020-11-08 12:49:47 +0100 | [diff] [blame] | 918 | def HasGuiRunning() |
| 919 | if has("gui_running") |
| 920 | echo "yes" |
| 921 | else |
| 922 | echo "no" |
| 923 | endif |
| 924 | enddef |
| 925 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 926 | def Test_disassemble_const_expr() |
Bram Moolenaar | d2c6170 | 2020-09-06 15:58:36 +0200 | [diff] [blame] | 927 | assert_equal("\nyes", execute('HasEval()')) |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 928 | var instr = execute('disassemble HasEval') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 929 | assert_match('HasEval\_s*' .. |
| 930 | 'if has("eval")\_s*' .. |
| 931 | 'echo "yes"\_s*' .. |
| 932 | '\d PUSHS "yes"\_s*' .. |
| 933 | '\d ECHO 1\_s*' .. |
| 934 | 'else\_s*' .. |
| 935 | 'echo "no"\_s*' .. |
| 936 | 'endif\_s*', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 937 | instr) |
Bram Moolenaar | 158906c | 2020-02-06 20:39:45 +0100 | [diff] [blame] | 938 | assert_notmatch('JUMP', instr) |
| 939 | |
Bram Moolenaar | d2c6170 | 2020-09-06 15:58:36 +0200 | [diff] [blame] | 940 | assert_equal("\nno", execute('HasNothing()')) |
Bram Moolenaar | 158906c | 2020-02-06 20:39:45 +0100 | [diff] [blame] | 941 | instr = execute('disassemble HasNothing') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 942 | assert_match('HasNothing\_s*' .. |
| 943 | 'if has("nothing")\_s*' .. |
| 944 | 'echo "yes"\_s*' .. |
| 945 | 'else\_s*' .. |
| 946 | 'echo "no"\_s*' .. |
| 947 | '\d PUSHS "no"\_s*' .. |
| 948 | '\d ECHO 1\_s*' .. |
| 949 | 'endif', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 950 | instr) |
Bram Moolenaar | 158906c | 2020-02-06 20:39:45 +0100 | [diff] [blame] | 951 | assert_notmatch('PUSHS "yes"', instr) |
| 952 | assert_notmatch('JUMP', instr) |
| 953 | |
Bram Moolenaar | d2c6170 | 2020-09-06 15:58:36 +0200 | [diff] [blame] | 954 | assert_equal("\neval", execute('HasSomething()')) |
Bram Moolenaar | 158906c | 2020-02-06 20:39:45 +0100 | [diff] [blame] | 955 | instr = execute('disassemble HasSomething') |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 956 | assert_match('HasSomething.*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 957 | 'if has("nothing")\_s*' .. |
| 958 | 'echo "nothing"\_s*' .. |
| 959 | 'elseif has("something")\_s*' .. |
| 960 | 'echo "something"\_s*' .. |
| 961 | 'elseif has("eval")\_s*' .. |
| 962 | 'echo "eval"\_s*' .. |
| 963 | '\d PUSHS "eval"\_s*' .. |
| 964 | '\d ECHO 1\_s*' .. |
| 965 | 'elseif has("less").*' .. |
| 966 | 'echo "less"\_s*' .. |
| 967 | 'endif', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 968 | instr) |
Bram Moolenaar | 158906c | 2020-02-06 20:39:45 +0100 | [diff] [blame] | 969 | assert_notmatch('PUSHS "nothing"', instr) |
| 970 | assert_notmatch('PUSHS "something"', instr) |
| 971 | assert_notmatch('PUSHS "less"', instr) |
| 972 | assert_notmatch('JUMP', instr) |
Bram Moolenaar | 8cebd43 | 2020-11-08 12:49:47 +0100 | [diff] [blame] | 973 | |
| 974 | var result: string |
| 975 | var instr_expected: string |
| 976 | if has('gui') |
| 977 | if has('gui_running') |
| 978 | # GUI already running, always returns "yes" |
| 979 | result = "\nyes" |
| 980 | instr_expected = 'HasGuiRunning.*' .. |
| 981 | 'if has("gui_running")\_s*' .. |
| 982 | ' echo "yes"\_s*' .. |
| 983 | '\d PUSHS "yes"\_s*' .. |
| 984 | '\d ECHO 1\_s*' .. |
| 985 | 'else\_s*' .. |
| 986 | ' echo "no"\_s*' .. |
| 987 | 'endif' |
| 988 | else |
| 989 | result = "\nno" |
| 990 | if has('unix') |
| 991 | # GUI not running but can start later, call has() |
| 992 | instr_expected = 'HasGuiRunning.*' .. |
| 993 | 'if has("gui_running")\_s*' .. |
| 994 | '\d PUSHS "gui_running"\_s*' .. |
| 995 | '\d BCALL has(argc 1)\_s*' .. |
Bram Moolenaar | af8ea0d | 2021-04-11 18:24:46 +0200 | [diff] [blame] | 996 | '\d COND2BOOL\_s*' .. |
Bram Moolenaar | 8cebd43 | 2020-11-08 12:49:47 +0100 | [diff] [blame] | 997 | '\d JUMP_IF_FALSE -> \d\_s*' .. |
| 998 | ' echo "yes"\_s*' .. |
| 999 | '\d PUSHS "yes"\_s*' .. |
| 1000 | '\d ECHO 1\_s*' .. |
| 1001 | 'else\_s*' .. |
| 1002 | '\d JUMP -> \d\_s*' .. |
| 1003 | ' echo "no"\_s*' .. |
| 1004 | '\d PUSHS "no"\_s*' .. |
| 1005 | '\d ECHO 1\_s*' .. |
| 1006 | 'endif' |
| 1007 | else |
| 1008 | # GUI not running, always return "no" |
| 1009 | instr_expected = 'HasGuiRunning.*' .. |
| 1010 | 'if has("gui_running")\_s*' .. |
| 1011 | ' echo "yes"\_s*' .. |
| 1012 | 'else\_s*' .. |
| 1013 | ' echo "no"\_s*' .. |
| 1014 | '\d PUSHS "no"\_s*' .. |
| 1015 | '\d ECHO 1\_s*' .. |
| 1016 | 'endif' |
| 1017 | endif |
| 1018 | endif |
| 1019 | else |
| 1020 | # GUI not supported, always return "no" |
| 1021 | result = "\nno" |
| 1022 | instr_expected = 'HasGuiRunning.*' .. |
| 1023 | 'if has("gui_running")\_s*' .. |
| 1024 | ' echo "yes"\_s*' .. |
| 1025 | 'else\_s*' .. |
| 1026 | ' echo "no"\_s*' .. |
| 1027 | '\d PUSHS "no"\_s*' .. |
| 1028 | '\d ECHO 1\_s*' .. |
| 1029 | 'endif' |
| 1030 | endif |
| 1031 | |
| 1032 | assert_equal(result, execute('HasGuiRunning()')) |
| 1033 | instr = execute('disassemble HasGuiRunning') |
| 1034 | assert_match(instr_expected, instr) |
Bram Moolenaar | 158906c | 2020-02-06 20:39:45 +0100 | [diff] [blame] | 1035 | enddef |
| 1036 | |
Bram Moolenaar | efd8855 | 2020-06-18 20:50:10 +0200 | [diff] [blame] | 1037 | def ReturnInIf(): string |
Bram Moolenaar | 8e02faf | 2020-11-18 16:35:02 +0100 | [diff] [blame] | 1038 | if 1 < 0 |
| 1039 | return "maybe" |
| 1040 | endif |
Bram Moolenaar | efd8855 | 2020-06-18 20:50:10 +0200 | [diff] [blame] | 1041 | if g:cond |
| 1042 | return "yes" |
| 1043 | else |
| 1044 | return "no" |
| 1045 | endif |
| 1046 | enddef |
| 1047 | |
| 1048 | def Test_disassemble_return_in_if() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1049 | var instr = execute('disassemble ReturnInIf') |
Bram Moolenaar | efd8855 | 2020-06-18 20:50:10 +0200 | [diff] [blame] | 1050 | assert_match('ReturnInIf\_s*' .. |
Bram Moolenaar | 8e02faf | 2020-11-18 16:35:02 +0100 | [diff] [blame] | 1051 | 'if 1 < 0\_s*' .. |
| 1052 | ' return "maybe"\_s*' .. |
| 1053 | 'endif\_s*' .. |
Bram Moolenaar | efd8855 | 2020-06-18 20:50:10 +0200 | [diff] [blame] | 1054 | 'if g:cond\_s*' .. |
| 1055 | '0 LOADG g:cond\_s*' .. |
Bram Moolenaar | ea2d407 | 2020-11-12 12:08:51 +0100 | [diff] [blame] | 1056 | '1 COND2BOOL\_s*' .. |
| 1057 | '2 JUMP_IF_FALSE -> 5\_s*' .. |
Bram Moolenaar | efd8855 | 2020-06-18 20:50:10 +0200 | [diff] [blame] | 1058 | 'return "yes"\_s*' .. |
Bram Moolenaar | ea2d407 | 2020-11-12 12:08:51 +0100 | [diff] [blame] | 1059 | '3 PUSHS "yes"\_s*' .. |
| 1060 | '4 RETURN\_s*' .. |
Bram Moolenaar | efd8855 | 2020-06-18 20:50:10 +0200 | [diff] [blame] | 1061 | 'else\_s*' .. |
| 1062 | ' return "no"\_s*' .. |
Bram Moolenaar | ea2d407 | 2020-11-12 12:08:51 +0100 | [diff] [blame] | 1063 | '5 PUSHS "no"\_s*' .. |
| 1064 | '6 RETURN$', |
Bram Moolenaar | efd8855 | 2020-06-18 20:50:10 +0200 | [diff] [blame] | 1065 | instr) |
| 1066 | enddef |
| 1067 | |
Bram Moolenaar | f51cb4e | 2020-03-01 17:55:14 +0100 | [diff] [blame] | 1068 | def WithFunc() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1069 | var Funky1: func |
| 1070 | var Funky2: func = function("len") |
| 1071 | var Party2: func = funcref("UserFunc") |
Bram Moolenaar | f51cb4e | 2020-03-01 17:55:14 +0100 | [diff] [blame] | 1072 | enddef |
| 1073 | |
| 1074 | def Test_disassemble_function() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1075 | var instr = execute('disassemble WithFunc') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1076 | assert_match('WithFunc\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1077 | 'var Funky1: func\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1078 | '0 PUSHFUNC "\[none]"\_s*' .. |
| 1079 | '1 STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1080 | 'var Funky2: func = function("len")\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1081 | '2 PUSHS "len"\_s*' .. |
| 1082 | '3 BCALL function(argc 1)\_s*' .. |
| 1083 | '4 STORE $1\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1084 | 'var Party2: func = funcref("UserFunc")\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1085 | '\d PUSHS "UserFunc"\_s*' .. |
| 1086 | '\d BCALL funcref(argc 1)\_s*' .. |
| 1087 | '\d STORE $2\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1088 | '\d RETURN void', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1089 | instr) |
Bram Moolenaar | f51cb4e | 2020-03-01 17:55:14 +0100 | [diff] [blame] | 1090 | enddef |
| 1091 | |
| 1092 | if has('channel') |
| 1093 | def WithChannel() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1094 | var job1: job |
| 1095 | var job2: job = job_start("donothing") |
| 1096 | var chan1: channel |
Bram Moolenaar | f51cb4e | 2020-03-01 17:55:14 +0100 | [diff] [blame] | 1097 | enddef |
| 1098 | endif |
| 1099 | |
| 1100 | def Test_disassemble_channel() |
| 1101 | CheckFeature channel |
| 1102 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1103 | var instr = execute('disassemble WithChannel') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1104 | assert_match('WithChannel\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1105 | 'var job1: job\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1106 | '\d PUSHJOB "no process"\_s*' .. |
| 1107 | '\d STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1108 | 'var job2: job = job_start("donothing")\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1109 | '\d PUSHS "donothing"\_s*' .. |
| 1110 | '\d BCALL job_start(argc 1)\_s*' .. |
| 1111 | '\d STORE $1\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1112 | 'var chan1: channel\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1113 | '\d PUSHCHANNEL 0\_s*' .. |
| 1114 | '\d STORE $2\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1115 | '\d RETURN void', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1116 | instr) |
Bram Moolenaar | f51cb4e | 2020-03-01 17:55:14 +0100 | [diff] [blame] | 1117 | enddef |
| 1118 | |
Bram Moolenaar | 777770f | 2020-02-06 21:27:08 +0100 | [diff] [blame] | 1119 | def WithLambda(): string |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1120 | var F = (a) => "X" .. a .. "X" |
Bram Moolenaar | 777770f | 2020-02-06 21:27:08 +0100 | [diff] [blame] | 1121 | return F("x") |
| 1122 | enddef |
| 1123 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1124 | def Test_disassemble_lambda() |
Bram Moolenaar | 777770f | 2020-02-06 21:27:08 +0100 | [diff] [blame] | 1125 | assert_equal("XxX", WithLambda()) |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1126 | var instr = execute('disassemble WithLambda') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1127 | assert_match('WithLambda\_s*' .. |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1128 | 'var F = (a) => "X" .. a .. "X"\_s*' .. |
Bram Moolenaar | 148ce7a | 2020-09-23 21:57:23 +0200 | [diff] [blame] | 1129 | '\d FUNCREF <lambda>\d\+\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1130 | '\d STORE $0\_s*' .. |
| 1131 | 'return F("x")\_s*' .. |
| 1132 | '\d PUSHS "x"\_s*' .. |
| 1133 | '\d LOAD $0\_s*' .. |
| 1134 | '\d PCALL (argc 1)\_s*' .. |
Bram Moolenaar | 822ba24 | 2020-05-24 23:00:18 +0200 | [diff] [blame] | 1135 | '\d RETURN', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1136 | instr) |
Bram Moolenaar | bfd6558 | 2020-07-13 18:18:00 +0200 | [diff] [blame] | 1137 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1138 | var name = substitute(instr, '.*\(<lambda>\d\+\).*', '\1', '') |
Bram Moolenaar | bfd6558 | 2020-07-13 18:18:00 +0200 | [diff] [blame] | 1139 | instr = execute('disassemble ' .. name) |
| 1140 | assert_match('<lambda>\d\+\_s*' .. |
| 1141 | 'return "X" .. a .. "X"\_s*' .. |
| 1142 | '\d PUSHS "X"\_s*' .. |
| 1143 | '\d LOAD arg\[-1\]\_s*' .. |
Bram Moolenaar | 418f1df | 2020-08-12 21:34:49 +0200 | [diff] [blame] | 1144 | '\d 2STRING_ANY stack\[-1\]\_s*' .. |
Bram Moolenaar | bfd6558 | 2020-07-13 18:18:00 +0200 | [diff] [blame] | 1145 | '\d CONCAT\_s*' .. |
| 1146 | '\d PUSHS "X"\_s*' .. |
| 1147 | '\d CONCAT\_s*' .. |
| 1148 | '\d RETURN', |
| 1149 | instr) |
Bram Moolenaar | 777770f | 2020-02-06 21:27:08 +0100 | [diff] [blame] | 1150 | enddef |
| 1151 | |
Bram Moolenaar | b4d16cb | 2020-11-05 18:45:46 +0100 | [diff] [blame] | 1152 | def LambdaWithType(): number |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1153 | var Ref = (a: number) => a + 10 |
Bram Moolenaar | b4d16cb | 2020-11-05 18:45:46 +0100 | [diff] [blame] | 1154 | return Ref(g:value) |
| 1155 | enddef |
| 1156 | |
| 1157 | def Test_disassemble_lambda_with_type() |
| 1158 | g:value = 5 |
| 1159 | assert_equal(15, LambdaWithType()) |
| 1160 | var instr = execute('disassemble LambdaWithType') |
| 1161 | assert_match('LambdaWithType\_s*' .. |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1162 | 'var Ref = (a: number) => a + 10\_s*' .. |
Bram Moolenaar | b4d16cb | 2020-11-05 18:45:46 +0100 | [diff] [blame] | 1163 | '\d FUNCREF <lambda>\d\+\_s*' .. |
| 1164 | '\d STORE $0\_s*' .. |
| 1165 | 'return Ref(g:value)\_s*' .. |
| 1166 | '\d LOADG g:value\_s*' .. |
| 1167 | '\d LOAD $0\_s*' .. |
Bram Moolenaar | e32e516 | 2021-01-21 20:21:29 +0100 | [diff] [blame] | 1168 | '\d CHECKTYPE number stack\[-2\] arg 1\_s*' .. |
Bram Moolenaar | b4d16cb | 2020-11-05 18:45:46 +0100 | [diff] [blame] | 1169 | '\d PCALL (argc 1)\_s*' .. |
| 1170 | '\d RETURN', |
| 1171 | instr) |
| 1172 | enddef |
| 1173 | |
Bram Moolenaar | 38ddf33 | 2020-07-31 22:05:04 +0200 | [diff] [blame] | 1174 | def NestedOuter() |
| 1175 | def g:Inner() |
| 1176 | echomsg "inner" |
| 1177 | enddef |
| 1178 | enddef |
| 1179 | |
Bram Moolenaar | 8863bda | 2021-03-17 18:42:08 +0100 | [diff] [blame] | 1180 | def Test_disassemble_nested_func() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1181 | var instr = execute('disassemble NestedOuter') |
Bram Moolenaar | 38ddf33 | 2020-07-31 22:05:04 +0200 | [diff] [blame] | 1182 | assert_match('NestedOuter\_s*' .. |
| 1183 | 'def g:Inner()\_s*' .. |
| 1184 | 'echomsg "inner"\_s*' .. |
| 1185 | 'enddef\_s*' .. |
| 1186 | '\d NEWFUNC <lambda>\d\+ Inner\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1187 | '\d RETURN void', |
Bram Moolenaar | 38ddf33 | 2020-07-31 22:05:04 +0200 | [diff] [blame] | 1188 | instr) |
| 1189 | enddef |
| 1190 | |
Bram Moolenaar | 6abdcf8 | 2020-11-22 18:15:44 +0100 | [diff] [blame] | 1191 | def NestedDefList() |
| 1192 | def |
| 1193 | def Info |
| 1194 | def /Info |
| 1195 | def /Info/ |
| 1196 | enddef |
| 1197 | |
Bram Moolenaar | 8863bda | 2021-03-17 18:42:08 +0100 | [diff] [blame] | 1198 | def Test_disassemble_nested_def_list() |
Bram Moolenaar | 6abdcf8 | 2020-11-22 18:15:44 +0100 | [diff] [blame] | 1199 | var instr = execute('disassemble NestedDefList') |
| 1200 | assert_match('NestedDefList\_s*' .. |
| 1201 | 'def\_s*' .. |
| 1202 | '\d DEF \_s*' .. |
| 1203 | 'def Info\_s*' .. |
| 1204 | '\d DEF Info\_s*' .. |
| 1205 | 'def /Info\_s*' .. |
| 1206 | '\d DEF /Info\_s*' .. |
| 1207 | 'def /Info/\_s*' .. |
| 1208 | '\d DEF /Info/\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1209 | '\d RETURN void', |
Bram Moolenaar | 6abdcf8 | 2020-11-22 18:15:44 +0100 | [diff] [blame] | 1210 | instr) |
| 1211 | enddef |
| 1212 | |
Bram Moolenaar | 6e94978 | 2020-04-13 17:21:00 +0200 | [diff] [blame] | 1213 | def AndOr(arg: any): string |
Bram Moolenaar | 777770f | 2020-02-06 21:27:08 +0100 | [diff] [blame] | 1214 | if arg == 1 && arg != 2 || arg == 4 |
| 1215 | return 'yes' |
| 1216 | endif |
| 1217 | return 'no' |
| 1218 | enddef |
| 1219 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1220 | def Test_disassemble_and_or() |
Bram Moolenaar | 777770f | 2020-02-06 21:27:08 +0100 | [diff] [blame] | 1221 | assert_equal("yes", AndOr(1)) |
| 1222 | assert_equal("no", AndOr(2)) |
| 1223 | assert_equal("yes", AndOr(4)) |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1224 | var instr = execute('disassemble AndOr') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1225 | assert_match('AndOr\_s*' .. |
| 1226 | 'if arg == 1 && arg != 2 || arg == 4\_s*' .. |
| 1227 | '\d LOAD arg\[-1]\_s*' .. |
| 1228 | '\d PUSHNR 1\_s*' .. |
| 1229 | '\d COMPAREANY ==\_s*' .. |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 1230 | '\d JUMP_IF_COND_FALSE -> \d\+\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1231 | '\d LOAD arg\[-1]\_s*' .. |
| 1232 | '\d PUSHNR 2\_s*' .. |
| 1233 | '\d COMPAREANY !=\_s*' .. |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 1234 | '\d JUMP_IF_COND_TRUE -> \d\+\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1235 | '\d LOAD arg\[-1]\_s*' .. |
| 1236 | '\d\+ PUSHNR 4\_s*' .. |
| 1237 | '\d\+ COMPAREANY ==\_s*' .. |
| 1238 | '\d\+ JUMP_IF_FALSE -> \d\+', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1239 | instr) |
Bram Moolenaar | 777770f | 2020-02-06 21:27:08 +0100 | [diff] [blame] | 1240 | enddef |
| 1241 | |
Bram Moolenaar | 1a7ee4d | 2021-09-16 16:15:07 +0200 | [diff] [blame] | 1242 | def AndConstant(arg: any): string |
| 1243 | if true && arg |
| 1244 | return "yes" |
| 1245 | endif |
| 1246 | if false && arg |
| 1247 | return "never" |
| 1248 | endif |
| 1249 | return "no" |
| 1250 | enddef |
| 1251 | |
| 1252 | def Test_disassemble_and_constant() |
| 1253 | assert_equal("yes", AndConstant(1)) |
| 1254 | assert_equal("no", AndConstant(false)) |
| 1255 | var instr = execute('disassemble AndConstant') |
| 1256 | assert_match('AndConstant\_s*' .. |
| 1257 | 'if true && arg\_s*' .. |
| 1258 | '0 LOAD arg\[-1\]\_s*' .. |
| 1259 | '1 COND2BOOL\_s*' .. |
| 1260 | '2 JUMP_IF_FALSE -> 5\_s*' .. |
| 1261 | 'return "yes"\_s*' .. |
| 1262 | '3 PUSHS "yes"\_s*' .. |
| 1263 | '4 RETURN\_s*' .. |
| 1264 | 'endif\_s*' .. |
| 1265 | 'if false && arg\_s*' .. |
| 1266 | 'return "never"\_s*' .. |
| 1267 | 'endif\_s*' .. |
| 1268 | 'return "no"\_s*' .. |
| 1269 | '5 PUSHS "no"\_s*' .. |
| 1270 | '6 RETURN', |
| 1271 | instr) |
| 1272 | enddef |
| 1273 | |
Bram Moolenaar | 04d0522 | 2020-02-06 22:06:54 +0100 | [diff] [blame] | 1274 | def ForLoop(): list<number> |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1275 | var res: list<number> |
Bram Moolenaar | 04d0522 | 2020-02-06 22:06:54 +0100 | [diff] [blame] | 1276 | for i in range(3) |
| 1277 | res->add(i) |
| 1278 | endfor |
| 1279 | return res |
| 1280 | enddef |
| 1281 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1282 | def Test_disassemble_for_loop() |
Bram Moolenaar | 04d0522 | 2020-02-06 22:06:54 +0100 | [diff] [blame] | 1283 | assert_equal([0, 1, 2], ForLoop()) |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1284 | var instr = execute('disassemble ForLoop') |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1285 | assert_match('ForLoop\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1286 | 'var res: list<number>\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1287 | '\d NEWLIST size 0\_s*' .. |
Bram Moolenaar | aa210a3 | 2021-01-02 15:41:03 +0100 | [diff] [blame] | 1288 | '\d SETTYPE list<number>\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1289 | '\d STORE $0\_s*' .. |
| 1290 | 'for i in range(3)\_s*' .. |
| 1291 | '\d STORE -1 in $1\_s*' .. |
| 1292 | '\d PUSHNR 3\_s*' .. |
| 1293 | '\d BCALL range(argc 1)\_s*' .. |
| 1294 | '\d FOR $1 -> \d\+\_s*' .. |
| 1295 | '\d STORE $2\_s*' .. |
| 1296 | 'res->add(i)\_s*' .. |
| 1297 | '\d LOAD $0\_s*' .. |
| 1298 | '\d LOAD $2\_s*' .. |
Bram Moolenaar | 1dcae59 | 2020-10-19 19:02:42 +0200 | [diff] [blame] | 1299 | '\d\+ LISTAPPEND\_s*' .. |
Bram Moolenaar | cb79040 | 2020-05-15 20:53:00 +0200 | [diff] [blame] | 1300 | '\d\+ DROP\_s*' .. |
| 1301 | 'endfor\_s*' .. |
| 1302 | '\d\+ JUMP -> \d\+\_s*' .. |
| 1303 | '\d\+ DROP', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1304 | instr) |
Bram Moolenaar | 04d0522 | 2020-02-06 22:06:54 +0100 | [diff] [blame] | 1305 | enddef |
| 1306 | |
Bram Moolenaar | 0ad3e89 | 2020-07-05 21:38:11 +0200 | [diff] [blame] | 1307 | def ForLoopEval(): string |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1308 | var res = "" |
Bram Moolenaar | 0ad3e89 | 2020-07-05 21:38:11 +0200 | [diff] [blame] | 1309 | for str in eval('["one", "two"]') |
| 1310 | res ..= str |
| 1311 | endfor |
| 1312 | return res |
| 1313 | enddef |
| 1314 | |
| 1315 | def Test_disassemble_for_loop_eval() |
| 1316 | assert_equal('onetwo', ForLoopEval()) |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1317 | var instr = execute('disassemble ForLoopEval') |
Bram Moolenaar | 0ad3e89 | 2020-07-05 21:38:11 +0200 | [diff] [blame] | 1318 | assert_match('ForLoopEval\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1319 | 'var res = ""\_s*' .. |
Bram Moolenaar | 0ad3e89 | 2020-07-05 21:38:11 +0200 | [diff] [blame] | 1320 | '\d PUSHS ""\_s*' .. |
| 1321 | '\d STORE $0\_s*' .. |
| 1322 | 'for str in eval(''\["one", "two"\]'')\_s*' .. |
| 1323 | '\d STORE -1 in $1\_s*' .. |
| 1324 | '\d PUSHS "\["one", "two"\]"\_s*' .. |
| 1325 | '\d BCALL eval(argc 1)\_s*' .. |
Bram Moolenaar | 0ad3e89 | 2020-07-05 21:38:11 +0200 | [diff] [blame] | 1326 | '\d FOR $1 -> \d\+\_s*' .. |
| 1327 | '\d STORE $2\_s*' .. |
| 1328 | 'res ..= str\_s*' .. |
| 1329 | '\d\+ LOAD $0\_s*' .. |
| 1330 | '\d\+ LOAD $2\_s*' .. |
Bram Moolenaar | f5d52c9 | 2021-07-31 22:51:10 +0200 | [diff] [blame] | 1331 | '\d 2STRING_ANY stack\[-1\]\_s*' .. |
Bram Moolenaar | 0ad3e89 | 2020-07-05 21:38:11 +0200 | [diff] [blame] | 1332 | '\d\+ CONCAT\_s*' .. |
| 1333 | '\d\+ STORE $0\_s*' .. |
| 1334 | 'endfor\_s*' .. |
Bram Moolenaar | 74e54fc | 2021-03-26 20:41:29 +0100 | [diff] [blame] | 1335 | '\d\+ JUMP -> 5\_s*' .. |
Bram Moolenaar | 0ad3e89 | 2020-07-05 21:38:11 +0200 | [diff] [blame] | 1336 | '\d\+ DROP\_s*' .. |
| 1337 | 'return res\_s*' .. |
| 1338 | '\d\+ LOAD $0\_s*' .. |
| 1339 | '\d\+ RETURN', |
| 1340 | instr) |
| 1341 | enddef |
| 1342 | |
Bram Moolenaar | 792f786 | 2020-11-23 08:31:18 +0100 | [diff] [blame] | 1343 | def ForLoopUnpack() |
| 1344 | for [x1, x2] in [[1, 2], [3, 4]] |
| 1345 | echo x1 x2 |
| 1346 | endfor |
| 1347 | enddef |
| 1348 | |
| 1349 | def Test_disassemble_for_loop_unpack() |
| 1350 | var instr = execute('disassemble ForLoopUnpack') |
| 1351 | assert_match('ForLoopUnpack\_s*' .. |
| 1352 | 'for \[x1, x2\] in \[\[1, 2\], \[3, 4\]\]\_s*' .. |
| 1353 | '\d\+ STORE -1 in $0\_s*' .. |
| 1354 | '\d\+ PUSHNR 1\_s*' .. |
| 1355 | '\d\+ PUSHNR 2\_s*' .. |
| 1356 | '\d\+ NEWLIST size 2\_s*' .. |
| 1357 | '\d\+ PUSHNR 3\_s*' .. |
| 1358 | '\d\+ PUSHNR 4\_s*' .. |
| 1359 | '\d\+ NEWLIST size 2\_s*' .. |
| 1360 | '\d\+ NEWLIST size 2\_s*' .. |
| 1361 | '\d\+ FOR $0 -> 16\_s*' .. |
| 1362 | '\d\+ UNPACK 2\_s*' .. |
| 1363 | '\d\+ STORE $1\_s*' .. |
| 1364 | '\d\+ STORE $2\_s*' .. |
| 1365 | 'echo x1 x2\_s*' .. |
| 1366 | '\d\+ LOAD $1\_s*' .. |
| 1367 | '\d\+ LOAD $2\_s*' .. |
| 1368 | '\d\+ ECHO 2\_s*' .. |
| 1369 | 'endfor\_s*' .. |
| 1370 | '\d\+ JUMP -> 8\_s*' .. |
| 1371 | '\d\+ DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1372 | '\d\+ RETURN void', |
Bram Moolenaar | 792f786 | 2020-11-23 08:31:18 +0100 | [diff] [blame] | 1373 | instr) |
| 1374 | enddef |
| 1375 | |
Bram Moolenaar | c150c09 | 2021-02-13 15:02:46 +0100 | [diff] [blame] | 1376 | def ForLoopContinue() |
| 1377 | for nr in [1, 2] |
| 1378 | try |
| 1379 | echo "ok" |
| 1380 | try |
| 1381 | echo "deeper" |
| 1382 | catch |
| 1383 | continue |
| 1384 | endtry |
| 1385 | catch |
| 1386 | echo "not ok" |
| 1387 | endtry |
| 1388 | endfor |
| 1389 | enddef |
| 1390 | |
| 1391 | def Test_disassemble_for_loop_continue() |
| 1392 | var instr = execute('disassemble ForLoopContinue') |
| 1393 | assert_match('ForLoopContinue\_s*' .. |
| 1394 | 'for nr in \[1, 2]\_s*' .. |
| 1395 | '0 STORE -1 in $0\_s*' .. |
| 1396 | '1 PUSHNR 1\_s*' .. |
| 1397 | '2 PUSHNR 2\_s*' .. |
| 1398 | '3 NEWLIST size 2\_s*' .. |
| 1399 | '4 FOR $0 -> 22\_s*' .. |
| 1400 | '5 STORE $1\_s*' .. |
| 1401 | 'try\_s*' .. |
Bram Moolenaar | 7e82c5f | 2021-02-21 21:32:45 +0100 | [diff] [blame] | 1402 | '6 TRY catch -> 17, endtry -> 20\_s*' .. |
Bram Moolenaar | c150c09 | 2021-02-13 15:02:46 +0100 | [diff] [blame] | 1403 | 'echo "ok"\_s*' .. |
| 1404 | '7 PUSHS "ok"\_s*' .. |
| 1405 | '8 ECHO 1\_s*' .. |
| 1406 | 'try\_s*' .. |
Bram Moolenaar | 7e82c5f | 2021-02-21 21:32:45 +0100 | [diff] [blame] | 1407 | '9 TRY catch -> 13, endtry -> 15\_s*' .. |
Bram Moolenaar | c150c09 | 2021-02-13 15:02:46 +0100 | [diff] [blame] | 1408 | 'echo "deeper"\_s*' .. |
| 1409 | '10 PUSHS "deeper"\_s*' .. |
| 1410 | '11 ECHO 1\_s*' .. |
| 1411 | 'catch\_s*' .. |
| 1412 | '12 JUMP -> 15\_s*' .. |
| 1413 | '13 CATCH\_s*' .. |
| 1414 | 'continue\_s*' .. |
| 1415 | '14 TRY-CONTINUE 2 levels -> 4\_s*' .. |
| 1416 | 'endtry\_s*' .. |
| 1417 | '15 ENDTRY\_s*' .. |
| 1418 | 'catch\_s*' .. |
| 1419 | '16 JUMP -> 20\_s*' .. |
| 1420 | '17 CATCH\_s*' .. |
| 1421 | 'echo "not ok"\_s*' .. |
| 1422 | '18 PUSHS "not ok"\_s*' .. |
| 1423 | '19 ECHO 1\_s*' .. |
| 1424 | 'endtry\_s*' .. |
| 1425 | '20 ENDTRY\_s*' .. |
| 1426 | 'endfor\_s*' .. |
| 1427 | '21 JUMP -> 4\_s*' .. |
| 1428 | '\d\+ DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1429 | '\d\+ RETURN void', |
Bram Moolenaar | c150c09 | 2021-02-13 15:02:46 +0100 | [diff] [blame] | 1430 | instr) |
| 1431 | enddef |
| 1432 | |
Bram Moolenaar | c2a4b35 | 2020-02-06 22:41:16 +0100 | [diff] [blame] | 1433 | let g:number = 42 |
| 1434 | |
Bram Moolenaar | 64d662d | 2020-08-09 19:02:50 +0200 | [diff] [blame] | 1435 | def TypeCast() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1436 | var l: list<number> = [23, <number>g:number] |
Bram Moolenaar | 64d662d | 2020-08-09 19:02:50 +0200 | [diff] [blame] | 1437 | enddef |
| 1438 | |
| 1439 | def Test_disassemble_typecast() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1440 | var instr = execute('disassemble TypeCast') |
Bram Moolenaar | 64d662d | 2020-08-09 19:02:50 +0200 | [diff] [blame] | 1441 | assert_match('TypeCast.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1442 | 'var l: list<number> = \[23, <number>g:number\].*' .. |
Bram Moolenaar | 64d662d | 2020-08-09 19:02:50 +0200 | [diff] [blame] | 1443 | '\d PUSHNR 23\_s*' .. |
| 1444 | '\d LOADG g:number\_s*' .. |
| 1445 | '\d CHECKTYPE number stack\[-1\]\_s*' .. |
| 1446 | '\d NEWLIST size 2\_s*' .. |
Bram Moolenaar | aa210a3 | 2021-01-02 15:41:03 +0100 | [diff] [blame] | 1447 | '\d SETTYPE list<number>\_s*' .. |
Bram Moolenaar | 64d662d | 2020-08-09 19:02:50 +0200 | [diff] [blame] | 1448 | '\d STORE $0\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1449 | '\d RETURN void\_s*', |
Bram Moolenaar | 64d662d | 2020-08-09 19:02:50 +0200 | [diff] [blame] | 1450 | instr) |
| 1451 | enddef |
| 1452 | |
Bram Moolenaar | c2a4b35 | 2020-02-06 22:41:16 +0100 | [diff] [blame] | 1453 | def Computing() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1454 | var nr = 3 |
| 1455 | var nrres = nr + 7 |
Bram Moolenaar | c2a4b35 | 2020-02-06 22:41:16 +0100 | [diff] [blame] | 1456 | nrres = nr - 7 |
| 1457 | nrres = nr * 7 |
| 1458 | nrres = nr / 7 |
| 1459 | nrres = nr % 7 |
| 1460 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1461 | var anyres = g:number + 7 |
Bram Moolenaar | c2a4b35 | 2020-02-06 22:41:16 +0100 | [diff] [blame] | 1462 | anyres = g:number - 7 |
| 1463 | anyres = g:number * 7 |
| 1464 | anyres = g:number / 7 |
| 1465 | anyres = g:number % 7 |
| 1466 | |
| 1467 | if has('float') |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1468 | var fl = 3.0 |
| 1469 | var flres = fl + 7.0 |
Bram Moolenaar | c2a4b35 | 2020-02-06 22:41:16 +0100 | [diff] [blame] | 1470 | flres = fl - 7.0 |
| 1471 | flres = fl * 7.0 |
| 1472 | flres = fl / 7.0 |
| 1473 | endif |
| 1474 | enddef |
| 1475 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1476 | def Test_disassemble_computing() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1477 | var instr = execute('disassemble Computing') |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1478 | assert_match('Computing.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1479 | 'var nr = 3.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1480 | '\d STORE 3 in $0.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1481 | 'var nrres = nr + 7.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1482 | '\d LOAD $0.*' .. |
| 1483 | '\d PUSHNR 7.*' .. |
| 1484 | '\d OPNR +.*' .. |
| 1485 | '\d STORE $1.*' .. |
| 1486 | 'nrres = nr - 7.*' .. |
| 1487 | '\d OPNR -.*' .. |
| 1488 | 'nrres = nr \* 7.*' .. |
| 1489 | '\d OPNR \*.*' .. |
| 1490 | 'nrres = nr / 7.*' .. |
| 1491 | '\d OPNR /.*' .. |
| 1492 | 'nrres = nr % 7.*' .. |
| 1493 | '\d OPNR %.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1494 | 'var anyres = g:number + 7.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1495 | '\d LOADG g:number.*' .. |
| 1496 | '\d PUSHNR 7.*' .. |
| 1497 | '\d OPANY +.*' .. |
| 1498 | '\d STORE $2.*' .. |
| 1499 | 'anyres = g:number - 7.*' .. |
| 1500 | '\d OPANY -.*' .. |
| 1501 | 'anyres = g:number \* 7.*' .. |
| 1502 | '\d OPANY \*.*' .. |
| 1503 | 'anyres = g:number / 7.*' .. |
| 1504 | '\d OPANY /.*' .. |
| 1505 | 'anyres = g:number % 7.*' .. |
| 1506 | '\d OPANY %.*', |
| 1507 | instr) |
Bram Moolenaar | c2a4b35 | 2020-02-06 22:41:16 +0100 | [diff] [blame] | 1508 | if has('float') |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1509 | assert_match('Computing.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1510 | 'var fl = 3.0.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1511 | '\d PUSHF 3.0.*' .. |
| 1512 | '\d STORE $3.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1513 | 'var flres = fl + 7.0.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1514 | '\d LOAD $3.*' .. |
| 1515 | '\d PUSHF 7.0.*' .. |
| 1516 | '\d OPFLOAT +.*' .. |
| 1517 | '\d STORE $4.*' .. |
| 1518 | 'flres = fl - 7.0.*' .. |
| 1519 | '\d OPFLOAT -.*' .. |
| 1520 | 'flres = fl \* 7.0.*' .. |
| 1521 | '\d OPFLOAT \*.*' .. |
| 1522 | 'flres = fl / 7.0.*' .. |
| 1523 | '\d OPFLOAT /.*', |
| 1524 | instr) |
Bram Moolenaar | c2a4b35 | 2020-02-06 22:41:16 +0100 | [diff] [blame] | 1525 | endif |
| 1526 | enddef |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 1527 | |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1528 | def AddListBlob() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1529 | var reslist = [1, 2] + [3, 4] |
| 1530 | var resblob = 0z1122 + 0z3344 |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1531 | enddef |
| 1532 | |
| 1533 | def Test_disassemble_add_list_blob() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1534 | var instr = execute('disassemble AddListBlob') |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1535 | assert_match('AddListBlob.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1536 | 'var reslist = \[1, 2] + \[3, 4].*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1537 | '\d PUSHNR 1.*' .. |
| 1538 | '\d PUSHNR 2.*' .. |
| 1539 | '\d NEWLIST size 2.*' .. |
| 1540 | '\d PUSHNR 3.*' .. |
| 1541 | '\d PUSHNR 4.*' .. |
| 1542 | '\d NEWLIST size 2.*' .. |
| 1543 | '\d ADDLIST.*' .. |
| 1544 | '\d STORE $.*.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1545 | 'var resblob = 0z1122 + 0z3344.*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1546 | '\d PUSHBLOB 0z1122.*' .. |
| 1547 | '\d PUSHBLOB 0z3344.*' .. |
| 1548 | '\d ADDBLOB.*' .. |
| 1549 | '\d STORE $.*', |
| 1550 | instr) |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1551 | enddef |
| 1552 | |
| 1553 | let g:aa = 'aa' |
| 1554 | def ConcatString(): string |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1555 | var res = g:aa .. "bb" |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1556 | return res |
| 1557 | enddef |
| 1558 | |
| 1559 | def Test_disassemble_concat() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1560 | var instr = execute('disassemble ConcatString') |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1561 | assert_match('ConcatString.*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1562 | 'var res = g:aa .. "bb".*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1563 | '\d LOADG g:aa.*' .. |
| 1564 | '\d PUSHS "bb".*' .. |
Bram Moolenaar | 418f1df | 2020-08-12 21:34:49 +0200 | [diff] [blame] | 1565 | '\d 2STRING_ANY stack\[-2].*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1566 | '\d CONCAT.*' .. |
| 1567 | '\d STORE $.*', |
| 1568 | instr) |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1569 | assert_equal('aabb', ConcatString()) |
| 1570 | enddef |
| 1571 | |
Bram Moolenaar | 11107ba | 2020-08-15 21:10:16 +0200 | [diff] [blame] | 1572 | def StringIndex(): string |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1573 | var s = "abcd" |
| 1574 | var res = s[1] |
Bram Moolenaar | 747f11a | 2020-07-19 18:38:37 +0200 | [diff] [blame] | 1575 | return res |
| 1576 | enddef |
| 1577 | |
| 1578 | def Test_disassemble_string_index() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1579 | var instr = execute('disassemble StringIndex') |
Bram Moolenaar | 747f11a | 2020-07-19 18:38:37 +0200 | [diff] [blame] | 1580 | assert_match('StringIndex\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1581 | 'var s = "abcd"\_s*' .. |
Bram Moolenaar | 747f11a | 2020-07-19 18:38:37 +0200 | [diff] [blame] | 1582 | '\d PUSHS "abcd"\_s*' .. |
| 1583 | '\d STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1584 | 'var res = s\[1]\_s*' .. |
Bram Moolenaar | 747f11a | 2020-07-19 18:38:37 +0200 | [diff] [blame] | 1585 | '\d LOAD $0\_s*' .. |
| 1586 | '\d PUSHNR 1\_s*' .. |
| 1587 | '\d STRINDEX\_s*' .. |
| 1588 | '\d STORE $1\_s*', |
| 1589 | instr) |
| 1590 | assert_equal('b', StringIndex()) |
| 1591 | enddef |
| 1592 | |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1593 | def StringSlice(): string |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1594 | var s = "abcd" |
Bram Moolenaar | de4f95b | 2020-12-30 20:39:21 +0100 | [diff] [blame] | 1595 | var res = s[1 : 8] |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1596 | return res |
| 1597 | enddef |
| 1598 | |
| 1599 | def Test_disassemble_string_slice() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1600 | var instr = execute('disassemble StringSlice') |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1601 | assert_match('StringSlice\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1602 | 'var s = "abcd"\_s*' .. |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1603 | '\d PUSHS "abcd"\_s*' .. |
| 1604 | '\d STORE $0\_s*' .. |
Bram Moolenaar | de4f95b | 2020-12-30 20:39:21 +0100 | [diff] [blame] | 1605 | 'var res = s\[1 : 8]\_s*' .. |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1606 | '\d LOAD $0\_s*' .. |
| 1607 | '\d PUSHNR 1\_s*' .. |
| 1608 | '\d PUSHNR 8\_s*' .. |
| 1609 | '\d STRSLICE\_s*' .. |
| 1610 | '\d STORE $1\_s*', |
| 1611 | instr) |
| 1612 | assert_equal('bcd', StringSlice()) |
| 1613 | enddef |
| 1614 | |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1615 | def ListIndex(): number |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1616 | var l = [1, 2, 3] |
| 1617 | var res = l[1] |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1618 | return res |
| 1619 | enddef |
| 1620 | |
| 1621 | def Test_disassemble_list_index() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1622 | var instr = execute('disassemble ListIndex') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1623 | assert_match('ListIndex\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1624 | 'var l = \[1, 2, 3]\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1625 | '\d PUSHNR 1\_s*' .. |
| 1626 | '\d PUSHNR 2\_s*' .. |
| 1627 | '\d PUSHNR 3\_s*' .. |
| 1628 | '\d NEWLIST size 3\_s*' .. |
| 1629 | '\d STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1630 | 'var res = l\[1]\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1631 | '\d LOAD $0\_s*' .. |
| 1632 | '\d PUSHNR 1\_s*' .. |
Bram Moolenaar | 747f11a | 2020-07-19 18:38:37 +0200 | [diff] [blame] | 1633 | '\d LISTINDEX\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1634 | '\d STORE $1\_s*', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1635 | instr) |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1636 | assert_equal(2, ListIndex()) |
| 1637 | enddef |
| 1638 | |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1639 | def ListSlice(): list<number> |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1640 | var l = [1, 2, 3] |
Bram Moolenaar | de4f95b | 2020-12-30 20:39:21 +0100 | [diff] [blame] | 1641 | var res = l[1 : 8] |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1642 | return res |
| 1643 | enddef |
| 1644 | |
| 1645 | def Test_disassemble_list_slice() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1646 | var instr = execute('disassemble ListSlice') |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1647 | assert_match('ListSlice\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1648 | 'var l = \[1, 2, 3]\_s*' .. |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1649 | '\d PUSHNR 1\_s*' .. |
| 1650 | '\d PUSHNR 2\_s*' .. |
| 1651 | '\d PUSHNR 3\_s*' .. |
| 1652 | '\d NEWLIST size 3\_s*' .. |
| 1653 | '\d STORE $0\_s*' .. |
Bram Moolenaar | de4f95b | 2020-12-30 20:39:21 +0100 | [diff] [blame] | 1654 | 'var res = l\[1 : 8]\_s*' .. |
Bram Moolenaar | ed59187 | 2020-08-15 22:14:53 +0200 | [diff] [blame] | 1655 | '\d LOAD $0\_s*' .. |
| 1656 | '\d PUSHNR 1\_s*' .. |
| 1657 | '\d PUSHNR 8\_s*' .. |
| 1658 | '\d LISTSLICE\_s*' .. |
| 1659 | '\d STORE $1\_s*', |
| 1660 | instr) |
| 1661 | assert_equal([2, 3], ListSlice()) |
| 1662 | enddef |
| 1663 | |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1664 | def DictMember(): number |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1665 | var d = {item: 1} |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1666 | var res = d.item |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1667 | res = d["item"] |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1668 | return res |
| 1669 | enddef |
| 1670 | |
| 1671 | def Test_disassemble_dict_member() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1672 | var instr = execute('disassemble DictMember') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1673 | assert_match('DictMember\_s*' .. |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1674 | 'var d = {item: 1}\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1675 | '\d PUSHS "item"\_s*' .. |
| 1676 | '\d PUSHNR 1\_s*' .. |
| 1677 | '\d NEWDICT size 1\_s*' .. |
| 1678 | '\d STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1679 | 'var res = d.item\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1680 | '\d\+ LOAD $0\_s*' .. |
| 1681 | '\d\+ MEMBER item\_s*' .. |
Bram Moolenaar | b1b6f4d | 2021-09-13 18:25:54 +0200 | [diff] [blame] | 1682 | '\d\+ USEDICT\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1683 | '\d\+ STORE $1\_s*' .. |
| 1684 | 'res = d\["item"\]\_s*' .. |
| 1685 | '\d\+ LOAD $0\_s*' .. |
| 1686 | '\d\+ PUSHS "item"\_s*' .. |
| 1687 | '\d\+ MEMBER\_s*' .. |
Bram Moolenaar | b1b6f4d | 2021-09-13 18:25:54 +0200 | [diff] [blame] | 1688 | '\d\+ USEDICT\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1689 | '\d\+ STORE $1\_s*', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1690 | instr) |
Bram Moolenaar | d2c6170 | 2020-09-06 15:58:36 +0200 | [diff] [blame] | 1691 | assert_equal(1, DictMember()) |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1692 | enddef |
| 1693 | |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1694 | let somelist = [1, 2, 3, 4, 5] |
| 1695 | def AnyIndex(): number |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1696 | var res = g:somelist[2] |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1697 | return res |
| 1698 | enddef |
| 1699 | |
| 1700 | def Test_disassemble_any_index() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1701 | var instr = execute('disassemble AnyIndex') |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1702 | assert_match('AnyIndex\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1703 | 'var res = g:somelist\[2\]\_s*' .. |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1704 | '\d LOADG g:somelist\_s*' .. |
| 1705 | '\d PUSHNR 2\_s*' .. |
| 1706 | '\d ANYINDEX\_s*' .. |
| 1707 | '\d STORE $0\_s*' .. |
| 1708 | 'return res\_s*' .. |
| 1709 | '\d LOAD $0\_s*' .. |
| 1710 | '\d CHECKTYPE number stack\[-1\]\_s*' .. |
| 1711 | '\d RETURN', |
| 1712 | instr) |
| 1713 | assert_equal(3, AnyIndex()) |
| 1714 | enddef |
| 1715 | |
| 1716 | def AnySlice(): list<number> |
Bram Moolenaar | de4f95b | 2020-12-30 20:39:21 +0100 | [diff] [blame] | 1717 | var res = g:somelist[1 : 3] |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1718 | return res |
| 1719 | enddef |
| 1720 | |
| 1721 | def Test_disassemble_any_slice() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1722 | var instr = execute('disassemble AnySlice') |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1723 | assert_match('AnySlice\_s*' .. |
Bram Moolenaar | de4f95b | 2020-12-30 20:39:21 +0100 | [diff] [blame] | 1724 | 'var res = g:somelist\[1 : 3\]\_s*' .. |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1725 | '\d LOADG g:somelist\_s*' .. |
| 1726 | '\d PUSHNR 1\_s*' .. |
| 1727 | '\d PUSHNR 3\_s*' .. |
| 1728 | '\d ANYSLICE\_s*' .. |
| 1729 | '\d STORE $0\_s*' .. |
| 1730 | 'return res\_s*' .. |
| 1731 | '\d LOAD $0\_s*' .. |
Bram Moolenaar | 5e65423 | 2020-09-16 15:22:00 +0200 | [diff] [blame] | 1732 | '\d CHECKTYPE list<number> stack\[-1\]\_s*' .. |
Bram Moolenaar | cc673e7 | 2020-08-16 17:33:35 +0200 | [diff] [blame] | 1733 | '\d RETURN', |
| 1734 | instr) |
| 1735 | assert_equal([2, 3, 4], AnySlice()) |
| 1736 | enddef |
| 1737 | |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1738 | def NegateNumber(): number |
Bram Moolenaar | cd6b4f3 | 2021-08-15 20:36:28 +0200 | [diff] [blame] | 1739 | g:nr = 9 |
| 1740 | var plus = +g:nr |
| 1741 | var minus = -g:nr |
| 1742 | return minus |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1743 | enddef |
| 1744 | |
| 1745 | def Test_disassemble_negate_number() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1746 | var instr = execute('disassemble NegateNumber') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1747 | assert_match('NegateNumber\_s*' .. |
Bram Moolenaar | cd6b4f3 | 2021-08-15 20:36:28 +0200 | [diff] [blame] | 1748 | 'g:nr = 9\_s*' .. |
| 1749 | '\d PUSHNR 9\_s*' .. |
| 1750 | '\d STOREG g:nr\_s*' .. |
| 1751 | 'var plus = +g:nr\_s*' .. |
| 1752 | '\d LOADG g:nr\_s*' .. |
| 1753 | '\d CHECKTYPE number stack\[-1\]\_s*' .. |
| 1754 | '\d STORE $0\_s*' .. |
| 1755 | 'var minus = -g:nr\_s*' .. |
| 1756 | '\d LOADG g:nr\_s*' .. |
| 1757 | '\d CHECKTYPE number stack\[-1\]\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1758 | '\d NEGATENR\_s*' .. |
Bram Moolenaar | cd6b4f3 | 2021-08-15 20:36:28 +0200 | [diff] [blame] | 1759 | '\d STORE $1\_s*', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1760 | instr) |
Bram Moolenaar | d2c6170 | 2020-09-06 15:58:36 +0200 | [diff] [blame] | 1761 | assert_equal(-9, NegateNumber()) |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1762 | enddef |
| 1763 | |
| 1764 | def InvertBool(): bool |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1765 | var flag = true |
| 1766 | var invert = !flag |
| 1767 | var res = !!flag |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1768 | return res |
| 1769 | enddef |
| 1770 | |
| 1771 | def Test_disassemble_invert_bool() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1772 | var instr = execute('disassemble InvertBool') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1773 | assert_match('InvertBool\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1774 | 'var flag = true\_s*' .. |
Bram Moolenaar | a8b8af1 | 2021-01-01 15:11:04 +0100 | [diff] [blame] | 1775 | '\d PUSH true\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1776 | '\d STORE $0\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1777 | 'var invert = !flag\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1778 | '\d LOAD $0\_s*' .. |
Bram Moolenaar | 5fa9b24 | 2021-06-04 21:00:32 +0200 | [diff] [blame] | 1779 | '\d INVERT -1 (!val)\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1780 | '\d STORE $1\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1781 | 'var res = !!flag\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1782 | '\d LOAD $0\_s*' .. |
Bram Moolenaar | 5fa9b24 | 2021-06-04 21:00:32 +0200 | [diff] [blame] | 1783 | '\d 2BOOL -1 (!!val)\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 1784 | '\d STORE $2\_s*', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1785 | instr) |
Bram Moolenaar | d2c6170 | 2020-09-06 15:58:36 +0200 | [diff] [blame] | 1786 | assert_equal(true, InvertBool()) |
Bram Moolenaar | ee2e52a | 2020-02-19 14:17:18 +0100 | [diff] [blame] | 1787 | enddef |
| 1788 | |
Bram Moolenaar | 4ed124c | 2020-09-09 20:03:46 +0200 | [diff] [blame] | 1789 | def ReturnBool(): bool |
Bram Moolenaar | 1a7ee4d | 2021-09-16 16:15:07 +0200 | [diff] [blame] | 1790 | var one = 1 |
| 1791 | var zero = 0 |
Bram Moolenaar | 5cd6479 | 2021-12-25 18:23:24 +0000 | [diff] [blame] | 1792 | var none: number |
Bram Moolenaar | 1a7ee4d | 2021-09-16 16:15:07 +0200 | [diff] [blame] | 1793 | var name: bool = one && zero || one |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 1794 | return name |
Bram Moolenaar | 4ed124c | 2020-09-09 20:03:46 +0200 | [diff] [blame] | 1795 | enddef |
| 1796 | |
| 1797 | def Test_disassemble_return_bool() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1798 | var instr = execute('disassemble ReturnBool') |
Bram Moolenaar | 4ed124c | 2020-09-09 20:03:46 +0200 | [diff] [blame] | 1799 | assert_match('ReturnBool\_s*' .. |
Bram Moolenaar | 1a7ee4d | 2021-09-16 16:15:07 +0200 | [diff] [blame] | 1800 | 'var one = 1\_s*' .. |
| 1801 | '0 STORE 1 in $0\_s*' .. |
| 1802 | 'var zero = 0\_s*' .. |
Bram Moolenaar | 5cd6479 | 2021-12-25 18:23:24 +0000 | [diff] [blame] | 1803 | 'var none: number\_s*' .. |
Bram Moolenaar | 1a7ee4d | 2021-09-16 16:15:07 +0200 | [diff] [blame] | 1804 | 'var name: bool = one && zero || one\_s*' .. |
Bram Moolenaar | 5cd6479 | 2021-12-25 18:23:24 +0000 | [diff] [blame] | 1805 | '1 LOAD $0\_s*' .. |
| 1806 | '2 COND2BOOL\_s*' .. |
| 1807 | '3 JUMP_IF_COND_FALSE -> 6\_s*' .. |
| 1808 | '4 LOAD $1\_s*' .. |
| 1809 | '5 COND2BOOL\_s*' .. |
| 1810 | '6 JUMP_IF_COND_TRUE -> 9\_s*' .. |
| 1811 | '7 LOAD $0\_s*' .. |
| 1812 | '8 COND2BOOL\_s*' .. |
| 1813 | '9 STORE $3\_s*' .. |
Bram Moolenaar | 2bb2658 | 2020-10-03 22:52:39 +0200 | [diff] [blame] | 1814 | 'return name\_s*' .. |
Bram Moolenaar | 5cd6479 | 2021-12-25 18:23:24 +0000 | [diff] [blame] | 1815 | '\d\+ LOAD $3\_s*' .. |
Bram Moolenaar | ea2d407 | 2020-11-12 12:08:51 +0100 | [diff] [blame] | 1816 | '\d\+ RETURN', |
Bram Moolenaar | 4ed124c | 2020-09-09 20:03:46 +0200 | [diff] [blame] | 1817 | instr) |
| 1818 | assert_equal(true, InvertBool()) |
| 1819 | enddef |
| 1820 | |
Bram Moolenaar | fb9dcb0 | 2021-12-25 22:00:49 +0000 | [diff] [blame] | 1821 | def AutoInit() |
| 1822 | var t: number |
| 1823 | t = 1 |
| 1824 | t = 0 |
| 1825 | enddef |
| 1826 | |
| 1827 | def Test_disassemble_auto_init() |
| 1828 | var instr = execute('disassemble AutoInit') |
| 1829 | assert_match('AutoInit\_s*' .. |
| 1830 | 'var t: number\_s*' .. |
| 1831 | 't = 1\_s*' .. |
| 1832 | '\d STORE 1 in $0\_s*' .. |
| 1833 | 't = 0\_s*' .. |
| 1834 | '\d STORE 0 in $0\_s*' .. |
| 1835 | '\d\+ RETURN void', |
| 1836 | instr) |
| 1837 | enddef |
| 1838 | |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1839 | def Test_disassemble_compare() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1840 | var cases = [ |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1841 | ['true == isFalse', 'COMPAREBOOL =='], |
| 1842 | ['true != isFalse', 'COMPAREBOOL !='], |
| 1843 | ['v:none == isNull', 'COMPARESPECIAL =='], |
| 1844 | ['v:none != isNull', 'COMPARESPECIAL !='], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1845 | |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1846 | ['111 == aNumber', 'COMPARENR =='], |
| 1847 | ['111 != aNumber', 'COMPARENR !='], |
| 1848 | ['111 > aNumber', 'COMPARENR >'], |
| 1849 | ['111 < aNumber', 'COMPARENR <'], |
| 1850 | ['111 >= aNumber', 'COMPARENR >='], |
| 1851 | ['111 <= aNumber', 'COMPARENR <='], |
| 1852 | ['111 =~ aNumber', 'COMPARENR =\~'], |
| 1853 | ['111 !~ aNumber', 'COMPARENR !\~'], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1854 | |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1855 | ['"xx" != aString', 'COMPARESTRING !='], |
| 1856 | ['"xx" > aString', 'COMPARESTRING >'], |
| 1857 | ['"xx" < aString', 'COMPARESTRING <'], |
| 1858 | ['"xx" >= aString', 'COMPARESTRING >='], |
| 1859 | ['"xx" <= aString', 'COMPARESTRING <='], |
| 1860 | ['"xx" =~ aString', 'COMPARESTRING =\~'], |
| 1861 | ['"xx" !~ aString', 'COMPARESTRING !\~'], |
| 1862 | ['"xx" is aString', 'COMPARESTRING is'], |
| 1863 | ['"xx" isnot aString', 'COMPARESTRING isnot'], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1864 | |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1865 | ['0z11 == aBlob', 'COMPAREBLOB =='], |
| 1866 | ['0z11 != aBlob', 'COMPAREBLOB !='], |
| 1867 | ['0z11 is aBlob', 'COMPAREBLOB is'], |
| 1868 | ['0z11 isnot aBlob', 'COMPAREBLOB isnot'], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1869 | |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1870 | ['[1, 2] == aList', 'COMPARELIST =='], |
| 1871 | ['[1, 2] != aList', 'COMPARELIST !='], |
| 1872 | ['[1, 2] is aList', 'COMPARELIST is'], |
| 1873 | ['[1, 2] isnot aList', 'COMPARELIST isnot'], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1874 | |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1875 | ['{a: 1} == aDict', 'COMPAREDICT =='], |
| 1876 | ['{a: 1} != aDict', 'COMPAREDICT !='], |
| 1877 | ['{a: 1} is aDict', 'COMPAREDICT is'], |
| 1878 | ['{a: 1} isnot aDict', 'COMPAREDICT isnot'], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1879 | |
Bram Moolenaar | 2949cfd | 2020-12-31 21:28:47 +0100 | [diff] [blame] | 1880 | ['(() => 33) == (() => 44)', 'COMPAREFUNC =='], |
| 1881 | ['(() => 33) != (() => 44)', 'COMPAREFUNC !='], |
| 1882 | ['(() => 33) is (() => 44)', 'COMPAREFUNC is'], |
| 1883 | ['(() => 33) isnot (() => 44)', 'COMPAREFUNC isnot'], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1884 | |
| 1885 | ['77 == g:xx', 'COMPAREANY =='], |
| 1886 | ['77 != g:xx', 'COMPAREANY !='], |
| 1887 | ['77 > g:xx', 'COMPAREANY >'], |
| 1888 | ['77 < g:xx', 'COMPAREANY <'], |
| 1889 | ['77 >= g:xx', 'COMPAREANY >='], |
| 1890 | ['77 <= g:xx', 'COMPAREANY <='], |
| 1891 | ['77 =~ g:xx', 'COMPAREANY =\~'], |
| 1892 | ['77 !~ g:xx', 'COMPAREANY !\~'], |
| 1893 | ['77 is g:xx', 'COMPAREANY is'], |
| 1894 | ['77 isnot g:xx', 'COMPAREANY isnot'], |
| 1895 | ] |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1896 | var floatDecl = '' |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1897 | if has('float') |
| 1898 | cases->extend([ |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1899 | ['1.1 == aFloat', 'COMPAREFLOAT =='], |
| 1900 | ['1.1 != aFloat', 'COMPAREFLOAT !='], |
| 1901 | ['1.1 > aFloat', 'COMPAREFLOAT >'], |
| 1902 | ['1.1 < aFloat', 'COMPAREFLOAT <'], |
| 1903 | ['1.1 >= aFloat', 'COMPAREFLOAT >='], |
| 1904 | ['1.1 <= aFloat', 'COMPAREFLOAT <='], |
| 1905 | ['1.1 =~ aFloat', 'COMPAREFLOAT =\~'], |
| 1906 | ['1.1 !~ aFloat', 'COMPAREFLOAT !\~'], |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1907 | ]) |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1908 | floatDecl = 'var aFloat = 2.2' |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1909 | endif |
| 1910 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1911 | var nr = 1 |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1912 | for case in cases |
Bram Moolenaar | f5be8cd | 2020-07-17 20:36:00 +0200 | [diff] [blame] | 1913 | # declare local variables to get a non-constant with the right type |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1914 | writefile(['def TestCase' .. nr .. '()', |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1915 | ' var isFalse = false', |
| 1916 | ' var isNull = v:null', |
| 1917 | ' var aNumber = 222', |
| 1918 | ' var aString = "yy"', |
| 1919 | ' var aBlob = 0z22', |
| 1920 | ' var aList = [3, 4]', |
Bram Moolenaar | e0de171 | 2020-12-02 17:36:54 +0100 | [diff] [blame] | 1921 | ' var aDict = {x: 2}', |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1922 | floatDecl, |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1923 | ' if ' .. case[0], |
| 1924 | ' echo 42' |
| 1925 | ' endif', |
| 1926 | 'enddef'], 'Xdisassemble') |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1927 | source Xdisassemble |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1928 | var instr = execute('disassemble TestCase' .. nr) |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1929 | assert_match('TestCase' .. nr .. '.*' .. |
| 1930 | 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' .. |
| 1931 | '\d \(PUSH\|FUNCREF\).*' .. |
Bram Moolenaar | a5565e4 | 2020-05-09 15:44:01 +0200 | [diff] [blame] | 1932 | '\d \(PUSH\|FUNCREF\|LOAD\).*' .. |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1933 | '\d ' .. case[1] .. '.*' .. |
| 1934 | '\d JUMP_IF_FALSE -> \d\+.*', |
| 1935 | instr) |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1936 | |
| 1937 | nr += 1 |
| 1938 | endfor |
| 1939 | |
Bram Moolenaar | 22da559 | 2020-03-19 14:52:20 +0100 | [diff] [blame] | 1940 | delete('Xdisassemble') |
Bram Moolenaar | f2460a3 | 2020-02-07 22:09:54 +0100 | [diff] [blame] | 1941 | enddef |
| 1942 | |
Bram Moolenaar | 92f26c2 | 2020-10-03 20:17:30 +0200 | [diff] [blame] | 1943 | def s:FalsyOp() |
| 1944 | echo g:flag ?? "yes" |
| 1945 | echo [] ?? "empty list" |
| 1946 | echo "" ?? "empty string" |
| 1947 | enddef |
| 1948 | |
| 1949 | def Test_dsassemble_falsy_op() |
| 1950 | var res = execute('disass s:FalsyOp') |
| 1951 | assert_match('\<SNR>\d*_FalsyOp\_s*' .. |
| 1952 | 'echo g:flag ?? "yes"\_s*' .. |
| 1953 | '0 LOADG g:flag\_s*' .. |
| 1954 | '1 JUMP_AND_KEEP_IF_TRUE -> 3\_s*' .. |
| 1955 | '2 PUSHS "yes"\_s*' .. |
| 1956 | '3 ECHO 1\_s*' .. |
| 1957 | 'echo \[\] ?? "empty list"\_s*' .. |
| 1958 | '4 NEWLIST size 0\_s*' .. |
| 1959 | '5 JUMP_AND_KEEP_IF_TRUE -> 7\_s*' .. |
| 1960 | '6 PUSHS "empty list"\_s*' .. |
| 1961 | '7 ECHO 1\_s*' .. |
| 1962 | 'echo "" ?? "empty string"\_s*' .. |
| 1963 | '\d\+ PUSHS "empty string"\_s*' .. |
| 1964 | '\d\+ ECHO 1\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1965 | '\d\+ RETURN void', |
Bram Moolenaar | 92f26c2 | 2020-10-03 20:17:30 +0200 | [diff] [blame] | 1966 | res) |
| 1967 | enddef |
| 1968 | |
Bram Moolenaar | a4d4cf4 | 2020-04-02 13:50:27 +0200 | [diff] [blame] | 1969 | def Test_disassemble_compare_const() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1970 | var cases = [ |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1971 | ['"xx" == "yy"', false], |
| 1972 | ['"aa" == "aa"', true], |
| 1973 | ['has("eval") ? true : false', true], |
| 1974 | ['has("asdf") ? true : false', false], |
| 1975 | ] |
Bram Moolenaar | a4d4cf4 | 2020-04-02 13:50:27 +0200 | [diff] [blame] | 1976 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1977 | var nr = 1 |
Bram Moolenaar | a4d4cf4 | 2020-04-02 13:50:27 +0200 | [diff] [blame] | 1978 | for case in cases |
| 1979 | writefile(['def TestCase' .. nr .. '()', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1980 | ' if ' .. case[0], |
| 1981 | ' echo 42' |
| 1982 | ' endif', |
| 1983 | 'enddef'], 'Xdisassemble') |
Bram Moolenaar | a4d4cf4 | 2020-04-02 13:50:27 +0200 | [diff] [blame] | 1984 | source Xdisassemble |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 1985 | var instr = execute('disassemble TestCase' .. nr) |
Bram Moolenaar | a4d4cf4 | 2020-04-02 13:50:27 +0200 | [diff] [blame] | 1986 | if case[1] |
Bram Moolenaar | f5be8cd | 2020-07-17 20:36:00 +0200 | [diff] [blame] | 1987 | # condition true, "echo 42" executed |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1988 | assert_match('TestCase' .. nr .. '.*' .. |
| 1989 | 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '.*' .. |
| 1990 | '\d PUSHNR 42.*' .. |
| 1991 | '\d ECHO 1.*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 1992 | '\d RETURN void', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1993 | instr) |
Bram Moolenaar | a4d4cf4 | 2020-04-02 13:50:27 +0200 | [diff] [blame] | 1994 | else |
Bram Moolenaar | f5be8cd | 2020-07-17 20:36:00 +0200 | [diff] [blame] | 1995 | # condition false, function just returns |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 1996 | assert_match('TestCase' .. nr .. '.*' .. |
| 1997 | 'if ' .. substitute(case[0], '[[~]', '\\\0', 'g') .. '[ \n]*' .. |
| 1998 | 'echo 42[ \n]*' .. |
| 1999 | 'endif[ \n]*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2000 | '\d RETURN void', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 2001 | instr) |
Bram Moolenaar | a4d4cf4 | 2020-04-02 13:50:27 +0200 | [diff] [blame] | 2002 | endif |
| 2003 | |
| 2004 | nr += 1 |
| 2005 | endfor |
| 2006 | |
| 2007 | delete('Xdisassemble') |
| 2008 | enddef |
| 2009 | |
Bram Moolenaar | ad39c09 | 2020-02-26 18:23:43 +0100 | [diff] [blame] | 2010 | def s:Execute() |
| 2011 | execute 'help vim9.txt' |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2012 | var cmd = 'help vim9.txt' |
Bram Moolenaar | ad39c09 | 2020-02-26 18:23:43 +0100 | [diff] [blame] | 2013 | execute cmd |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2014 | var tag = 'vim9.txt' |
Bram Moolenaar | ad39c09 | 2020-02-26 18:23:43 +0100 | [diff] [blame] | 2015 | execute 'help ' .. tag |
| 2016 | enddef |
| 2017 | |
| 2018 | def Test_disassemble_execute() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2019 | var res = execute('disass s:Execute') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2020 | assert_match('\<SNR>\d*_Execute\_s*' .. |
| 2021 | "execute 'help vim9.txt'\\_s*" .. |
| 2022 | '\d PUSHS "help vim9.txt"\_s*' .. |
| 2023 | '\d EXECUTE 1\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2024 | "var cmd = 'help vim9.txt'\\_s*" .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2025 | '\d PUSHS "help vim9.txt"\_s*' .. |
| 2026 | '\d STORE $0\_s*' .. |
| 2027 | 'execute cmd\_s*' .. |
| 2028 | '\d LOAD $0\_s*' .. |
| 2029 | '\d EXECUTE 1\_s*' .. |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2030 | "var tag = 'vim9.txt'\\_s*" .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2031 | '\d PUSHS "vim9.txt"\_s*' .. |
| 2032 | '\d STORE $1\_s*' .. |
| 2033 | "execute 'help ' .. tag\\_s*" .. |
| 2034 | '\d\+ PUSHS "help "\_s*' .. |
| 2035 | '\d\+ LOAD $1\_s*' .. |
| 2036 | '\d\+ CONCAT\_s*' .. |
| 2037 | '\d\+ EXECUTE 1\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2038 | '\d\+ RETURN void', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 2039 | res) |
Bram Moolenaar | ad39c09 | 2020-02-26 18:23:43 +0100 | [diff] [blame] | 2040 | enddef |
| 2041 | |
Bram Moolenaar | e4eed8c | 2021-12-01 15:22:56 +0000 | [diff] [blame] | 2042 | def s:OnlyRange() |
| 2043 | :$ |
| 2044 | :123 |
| 2045 | :'m |
| 2046 | enddef |
| 2047 | |
| 2048 | def Test_disassemble_range_only() |
| 2049 | var res = execute('disass s:OnlyRange') |
| 2050 | assert_match('\<SNR>\d*_OnlyRange\_s*' .. |
| 2051 | ':$\_s*' .. |
| 2052 | '\d EXECRANGE $\_s*' .. |
| 2053 | ':123\_s*' .. |
| 2054 | '\d EXECRANGE 123\_s*' .. |
| 2055 | ':''m\_s*' .. |
| 2056 | '\d EXECRANGE ''m\_s*' .. |
| 2057 | '\d\+ RETURN void', |
| 2058 | res) |
| 2059 | enddef |
| 2060 | |
Bram Moolenaar | f93c7fe | 2020-04-23 22:16:53 +0200 | [diff] [blame] | 2061 | def s:Echomsg() |
| 2062 | echomsg 'some' 'message' |
Bram Moolenaar | 7de6262 | 2021-08-07 15:05:47 +0200 | [diff] [blame] | 2063 | echoconsole 'nothing' |
Bram Moolenaar | f93c7fe | 2020-04-23 22:16:53 +0200 | [diff] [blame] | 2064 | echoerr 'went' .. 'wrong' |
| 2065 | enddef |
| 2066 | |
| 2067 | def Test_disassemble_echomsg() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2068 | var res = execute('disass s:Echomsg') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2069 | assert_match('\<SNR>\d*_Echomsg\_s*' .. |
| 2070 | "echomsg 'some' 'message'\\_s*" .. |
| 2071 | '\d PUSHS "some"\_s*' .. |
| 2072 | '\d PUSHS "message"\_s*' .. |
| 2073 | '\d ECHOMSG 2\_s*' .. |
Bram Moolenaar | 7de6262 | 2021-08-07 15:05:47 +0200 | [diff] [blame] | 2074 | "echoconsole 'nothing'\\_s*" .. |
| 2075 | '\d PUSHS "nothing"\_s*' .. |
| 2076 | '\d ECHOCONSOLE 1\_s*' .. |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2077 | "echoerr 'went' .. 'wrong'\\_s*" .. |
| 2078 | '\d PUSHS "wentwrong"\_s*' .. |
| 2079 | '\d ECHOERR 1\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2080 | '\d RETURN void', |
Bram Moolenaar | f93c7fe | 2020-04-23 22:16:53 +0200 | [diff] [blame] | 2081 | res) |
| 2082 | enddef |
| 2083 | |
Bram Moolenaar | 61a6d4e | 2020-03-01 23:32:25 +0100 | [diff] [blame] | 2084 | def SomeStringArg(arg: string) |
| 2085 | echo arg |
| 2086 | enddef |
| 2087 | |
| 2088 | def SomeAnyArg(arg: any) |
| 2089 | echo arg |
| 2090 | enddef |
| 2091 | |
| 2092 | def SomeStringArgAndReturn(arg: string): string |
| 2093 | return arg |
| 2094 | enddef |
| 2095 | |
| 2096 | def Test_display_func() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2097 | var res1 = execute('function SomeStringArg') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2098 | assert_match('.* def SomeStringArg(arg: string)\_s*' .. |
| 2099 | '\d *echo arg.*' .. |
| 2100 | ' *enddef', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 2101 | res1) |
Bram Moolenaar | 61a6d4e | 2020-03-01 23:32:25 +0100 | [diff] [blame] | 2102 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2103 | var res2 = execute('function SomeAnyArg') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2104 | assert_match('.* def SomeAnyArg(arg: any)\_s*' .. |
| 2105 | '\d *echo arg\_s*' .. |
| 2106 | ' *enddef', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 2107 | res2) |
Bram Moolenaar | 61a6d4e | 2020-03-01 23:32:25 +0100 | [diff] [blame] | 2108 | |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2109 | var res3 = execute('function SomeStringArgAndReturn') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2110 | assert_match('.* def SomeStringArgAndReturn(arg: string): string\_s*' .. |
| 2111 | '\d *return arg\_s*' .. |
| 2112 | ' *enddef', |
Bram Moolenaar | 675f716 | 2020-04-12 22:53:54 +0200 | [diff] [blame] | 2113 | res3) |
Bram Moolenaar | 61a6d4e | 2020-03-01 23:32:25 +0100 | [diff] [blame] | 2114 | enddef |
| 2115 | |
Bram Moolenaar | 09689a0 | 2020-05-09 22:50:08 +0200 | [diff] [blame] | 2116 | def Test_vim9script_forward_func() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2117 | var lines =<< trim END |
Bram Moolenaar | 09689a0 | 2020-05-09 22:50:08 +0200 | [diff] [blame] | 2118 | vim9script |
| 2119 | def FuncOne(): string |
| 2120 | return FuncTwo() |
| 2121 | enddef |
| 2122 | def FuncTwo(): string |
| 2123 | return 'two' |
| 2124 | enddef |
Bram Moolenaar | 6797966 | 2020-06-20 22:50:47 +0200 | [diff] [blame] | 2125 | g:res_FuncOne = execute('disass FuncOne') |
Bram Moolenaar | 09689a0 | 2020-05-09 22:50:08 +0200 | [diff] [blame] | 2126 | END |
| 2127 | writefile(lines, 'Xdisassemble') |
| 2128 | source Xdisassemble |
| 2129 | |
Bram Moolenaar | f5be8cd | 2020-07-17 20:36:00 +0200 | [diff] [blame] | 2130 | # check that the first function calls the second with DCALL |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2131 | assert_match('\<SNR>\d*_FuncOne\_s*' .. |
| 2132 | 'return FuncTwo()\_s*' .. |
| 2133 | '\d DCALL <SNR>\d\+_FuncTwo(argc 0)\_s*' .. |
Bram Moolenaar | 09689a0 | 2020-05-09 22:50:08 +0200 | [diff] [blame] | 2134 | '\d RETURN', |
| 2135 | g:res_FuncOne) |
| 2136 | |
| 2137 | delete('Xdisassemble') |
| 2138 | unlet g:res_FuncOne |
| 2139 | enddef |
| 2140 | |
Bram Moolenaar | 61a8981 | 2020-05-07 16:58:17 +0200 | [diff] [blame] | 2141 | def s:ConcatStrings(): string |
| 2142 | return 'one' .. 'two' .. 'three' |
| 2143 | enddef |
| 2144 | |
Bram Moolenaar | 7d131b0 | 2020-05-08 19:10:34 +0200 | [diff] [blame] | 2145 | def s:ComputeConst(): number |
| 2146 | return 2 + 3 * 4 / 6 + 7 |
| 2147 | enddef |
| 2148 | |
Bram Moolenaar | 1c74721 | 2020-05-09 18:28:34 +0200 | [diff] [blame] | 2149 | def s:ComputeConstParen(): number |
| 2150 | return ((2 + 4) * (8 / 2)) / (3 + 4) |
| 2151 | enddef |
| 2152 | |
Bram Moolenaar | 61a8981 | 2020-05-07 16:58:17 +0200 | [diff] [blame] | 2153 | def Test_simplify_const_expr() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2154 | var res = execute('disass s:ConcatStrings') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2155 | assert_match('<SNR>\d*_ConcatStrings\_s*' .. |
| 2156 | "return 'one' .. 'two' .. 'three'\\_s*" .. |
| 2157 | '\d PUSHS "onetwothree"\_s*' .. |
Bram Moolenaar | 61a8981 | 2020-05-07 16:58:17 +0200 | [diff] [blame] | 2158 | '\d RETURN', |
| 2159 | res) |
Bram Moolenaar | 7d131b0 | 2020-05-08 19:10:34 +0200 | [diff] [blame] | 2160 | |
| 2161 | res = execute('disass s:ComputeConst') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2162 | assert_match('<SNR>\d*_ComputeConst\_s*' .. |
| 2163 | 'return 2 + 3 \* 4 / 6 + 7\_s*' .. |
| 2164 | '\d PUSHNR 11\_s*' .. |
Bram Moolenaar | 7d131b0 | 2020-05-08 19:10:34 +0200 | [diff] [blame] | 2165 | '\d RETURN', |
| 2166 | res) |
Bram Moolenaar | 1c74721 | 2020-05-09 18:28:34 +0200 | [diff] [blame] | 2167 | |
| 2168 | res = execute('disass s:ComputeConstParen') |
Bram Moolenaar | 4902ab1 | 2020-05-15 19:21:31 +0200 | [diff] [blame] | 2169 | assert_match('<SNR>\d*_ComputeConstParen\_s*' .. |
| 2170 | 'return ((2 + 4) \* (8 / 2)) / (3 + 4)\_s*' .. |
| 2171 | '\d PUSHNR 3\>\_s*' .. |
Bram Moolenaar | 1c74721 | 2020-05-09 18:28:34 +0200 | [diff] [blame] | 2172 | '\d RETURN', |
| 2173 | res) |
Bram Moolenaar | 61a8981 | 2020-05-07 16:58:17 +0200 | [diff] [blame] | 2174 | enddef |
| 2175 | |
Bram Moolenaar | 389df25 | 2020-07-09 21:20:47 +0200 | [diff] [blame] | 2176 | def s:CallAppend() |
| 2177 | eval "some text"->append(2) |
| 2178 | enddef |
| 2179 | |
| 2180 | def Test_shuffle() |
Bram Moolenaar | ac56408 | 2020-09-27 19:05:33 +0200 | [diff] [blame] | 2181 | var res = execute('disass s:CallAppend') |
Bram Moolenaar | 389df25 | 2020-07-09 21:20:47 +0200 | [diff] [blame] | 2182 | assert_match('<SNR>\d*_CallAppend\_s*' .. |
| 2183 | 'eval "some text"->append(2)\_s*' .. |
| 2184 | '\d PUSHS "some text"\_s*' .. |
| 2185 | '\d PUSHNR 2\_s*' .. |
| 2186 | '\d SHUFFLE 2 up 1\_s*' .. |
| 2187 | '\d BCALL append(argc 2)\_s*' .. |
| 2188 | '\d DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2189 | '\d RETURN void', |
Bram Moolenaar | 389df25 | 2020-07-09 21:20:47 +0200 | [diff] [blame] | 2190 | res) |
| 2191 | enddef |
| 2192 | |
Bram Moolenaar | f4c6e1e | 2020-10-23 18:02:32 +0200 | [diff] [blame] | 2193 | |
| 2194 | def s:SilentMessage() |
| 2195 | silent echomsg "text" |
| 2196 | silent! echoerr "error" |
| 2197 | enddef |
| 2198 | |
| 2199 | def Test_silent() |
| 2200 | var res = execute('disass s:SilentMessage') |
| 2201 | assert_match('<SNR>\d*_SilentMessage\_s*' .. |
| 2202 | 'silent echomsg "text"\_s*' .. |
Bram Moolenaar | 02194d2 | 2020-10-24 23:08:38 +0200 | [diff] [blame] | 2203 | '\d CMDMOD silent\_s*' .. |
Bram Moolenaar | f4c6e1e | 2020-10-23 18:02:32 +0200 | [diff] [blame] | 2204 | '\d PUSHS "text"\_s*' .. |
| 2205 | '\d ECHOMSG 1\_s*' .. |
Bram Moolenaar | 02194d2 | 2020-10-24 23:08:38 +0200 | [diff] [blame] | 2206 | '\d CMDMOD_REV\_s*' .. |
Bram Moolenaar | f4c6e1e | 2020-10-23 18:02:32 +0200 | [diff] [blame] | 2207 | 'silent! echoerr "error"\_s*' .. |
Bram Moolenaar | 02194d2 | 2020-10-24 23:08:38 +0200 | [diff] [blame] | 2208 | '\d CMDMOD silent!\_s*' .. |
Bram Moolenaar | f4c6e1e | 2020-10-23 18:02:32 +0200 | [diff] [blame] | 2209 | '\d PUSHS "error"\_s*' .. |
| 2210 | '\d ECHOERR 1\_s*' .. |
Bram Moolenaar | 02194d2 | 2020-10-24 23:08:38 +0200 | [diff] [blame] | 2211 | '\d CMDMOD_REV\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2212 | '\d\+ RETURN void', |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2213 | res) |
| 2214 | enddef |
| 2215 | |
| 2216 | def s:SilentIf() |
| 2217 | silent if 4 == g:five |
| 2218 | silent elseif 4 == g:five |
Bram Moolenaar | fa98441 | 2021-03-25 22:15:28 +0100 | [diff] [blame] | 2219 | endif |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2220 | enddef |
| 2221 | |
| 2222 | def Test_silent_if() |
| 2223 | var res = execute('disass s:SilentIf') |
| 2224 | assert_match('<SNR>\d*_SilentIf\_s*' .. |
| 2225 | 'silent if 4 == g:five\_s*' .. |
| 2226 | '\d\+ CMDMOD silent\_s*' .. |
| 2227 | '\d\+ PUSHNR 4\_s*' .. |
| 2228 | '\d\+ LOADG g:five\_s*' .. |
| 2229 | '\d\+ COMPAREANY ==\_s*' .. |
| 2230 | '\d\+ CMDMOD_REV\_s*' .. |
| 2231 | '\d\+ JUMP_IF_FALSE -> \d\+\_s*' .. |
| 2232 | 'silent elseif 4 == g:five\_s*' .. |
| 2233 | '\d\+ JUMP -> \d\+\_s*' .. |
| 2234 | '\d\+ CMDMOD silent\_s*' .. |
| 2235 | '\d\+ PUSHNR 4\_s*' .. |
| 2236 | '\d\+ LOADG g:five\_s*' .. |
| 2237 | '\d\+ COMPAREANY ==\_s*' .. |
| 2238 | '\d\+ CMDMOD_REV\_s*' .. |
| 2239 | '\d\+ JUMP_IF_FALSE -> \d\+\_s*' .. |
Bram Moolenaar | fa98441 | 2021-03-25 22:15:28 +0100 | [diff] [blame] | 2240 | 'endif\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2241 | '\d\+ RETURN void', |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2242 | res) |
| 2243 | enddef |
| 2244 | |
| 2245 | def s:SilentFor() |
| 2246 | silent for i in [0] |
Bram Moolenaar | fa98441 | 2021-03-25 22:15:28 +0100 | [diff] [blame] | 2247 | endfor |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2248 | enddef |
| 2249 | |
| 2250 | def Test_silent_for() |
| 2251 | var res = execute('disass s:SilentFor') |
| 2252 | assert_match('<SNR>\d*_SilentFor\_s*' .. |
| 2253 | 'silent for i in \[0\]\_s*' .. |
| 2254 | '\d CMDMOD silent\_s*' .. |
| 2255 | '\d STORE -1 in $0\_s*' .. |
| 2256 | '\d PUSHNR 0\_s*' .. |
| 2257 | '\d NEWLIST size 1\_s*' .. |
| 2258 | '\d CMDMOD_REV\_s*' .. |
| 2259 | '5 FOR $0 -> 8\_s*' .. |
| 2260 | '\d STORE $1\_s*' .. |
Bram Moolenaar | fa98441 | 2021-03-25 22:15:28 +0100 | [diff] [blame] | 2261 | 'endfor\_s*' .. |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2262 | '\d JUMP -> 5\_s*' .. |
| 2263 | '8 DROP\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2264 | '\d RETURN void\_s*', |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2265 | res) |
| 2266 | enddef |
| 2267 | |
| 2268 | def s:SilentWhile() |
| 2269 | silent while g:not |
Bram Moolenaar | fa98441 | 2021-03-25 22:15:28 +0100 | [diff] [blame] | 2270 | endwhile |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2271 | enddef |
| 2272 | |
| 2273 | def Test_silent_while() |
| 2274 | var res = execute('disass s:SilentWhile') |
| 2275 | assert_match('<SNR>\d*_SilentWhile\_s*' .. |
| 2276 | 'silent while g:not\_s*' .. |
| 2277 | '0 CMDMOD silent\_s*' .. |
| 2278 | '\d LOADG g:not\_s*' .. |
| 2279 | '\d COND2BOOL\_s*' .. |
| 2280 | '\d CMDMOD_REV\_s*' .. |
| 2281 | '\d JUMP_IF_FALSE -> 6\_s*' .. |
| 2282 | |
Bram Moolenaar | fa98441 | 2021-03-25 22:15:28 +0100 | [diff] [blame] | 2283 | 'endwhile\_s*' .. |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2284 | '\d JUMP -> 0\_s*' .. |
Bram Moolenaar | f57b43c | 2021-06-15 22:13:27 +0200 | [diff] [blame] | 2285 | '6 RETURN void\_s*', |
Bram Moolenaar | a91a713 | 2021-03-25 21:12:15 +0100 | [diff] [blame] | 2286 | res) |
| 2287 | enddef |
| 2288 | |
| 2289 | def s:SilentReturn(): string |
| 2290 | silent return "done" |
| 2291 | enddef |
| 2292 | |
| 2293 | def Test_silent_return() |
| 2294 | var res = execute('disass s:SilentReturn') |
| 2295 | assert_match('<SNR>\d*_SilentReturn\_s*' .. |
| 2296 | 'silent return "done"\_s*' .. |
| 2297 | '\d CMDMOD silent\_s*' .. |
| 2298 | '\d PUSHS "done"\_s*' .. |
| 2299 | '\d CMDMOD_REV\_s*' .. |
| 2300 | '\d RETURN', |
Bram Moolenaar | f4c6e1e | 2020-10-23 18:02:32 +0200 | [diff] [blame] | 2301 | res) |
| 2302 | enddef |
| 2303 | |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2304 | def s:Profiled(): string |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2305 | # comment |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2306 | echo "profiled" |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2307 | # comment |
Bram Moolenaar | 26d7116 | 2021-06-14 21:08:56 +0200 | [diff] [blame] | 2308 | var some = "some text" |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2309 | return "done" |
| 2310 | enddef |
| 2311 | |
| 2312 | def Test_profiled() |
Bram Moolenaar | f002a41 | 2021-01-24 13:34:18 +0100 | [diff] [blame] | 2313 | if !has('profile') |
| 2314 | MissingFeature 'profile' |
| 2315 | endif |
Bram Moolenaar | e99d422 | 2021-06-13 14:01:26 +0200 | [diff] [blame] | 2316 | var res = execute('disass profile s:Profiled') |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2317 | assert_match('<SNR>\d*_Profiled\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2318 | '# comment\_s*' .. |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2319 | 'echo "profiled"\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2320 | '\d PROFILE START line 2\_s*' .. |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2321 | '\d PUSHS "profiled"\_s*' .. |
| 2322 | '\d ECHO 1\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2323 | '# comment\_s*' .. |
Bram Moolenaar | 26d7116 | 2021-06-14 21:08:56 +0200 | [diff] [blame] | 2324 | 'var some = "some text"\_s*' .. |
Bram Moolenaar | ced68a0 | 2021-01-24 17:53:47 +0100 | [diff] [blame] | 2325 | '\d PROFILE END\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2326 | '\d PROFILE START line 4\_s*' .. |
Bram Moolenaar | 26d7116 | 2021-06-14 21:08:56 +0200 | [diff] [blame] | 2327 | '\d PUSHS "some text"\_s*' .. |
| 2328 | '\d STORE $0\_s*' .. |
| 2329 | 'return "done"\_s*' .. |
| 2330 | '\d PROFILE END\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2331 | '\d PROFILE START line 5\_s*' .. |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2332 | '\d PUSHS "done"\_s*' .. |
Bram Moolenaar | 26d7116 | 2021-06-14 21:08:56 +0200 | [diff] [blame] | 2333 | '\d\+ RETURN\_s*' .. |
| 2334 | '\d\+ PROFILE END', |
Bram Moolenaar | b204990 | 2021-01-24 12:53:53 +0100 | [diff] [blame] | 2335 | res) |
| 2336 | enddef |
| 2337 | |
Bram Moolenaar | e99d422 | 2021-06-13 14:01:26 +0200 | [diff] [blame] | 2338 | def Test_debugged() |
| 2339 | var res = execute('disass debug s:Profiled') |
| 2340 | assert_match('<SNR>\d*_Profiled\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2341 | '# comment\_s*' .. |
Bram Moolenaar | e99d422 | 2021-06-13 14:01:26 +0200 | [diff] [blame] | 2342 | 'echo "profiled"\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2343 | '\d DEBUG line 1-2 varcount 0\_s*' .. |
Bram Moolenaar | e99d422 | 2021-06-13 14:01:26 +0200 | [diff] [blame] | 2344 | '\d PUSHS "profiled"\_s*' .. |
| 2345 | '\d ECHO 1\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2346 | '# comment\_s*' .. |
Bram Moolenaar | 26d7116 | 2021-06-14 21:08:56 +0200 | [diff] [blame] | 2347 | 'var some = "some text"\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2348 | '\d DEBUG line 3-4 varcount 0\_s*' .. |
Bram Moolenaar | 26d7116 | 2021-06-14 21:08:56 +0200 | [diff] [blame] | 2349 | '\d PUSHS "some text"\_s*' .. |
| 2350 | '\d STORE $0\_s*' .. |
Bram Moolenaar | e99d422 | 2021-06-13 14:01:26 +0200 | [diff] [blame] | 2351 | 'return "done"\_s*' .. |
Bram Moolenaar | 8cec927 | 2021-06-23 20:20:53 +0200 | [diff] [blame] | 2352 | '\d DEBUG line 5-5 varcount 1\_s*' .. |
Bram Moolenaar | e99d422 | 2021-06-13 14:01:26 +0200 | [diff] [blame] | 2353 | '\d PUSHS "done"\_s*' .. |
| 2354 | '\d RETURN\_s*', |
| 2355 | res) |
| 2356 | enddef |
| 2357 | |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2358 | def s:ElseifConstant() |
| 2359 | if g:value |
| 2360 | echo "one" |
| 2361 | elseif true |
| 2362 | echo "true" |
| 2363 | elseif false |
| 2364 | echo "false" |
| 2365 | endif |
Bram Moolenaar | 1b5f7a6 | 2021-12-21 13:30:42 +0000 | [diff] [blame] | 2366 | if 0 |
| 2367 | echo "yes" |
| 2368 | elseif 0 |
| 2369 | echo "no" |
| 2370 | endif |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2371 | enddef |
| 2372 | |
| 2373 | def Test_debug_elseif_constant() |
Bram Moolenaar | 1b5f7a6 | 2021-12-21 13:30:42 +0000 | [diff] [blame] | 2374 | var res = execute('disass debug s:ElseifConstant') |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2375 | assert_match('<SNR>\d*_ElseifConstant\_s*' .. |
| 2376 | 'if g:value\_s*' .. |
Bram Moolenaar | 1b5f7a6 | 2021-12-21 13:30:42 +0000 | [diff] [blame] | 2377 | '0 DEBUG line 1-1 varcount 0\_s*' .. |
| 2378 | '1 LOADG g:value\_s*' .. |
| 2379 | '2 COND2BOOL\_s*' .. |
| 2380 | '3 JUMP_IF_FALSE -> 8\_s*' .. |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2381 | 'echo "one"\_s*' .. |
Bram Moolenaar | 1b5f7a6 | 2021-12-21 13:30:42 +0000 | [diff] [blame] | 2382 | '4 DEBUG line 2-2 varcount 0\_s*' .. |
| 2383 | '5 PUSHS "one"\_s*' .. |
| 2384 | '6 ECHO 1\_s*' .. |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2385 | 'elseif true\_s*' .. |
Bram Moolenaar | 1b5f7a6 | 2021-12-21 13:30:42 +0000 | [diff] [blame] | 2386 | '7 JUMP -> 12\_s*' .. |
| 2387 | '8 DEBUG line 3-3 varcount 0\_s*' .. |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2388 | 'echo "true"\_s*' .. |
Bram Moolenaar | 1b5f7a6 | 2021-12-21 13:30:42 +0000 | [diff] [blame] | 2389 | '9 DEBUG line 4-4 varcount 0\_s*' .. |
| 2390 | '10 PUSHS "true"\_s*' .. |
| 2391 | '11 ECHO 1\_s*' .. |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2392 | 'elseif false\_s*' .. |
| 2393 | 'echo "false"\_s*' .. |
| 2394 | 'endif\_s*' .. |
Bram Moolenaar | 1b5f7a6 | 2021-12-21 13:30:42 +0000 | [diff] [blame] | 2395 | 'if 0\_s*' .. |
| 2396 | '12 DEBUG line 8-8 varcount 0\_s*' .. |
| 2397 | 'echo "yes"\_s*' .. |
| 2398 | 'elseif 0\_s*' .. |
| 2399 | '13 DEBUG line 11-10 varcount 0\_s*' .. |
| 2400 | 'echo "no"\_s*' .. |
| 2401 | 'endif\_s*' .. |
| 2402 | '14 RETURN void*', |
Bram Moolenaar | 90770b7 | 2021-11-30 20:57:38 +0000 | [diff] [blame] | 2403 | res) |
| 2404 | enddef |
| 2405 | |
Bram Moolenaar | 093165c | 2021-08-22 13:35:31 +0200 | [diff] [blame] | 2406 | def s:DebugElseif() |
| 2407 | var b = false |
| 2408 | if b |
| 2409 | eval 1 + 0 |
| 2410 | silent elseif !b |
| 2411 | eval 2 + 0 |
| 2412 | endif |
| 2413 | enddef |
| 2414 | |
| 2415 | def Test_debug_elseif() |
| 2416 | var res = execute('disass debug s:DebugElseif') |
| 2417 | assert_match('<SNR>\d*_DebugElseif\_s*' .. |
| 2418 | 'var b = false\_s*' .. |
| 2419 | '0 DEBUG line 1-1 varcount 0\_s*' .. |
| 2420 | '1 PUSH false\_s*' .. |
| 2421 | '2 STORE $0\_s*' .. |
| 2422 | |
| 2423 | 'if b\_s*' .. |
| 2424 | '3 DEBUG line 2-2 varcount 1\_s*' .. |
| 2425 | '4 LOAD $0\_s*' .. |
| 2426 | '5 JUMP_IF_FALSE -> 10\_s*' .. |
| 2427 | |
| 2428 | 'eval 1 + 0\_s*' .. |
| 2429 | '6 DEBUG line 3-3 varcount 1\_s*' .. |
| 2430 | '7 PUSHNR 1\_s*' .. |
| 2431 | '8 DROP\_s*' .. |
| 2432 | |
| 2433 | 'silent elseif !b\_s*' .. |
| 2434 | '9 JUMP -> 20\_s*' .. |
| 2435 | '10 CMDMOD silent\_s*' .. |
| 2436 | '11 DEBUG line 4-4 varcount 1\_s*' .. |
| 2437 | '12 LOAD $0\_s*' .. |
| 2438 | '13 INVERT -1 (!val)\_s*' .. |
| 2439 | '14 CMDMOD_REV\_s*' .. |
| 2440 | '15 JUMP_IF_FALSE -> 20\_s*' .. |
| 2441 | |
| 2442 | 'eval 2 + 0\_s*' .. |
| 2443 | '16 DEBUG line 5-5 varcount 1\_s*' .. |
| 2444 | '17 PUSHNR 2\_s*' .. |
| 2445 | '18 DROP\_s*' .. |
| 2446 | |
| 2447 | 'endif\_s*' .. |
| 2448 | '19 DEBUG line 6-6 varcount 1\_s*' .. |
| 2449 | '20 RETURN void*', |
| 2450 | res) |
| 2451 | enddef |
| 2452 | |
Bram Moolenaar | 2b4ecc2 | 2022-01-02 14:08:18 +0000 | [diff] [blame] | 2453 | def s:DebugFor() |
| 2454 | echo "hello" |
| 2455 | for a in [0] |
| 2456 | echo a |
| 2457 | endfor |
| 2458 | enddef |
| 2459 | |
| 2460 | def Test_debug_for() |
| 2461 | var res = execute('disass debug s:DebugFor') |
| 2462 | assert_match('<SNR>\d*_DebugFor\_s*' .. |
| 2463 | 'echo "hello"\_s*' .. |
| 2464 | '0 DEBUG line 1-1 varcount 0\_s*' .. |
| 2465 | '1 PUSHS "hello"\_s*' .. |
| 2466 | '2 ECHO 1\_s*' .. |
| 2467 | |
| 2468 | 'for a in \[0\]\_s*' .. |
| 2469 | '3 DEBUG line 2-2 varcount 0\_s*' .. |
| 2470 | '4 STORE -1 in $0\_s*' .. |
| 2471 | '5 PUSHNR 0\_s*' .. |
| 2472 | '6 NEWLIST size 1\_s*' .. |
| 2473 | '7 DEBUG line 2-2 varcount 2\_s*' .. |
| 2474 | '8 FOR $0 -> 15\_s*' .. |
| 2475 | '9 STORE $1\_s*' .. |
| 2476 | |
| 2477 | 'echo a\_s*' .. |
| 2478 | '10 DEBUG line 3-3 varcount 2\_s*' .. |
| 2479 | '11 LOAD $1\_s*' .. |
| 2480 | '12 ECHO 1\_s*' .. |
| 2481 | |
| 2482 | 'endfor\_s*' .. |
| 2483 | '13 DEBUG line 4-4 varcount 2\_s*' .. |
| 2484 | '14 JUMP -> 7\_s*' .. |
| 2485 | '15 DROP\_s*' .. |
| 2486 | '16 RETURN void*', |
| 2487 | res) |
| 2488 | enddef |
| 2489 | |
Bram Moolenaar | b1b6f4d | 2021-09-13 18:25:54 +0200 | [diff] [blame] | 2490 | func Legacy() dict |
| 2491 | echo 'legacy' |
| 2492 | endfunc |
| 2493 | |
| 2494 | def s:UseMember() |
| 2495 | var d = {func: Legacy} |
| 2496 | var v = d.func() |
| 2497 | enddef |
| 2498 | |
| 2499 | def Test_disassemble_dict_stack() |
| 2500 | var res = execute('disass s:UseMember') |
| 2501 | assert_match('<SNR>\d*_UseMember\_s*' .. |
| 2502 | 'var d = {func: Legacy}\_s*' .. |
| 2503 | '\d PUSHS "func"\_s*' .. |
Bram Moolenaar | b15cf44 | 2021-12-16 15:49:43 +0000 | [diff] [blame] | 2504 | '\d PUSHFUNC "g:Legacy"\_s*' .. |
Bram Moolenaar | b1b6f4d | 2021-09-13 18:25:54 +0200 | [diff] [blame] | 2505 | '\d NEWDICT size 1\_s*' .. |
| 2506 | '\d STORE $0\_s*' .. |
| 2507 | |
| 2508 | 'var v = d.func()\_s*' .. |
| 2509 | '\d LOAD $0\_s*' .. |
| 2510 | '\d MEMBER func\_s*' .. |
| 2511 | '\d PCALL top (argc 0)\_s*' .. |
| 2512 | '\d PCALL end\_s*' .. |
| 2513 | '\d CLEARDICT\_s*' .. |
| 2514 | '\d\+ STORE $1\_s*' .. |
| 2515 | '\d\+ RETURN void*', |
| 2516 | res) |
| 2517 | enddef |
| 2518 | |
Bram Moolenaar | f62d739 | 2021-04-14 12:40:00 +0200 | [diff] [blame] | 2519 | def s:EchoMessages() |
| 2520 | echohl ErrorMsg | echom v:exception | echohl NONE |
| 2521 | enddef |
| 2522 | |
| 2523 | def Test_disassemble_nextcmd() |
| 2524 | # splitting commands and removing trailing blanks should not change the line |
| 2525 | var res = execute('disass s:EchoMessages') |
| 2526 | assert_match('<SNR>\d*_EchoMessages\_s*' .. |
| 2527 | 'echohl ErrorMsg | echom v:exception | echohl NONE', |
| 2528 | res) |
| 2529 | enddef |
| 2530 | |
Bram Moolenaar | 6db660b | 2021-08-01 14:08:54 +0200 | [diff] [blame] | 2531 | def Test_disassemble_after_reload() |
| 2532 | var lines =<< trim END |
| 2533 | vim9script |
| 2534 | if exists('g:ThisFunc') |
| 2535 | finish |
| 2536 | endif |
| 2537 | var name: any |
| 2538 | def g:ThisFunc(): number |
| 2539 | g:name = name |
| 2540 | return 0 |
| 2541 | enddef |
| 2542 | def g:ThatFunc(): number |
| 2543 | name = g:name |
| 2544 | return 0 |
| 2545 | enddef |
| 2546 | END |
| 2547 | lines->writefile('Xreload.vim') |
| 2548 | |
| 2549 | source Xreload.vim |
| 2550 | g:ThisFunc() |
| 2551 | g:ThatFunc() |
| 2552 | |
| 2553 | source Xreload.vim |
| 2554 | var res = execute('disass g:ThisFunc') |
| 2555 | assert_match('ThisFunc\_s*' .. |
| 2556 | 'g:name = name\_s*' .. |
| 2557 | '\d LOADSCRIPT \[deleted\] from .*/Xreload.vim\_s*' .. |
| 2558 | '\d STOREG g:name\_s*' .. |
| 2559 | 'return 0\_s*' .. |
| 2560 | '\d PUSHNR 0\_s*' .. |
| 2561 | '\d RETURN\_s*', |
| 2562 | res) |
| 2563 | |
| 2564 | res = execute('disass g:ThatFunc') |
| 2565 | assert_match('ThatFunc\_s*' .. |
| 2566 | 'name = g:name\_s*' .. |
| 2567 | '\d LOADG g:name\_s*' .. |
| 2568 | '\d STORESCRIPT \[deleted\] in .*/Xreload.vim\_s*' .. |
| 2569 | 'return 0\_s*' .. |
| 2570 | '\d PUSHNR 0\_s*' .. |
| 2571 | '\d RETURN\_s*', |
| 2572 | res) |
| 2573 | |
| 2574 | delete('Xreload.vim') |
| 2575 | delfunc g:ThisFunc |
| 2576 | delfunc g:ThatFunc |
| 2577 | enddef |
| 2578 | |
Bram Moolenaar | 7cd2422 | 2021-01-12 18:58:39 +0100 | [diff] [blame] | 2579 | |
Bram Moolenaar | b1b6f4d | 2021-09-13 18:25:54 +0200 | [diff] [blame] | 2580 | |
Bram Moolenaar | 5cab73f | 2020-02-06 19:25:19 +0100 | [diff] [blame] | 2581 | " vim: ts=8 sw=2 sts=2 expandtab tw=80 fdm=marker |