NAME=ragg2 -a x86 -b 64 -e 'main@global{main(123)}'
FILE=-
CMDS=!ragg2 -a x86 -b 64 -e 'main@global{main(123)}'
EXPECT=<<EOF
48c7c07b00000050c3
EOF
RUN

NAME=ragg2 -a x86 -b 64 -p A200 -d 50:0xccccccb
FILE=-
CMDS=!ragg2 -a x86 -b 64 -p A200 -d 50:0xccccccb
EXPECT=<<EOF
4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141cbcccc0c4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141
EOF
RUN

NAME=ragg2 -a x86 -b 64 -p A200 -d 50:0xcb
FILE=-
CMDS=!ragg2 -a x86 -b 64 -p A200 -d 50:0xcb
EXPECT=<<EOF
4141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141cb0000004141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141414141
EOF
RUN

NAME=ragg2 -a x86 -b 64 -p A10 -d 50:0xcb
FILE=-
CMDS=!ragg2 -a x86 -b 64 -p A10 -d 50:0xcb
EXPECT=<<EOF
41414141414141414141
EOF
EXPECT_ERR=<<EOF
ERROR: Cannot patch outside
EOF
RUN

NAME=ragg2 -a x86 -b 64 -p A20 -w 10:cb
FILE=-
CMDS=!ragg2 -a x86 -b 64 -p A20 -w 10:cb
EXPECT=<<EOF
41414141414141414141cb414141414141414141
EOF
RUN

NAME=ragg2 -a x86 -b 64 -p A20 -D 10:33
FILE=-
CMDS=!ragg2 -a x86 -b 64 -p A20 -D 10:33
EXPECT=<<EOF
4141414141414141414121000000000000004141
EOF
RUN

NAME=ragg2 -a x86 -b 64 -p n2t2a2s2
FILE=-
CMDS=!ragg2 -a x86 -b 64 -p n2t2a2s2
EXPECT=<<EOF
00004141cccc9090
EOF
RUN

NAME=ragg2 -i exec -z -a x86 -b32
FILE=-
CMDS=!ragg2 -i exec -z -k linux -a x86 -b32
EXPECT=<<EOF
"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x53\x89\xe1\x99\xb0\x0b\xcd\x80"
EOF
RUN

NAME=ragg2 -k linux -i exec  -a x86 -b32 -p n3N3
FILE=-
CMDS=!ragg2 -k linux -i exec  -a x86 -b32 -p n3N3
EXPECT=<<EOF
90909031c050682f2f7368682f62696e89e3505389e199b00bcd80909090
EOF
RUN

NAME=ragg2 -p n80 -w 79:c3 -x
FILE=-
CMDS=!ragg2 -p n80 -w 79:c3 -x
EXPECT=<<EOF
EOF
RUN

NAME=ragg2 -q 0x45414146
FILE=-
CMDS=!ragg2 -q 0x45414146
EXPECT=<<EOF
Little endian: -1
Big endian: 12
EOF
RUN

NAME=ragg2 -q 45414146
FILE=-
CMDS=!ragg2 -q 45414146
EXPECT=<<EOF
EOF
RUN

NAME=ragg2 -k linux -a x86 -b32 simple_cmp.r
BROKEN=1
FILE=-
CMDS=!ragg2 -k linux -a x86 -b32 bins/other/ragg2/simple_cmp.r
EXPECT=<<EOF
5589e581ec80000000c745086869210ac7450c6e000000c74510000000008d4508898504000000c7450501000000c745060200000055583b45060f8f5a0000006a04546a018b1c248b8c24040000008b942408000000b804000000cd8083c40c6a008b1c24b801000000cd8083c40481c4800000005dc3
EOF
RUN

NAME=ragg2 bugg8.r
FILE=-
CMDS=!ragg2 bins/other/ragg2/bugg8.r > /dev/null
EXPECT=<<EOF
EOF
RUN

NAME=ragg2 fastcall declarations do not emit x86 asm garbage
FILE=unit/legacy_unit/ragg2/fastcall-decls.r
CMDS=!ragg2 -a x86 -b 32 -s unit/legacy_unit/ragg2/fastcall-decls.r
EXPECT=<<EOF
.equ bar,4

.global main
main:
  ret


EOF
RUN

NAME=ragg2 fastcall declarations emit x64 aliases without garbage
FILE=unit/legacy_unit/ragg2/fastcall-decls.r
CMDS=!ragg2 -a x86 -b 64 -s unit/legacy_unit/ragg2/fastcall-decls.r
EXPECT=<<EOF
.equ bar,4

.global main
main:
  ret


EOF
RUN

NAME=ragg2 issue25590 basic arm fastcall sample emits valid thumb asm
FILE=unit/legacy_unit/ragg2/fastcall-basic.r
CMDS=!ragg2 -s -a arm -b 16 unit/legacy_unit/ragg2/fastcall-basic.r
EXPECT=<<EOF
.equ printf, 0x1fa0b4

.global main
main:
  push {fp,lr}
  add fp, sp, 4
  sub sp, sp, 32
# rcc_fun 1 (printf)
# encode filtered string (fnord\n) (printf)
  adr r0, 4
  b 12
.string "fnord\n"
.fill 1, 1, 0
  str r0, [sp, 4]
# call in egg->lang.mode 0
  ldr r0, [sp, 4]
  bl printf
  add sp, fp, 32
  pop {fp,pc}


EOF
RUN

NAME=ragg2 issue25590 basic arm fastcall sample emits valid arm32 asm
FILE=unit/legacy_unit/ragg2/fastcall-basic.r
CMDS=!ragg2 -s -a arm -b 32 unit/legacy_unit/ragg2/fastcall-basic.r
EXPECT=<<EOF
.equ printf, 0x1fa0b4

.global main
main:
  push {fp,lr}
  add fp, sp, 4
  sub sp, sp, 32
# rcc_fun 1 (printf)
# encode filtered string (fnord\n) (printf)
  add pc, 4
.string "fnord\n"
.fill 1, 1, 0
  sub r0, pc, 12
  str r0, [sp, 4]
# call in egg->lang.mode 0
  ldr r0, [sp, 4]
  bl printf
  add sp, fp, 32
  pop {fp,pc}


EOF
RUN

NAME=ragg2 issue25590 basic arm fastcall sample emits valid arm64 asm
FILE=unit/legacy_unit/ragg2/fastcall-basic.r
CMDS=!ragg2 -s -a arm -b 64 unit/legacy_unit/ragg2/fastcall-basic.r
EXPECT=<<EOF
.equ printf, 0x1fa0b4

.global main
main:
  stp x29, x30, [sp, -16]!
  mov x29, sp
  sub sp, sp, 32
# rcc_fun 1 (printf)
# encode filtered string (fnord\n) (printf)
  adr x0, 8
  b 12
.string "fnord\n"
.fill 1, 1, 0
  str x0, [sp, 8]
# call in egg->lang.mode 0
  ldr x0, [sp, 8]
  bl printf
  mov sp, x29
  ldp x29, x30, [sp], 16
  ret


EOF
RUN

NAME=ragg2 issue25590 arm thumb dereference sample emits valid stack syntax
FILE=unit/legacy_unit/ragg2/fastcall-deref.r
CMDS=!ragg2 -s -a arm -b 16 unit/legacy_unit/ragg2/fastcall-deref.r
EXPECT=<<EOF
.equ printf, 0x1fa0b4

.global main
main:
  push {fp,lr}
  add fp, sp, 4
  sub sp, sp, 192
  mov r1, 0
  mov r1, 0xb0000000
  mov r9, r1
  str r9, [sp, 68]
# rcc_fun 1 (printf)
  ldr r0, [sp, 68]
  ldr r0, [r0]
  str r0, [sp, 12]
# encode filtered string (idreg=%x\n) (printf)
  adr r0, 4
  b 16
.string "idreg=%x\n"
.fill 2, 1, 0
  str r0, [sp, 20]
# call in egg->lang.mode 0
  ldr r1, [sp, 12]
  ldr r0, [sp, 20]
  bl printf
  add sp, fp, 192
  pop {fp,pc}


EOF
RUN

NAME=ragg2 issue25590 arm32 dereference sample emits valid stack syntax
FILE=unit/legacy_unit/ragg2/fastcall-deref.r
CMDS=!ragg2 -s -a arm -b 32 unit/legacy_unit/ragg2/fastcall-deref.r
EXPECT=<<EOF
.equ printf, 0x1fa0b4

.global main
main:
  push {fp,lr}
  add fp, sp, 4
  sub sp, sp, 192
  mov r1, 0
  mov r1, 0xb0000000
  mov r9, r1
  str r9, [sp, 68]
# rcc_fun 1 (printf)
  ldr r0, [sp, 68]
  ldr r0, [r0]
  str r0, [sp, 12]
# encode filtered string (idreg=%x\n) (printf)
  add pc, 8
.string "idreg=%x\n"
.fill 2, 1, 0
  sub r0, pc, 16
  str r0, [sp, 20]
# call in egg->lang.mode 0
  ldr r1, [sp, 12]
  ldr r0, [sp, 20]
  bl printf
  add sp, fp, 192
  pop {fp,pc}


EOF
RUN

#CLANG=e900000000488d3524000000bf01000000b80400000248c7c2070000000f05b80100000248c7c7000000000f0531c0c348656c6c6f210a00
NAME=ragg2c bins/other/ragg2/hi.c
BROKEN=1
FILE=-
CMDS=!ragg2 bins/other/ragg2/hi.c | grep e9
EXPECT=<<EOF
e90800000048656c6c6f210a00bf01000000488d35ecffffffba07000000b8010000000f05b83c0000004030ff0f05c3
EOF
RUN

NAME=ragg2 -v
FILE=-
CMDS=!ragg2 -v | grep -c birth
EXPECT=<<EOF
1
EOF
RUN

NAME=ragg2 -h
FILE=-
CMDS=!ragg2 -h | grep -c Usage
EXPECT=<<EOF
1
EOF
RUN

NAME=ragg2 -L
FILE=-
CMDS=!ragg2 -L | grep -c encoders
EXPECT=<<EOF
1
EOF
RUN

NAME=ragg2 empty file
FILE=-
CMDS=!ragg2 ""
EXPECT_ERR=<<EOF
ERROR: Cannot open empty path
EOF
RUN

NAME=ragg2 empty include
FILE=bins/other/ragg2/hi.c
CMDS=!ragg2 -I "" bins/other/ragg2/hi.c
EXPECT_ERR=<<EOF
ERROR: Cannot open empty include path
EOF
RUN

NAME=ragg2 empty contents
FILE=bins/other/ragg2/hi.c
CMDS=!ragg2 -C "" bins/other/ragg2/hi.c
EXPECT_ERR=<<EOF
ERROR: Cannot open empty contents path
EOF
RUN

NAME=ragg2 debruijn sequence 1
FILE=-
CMDS=!ragg2 -a x86 -r -P 2; ?e
EXPECT=<<EOF
AA
EOF
RUN

NAME=ragg2 debruijn sequence 2
FILE=-
CMDS=!ragg2 -a x86 -P 2 -r; ?e
EXPECT=<<EOF
AA
EOF
RUN

NAME=ragg2 debruijn sequence ppc 64
FILE=-
CMDS=!ragg2 -a ppc -b 64 -r -P 2; ?e
EXPECT=<<EOF
AA
EOF
RUN

NAME=ragg2 -a ppc -b 32 -k linux exit syscall
FILE=-
CMDS=!ragg2 -a ppc -b 32 -k linux -e 'exit@syscall(1); main@global() { exit(0); }'
EXPECT=<<EOF
7c0802a6900100049421ffd0386000009061001080610010380000014400000238210030800100047c0803a64e800020
EOF
RUN

NAME=ragg2 -a ppc -b 64 -k linux exit syscall (BE default)
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -e 'exit@syscall(1); main@global() { exit(0); }'
EXPECT=<<EOF
7c0802a6f8010010f821ffa138600000f8610020e8610020380000014400000238210060e80100107c0803a64e800020
EOF
RUN

NAME=ragg2 -a ppc -b 64 -s shows source
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'exit@syscall(1); main@global() { exit(0); }'
EXPECT=<<EOF

.global main
main:
  mflr r0
  std r0, 16(r1)
  stdu r1, -96(r1)
# rcc_fun 1 (exit)
  li r3, 0
  std r3, 32(r1)
# set syscall args
  ld r3, 32(r1)
# syscall
 li r0, 1
 sc
  addi r1, r1, 96
  ld r0, 16(r1)
  mtlr r0
  blr


EOF
RUN

# --- bug-detection tests below: each currently fails, demonstrating a
# --- specific bug in the PPC backend. They turn green once the bug is fixed.

# Finding #1: missing '\n' in emit_ppc.c indirect emit_jmp / emit_call.
# The 'ld r0, ...' and 'mtctr r0' lines get concatenated when the call
# goes through the indirect (atr=1) path triggered by '.var()' syntax.
NAME=ragg2 ppc indirect call separates ld and mtctr (finding #1)
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'main@global(8,0) { .var0(); }' | grep -c '^  ld r0, 0(r1)$'
EXPECT=<<EOF
1
EOF
RUN

# Finding #2: emit_frame with sz=0 allocates only R_MIN_FRAME bytes (32 for
# ppc64), but emit_arg stores arg 1 at offset R_MIN_FRAME (=32), which is
# the FIRST byte of the caller's frame. The frame must be large enough to
# include a parameter save area (32 + 8*8 = 96 for ppc64 with R_NGP=8).
NAME=ragg2 ppc 64 frame accommodates arg spill (finding #2)
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'foo@global() { ; } main@global() { foo(42); }' | grep -E '^  stdu r1,' | tail -1
EXPECT=<<EOF
  stdu r1, -96(r1)
EOF
RUN

# Finding #3: h_li / h_addi / h_cmpwi accept 0x8000..0xffff and silently
# sign-extend. SIMM is signed-16 so the upper bound must be 0x7fff.
NAME=rasm2 ppc.nz rejects li above signed-16 max (finding #3)
FILE=-
CMDS=!rasm2 -a ppc -b 64 -e 'li r3, 0x8000'
EXPECT=
EXPECT_ERR=<<EOF
ERROR: Cannot assemble 'li r3, 0x8000' at line 1
EOF
RUN

# Finding #4: emit_ppc.c uses 32-bit cmpw/mullw/divw even in the 64-bit
# emit_ppc64. Compares of 64-bit values silently truncate the high word.
# This test currently emits 'cmpw'; post-fix must emit 'cmpd' on ppc64.
NAME=ragg2 ppc 64 compare uses cmpd not cmpw (finding #4)
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'main@global(8,0) { .var0 = 1; if (.var0 == 0) { break; } }' | grep -cE '^  cmpd '
EXPECT=<<EOF
1
EOF
RUN

# Finding #5: emit_mathop emits PPC 3-register arithmetic with literal
# operands. ppc.nz parses bare digits 0-31 as register names, so
# 'add r4, r4, 1' silently encodes as 'add r4, r4, r1' (stack pointer).
# Post-fix must emit 'addi' (D-form, immediate-aware) for literal operands.
NAME=ragg2 ppc mathop with immediate uses addi (finding #5)
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'main@global(8,0) { .var0 = .var0 + 1; }' | grep -cE '^  addi r[0-9]+, r[0-9]+, 1$'
EXPECT=<<EOF
1
EOF
RUN

# Finding #4b (pattern analogue): mullw / divw aren't switched to mulld /
# divd in 64-bit emit_ppc. Same fix shape as finding #4 but a different
# instruction site (emit_mathop, not emit_branch).
NAME=ragg2 ppc 64 multiply uses mulld not mullw (finding #4b)
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'main@global(8,0) { .var0 = .var0 * .var1; }' | grep -cE '^  mulld '
EXPECT=<<EOF
1
EOF
RUN

# Finding #3b (pattern analogue): h_addi accepts 0x8000 with silent
# sign-wrap, same bug as h_li (finding #3) but in a different handler.
NAME=rasm2 ppc.nz rejects addi above signed-16 max (finding #3b)
FILE=-
CMDS=!rasm2 -a ppc -b 64 -e 'addi r1, r1, 0x8000'
EXPECT=
EXPECT_ERR=<<EOF
ERROR: Cannot assemble 'addi r1, r1, 0x8000' at line 1
EOF
RUN

# Finding #5b (pattern analogue): subtract-with-literal emits
# 'subf r4, 1, r4' where '1' is parsed as r1 (stack pointer!). Post-fix
# should emit either 'addi rT, rA, -imm' or materialise the literal into
# R_TMP first.
NAME=ragg2 ppc subtract with literal does not use subf (finding #5b)
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'main@global(8,0) { .var0 = .var0 - 1; }' | grep -cE '^  subf r[0-9]+, [0-9]+, r[0-9]+$'
EXPECT=<<EOF
0
EOF
RUN

# --- coverage tests below: every callback in emit_ppc.c exercised at least
# --- once. Currently pass.

# emit_trap: 'break' statement
NAME=ragg2 ppc emit_trap on break
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'main@global() { break; }' | grep -c '^  trap$'
EXPECT=<<EOF
1
EOF
RUN

# emit_load: dereference of pointer variable
NAME=ragg2 ppc emit_load on dereference
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'main@global(16,0) { .var0 = *.var1; }' | grep -cE '^  ld r[0-9]+, 0\(r[0-9]+\)$'
EXPECT=<<EOF
1
EOF
RUN

# emit_call (direct): function-to-function bl. Asserts 'bl foo' appears.
NAME=ragg2 ppc emit_call direct bl
FILE=-
CMDS=!ragg2 -a ppc -b 64 -k linux -s -e 'foo@global() { ; } main@global() { foo(); }' | grep -c '^  bl foo$'
EXPECT=<<EOF
1
EOF
RUN

NAME=ragg2 -H R2_NOPLUGINS
FILE=-
CMDS=!R2_NOPLUGINS=1;ragg2 -H R2_NOPLUGINS
EXPECT=<<EOF
1
EOF
EXPECT_ERR=
RUN

NAME=ragg2 esil assign constant
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5; }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil addition
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5 + 3; }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,3,r1,+=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil compound plus
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5; .var0 += 3; }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,r1,v8,:=,3,r1,:=,r1,v8,+=

EOF
RUN

NAME=ragg2 esil compound minus
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 10; .var0 -= 4; }'
EXPECT=<<EOF

.global main
main:
10,r1,:=,r1,v8,:=,4,r1,:=,r1,v8,-=

EOF
RUN

NAME=ragg2 esil multiplication
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5 * 3; }'
EXPECT=<<EOF

.global main
main:
5,r2,:=,3,r2,*=,r2,r1,:=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil division
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 20 / 4; }'
EXPECT=<<EOF

.global main
main:
20,r2,:=,4,r2,/=,r2,r1,:=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil bitwise and
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 0xff & 0x0f; }'
EXPECT=<<EOF

.global main
main:
0xff,r3,:=,0x0f,r3,&=,r3,r1,:=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil bitwise or chain
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 1 | 2 | 4; }'
EXPECT=<<EOF

.global main
main:
1,r3,:=,2,r3,|=,4,r3,|=,r3,r1,:=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil bitwise xor
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5 ^ 3; }'
EXPECT=<<EOF

.global main
main:
5,r3,:=,3,r3,^=,r3,r1,:=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil operator precedence
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 2 + 3 * 4; }'
EXPECT=<<EOF

.global main
main:
2,r1,:=,3,r2,:=,4,r2,*=,r2,r1,+=,r1,v8,:=

EOF
RUN

NAME=ragg2 esil variable as rvalue
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5; .var8 = .var0 + 1; }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,r1,v8,:=,v8,r1,:=,1,r1,+=,r1,v16,:=

EOF
RUN

NAME=ragg2 esil pointer dereference
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 0x1000; .var8 = *.var0; }'
EXPECT=<<EOF

.global main
main:
0x1000,r1,:=,r1,v8,:=,v8,[4],r0,:=,r0,r1,:=,r1,v16,:=

EOF
RUN

NAME=ragg2 esil syscall via @syscall
FILE=-
CMDS=!ragg2 -a esil -b 64 -k linux -s -e 'exit@syscall(60); main@global(16,0) { exit(42); }'
EXPECT=<<EOF

.global main
main:
42,a1,:=,60,$


EOF
RUN

NAME=ragg2 esil raw register access
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .%rax = 5; }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,r1,rax,:=

EOF
RUN

NAME=ragg2 esil raw register in expression
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .%rax = .%rcx + 3; }'
EXPECT=<<EOF

.global main
main:
rcx,r1,:=,3,r1,+=,r1,rax,:=

EOF
RUN

NAME=ragg2 esil unknown dotname is an error
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .rax = 5; }'
EXPECT_ERR=<<EOF
ERROR: Unknown name '.rax' (use .%rax for a raw register or `rax@alias(...)`)
EOF
RUN

NAME=ragg2 esil alias directive
FILE=-
CMDS=!ragg2 -a esil -s -e 'myreg@alias(rax) main@global(16,0) { .myreg = 42; }'
EXPECT=<<EOF

.global main
main:
42,r1,:=,r1,rax,:=

EOF
RUN

NAME=ragg2 esil if equality skip
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5; if (.var0 == 0) { .var0 = 99; } }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,r1,v8,:=,v8,a1,:=,0,a1,==,$z,!,?{,26,GOTO,},99,r1,:=,r1,v8,:=,26,GOTO,26,GOTO

EOF
RUN

NAME=ragg2 esil if not-equal skip
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5; if (.var0 != 0) { .var0 = 99; } }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,r1,v8,:=,v8,a1,:=,0,a1,==,$z,?{,25,GOTO,},99,r1,:=,r1,v8,:=,25,GOTO,25,GOTO

EOF
RUN

NAME=ragg2 esil bare truthy if
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 5; if (.var0) { .var0 = 0; } }'
EXPECT=<<EOF

.global main
main:
5,r1,:=,r1,v8,:=,v8,a1,:=,0,a1,==,$z,?{,25,GOTO,},0,r1,:=,r1,v8,:=,25,GOTO,25,GOTO

EOF
RUN

NAME=ragg2 esil while truthy
FILE=-
CMDS=!ragg2 -a esil -s -e 'main@global(16,0) { .var0 = 3; while (.var0) { .var0 -= 1; } }'
EXPECT=<<EOF

.global main
main:
3,r1,:=,r1,v8,:=,v8,a1,:=,0,a1,==,$z,?{,28,GOTO,},1,r1,:=,r1,v8,-=,v8,a1,:=,9,GOTO

EOF
RUN
