Execute SNUSP: Difference between revisions

m
(Rename Perl 6 -> Raku, alphabetize, minor clean-up)
 
(11 intermediate revisions by 9 users not shown)
Line 6:
=={{header|11l}}==
{{trans|Python}}
<langsyntaxhighlight lang="11l">V HW = ‘
/++++!/===========?\>++.>+.+++++++..+++\
\+++\ | /+>+++++++>/ /++++++++++<<.++>./
Line 48:
ds[dp] = Byte(:stdin.read(1).code)
‘/’
id = (-)~id
‘\’
id (+)= 1
Line 58:
step()
 
snusp(5, HW)</langsyntaxhighlight>
{{out}}
<pre>
Line 66:
=={{header|Ada}}==
See [[Execute SNUSP/Ada]].
 
=={{header|ALGOL 68}}==
See [[Execute SNUSP/Algol68]].
 
=={{header|AutoHotkey}}==
Line 81 ⟶ 84:
=={{header|D}}==
See [[RCSNUSP/D]].
 
=={{header|EasyLang}}==
{{trans|Go}}
<syntaxhighlight>
proc snusp dlen raw$ . .
len ds[] dlen
is$[] = strsplit raw$ "\n"
for s$ in is$[]
is$[][] &= strchars s$
.
for ipr to len is$[][]
for ipc to len is$[ipr][]
if is$[ipr][ipc] = "$"
break 2
.
.
.
dp = 1
id = 0
#
subr step
if id mod 2 = 0
ipc += 1 - bitand id 2
else
ipr += 1 - bitand id 2
.
.
while ipr >= 1 and ipr <= len is$[][] and ipc >= 1 and ipc <= len is$[ipr][]
c$ = is$[ipr][ipc]
if c$ = ">"
dp += 1
elif c$ = "<"
dp -= 1
elif c$ = "+"
ds[dp] += 1
elif c$ = "-"
ds[dp] -= 1
elif c$ = "."
write strchar ds[dp]
elif c$ = ","
# ds[dp] = strcode input
elif c$ = "/"
id = bitxor id 3
elif c$ = "\\"
id = bitxor id 1
elif c$ = "!"
step
elif c$ = "?"
if ds[dp] = 0
step
.
.
step
.
.
s$ = input
while s$ <> ""
cod$ &= "\n" & s$
s$ = input
.
snusp 5 cod$
#
input_data
/++++!/===========?\>++.>+.+++++++..+++\
\+++\ | /+>+++++++>/ /++++++++++<<.++>./
$+++/ | \+++++++++>\ \+++++.>.+++.-----\
\==-<<<<+>+++/ /=.>.+>.--------.-/
 
</syntaxhighlight>
 
=={{header|F_Sharp|F#}}==
Line 93 ⟶ 165:
=={{header|Haskell}}==
See [[RCSNUSP/Haskell]].
 
=={{header|Icon}} and {{header|Unicon}}==
<syntaxhighlight lang="icon">#
# snusp.icn, A Modular SNUSP interpreter
#
 
$define VERSION 0.6
 
# allow a couple of cli options
link options
 
# directions
$define DRIGHT 1
$define DLEFT 2
$define DUP 3
$define DDOWN 4
 
record position(row, col)
global dir, ip, ram
 
procedure main(argv)
local ch, codespace, col, dp, fn, line
local row := 1
local wid := 0
local dirs := []
local ips := []
local opts, verbose, debug
 
opts := options(argv, "-h! -v! -d!", errorproc)
\opts["v"] & verbose := 1
\opts["h"] & show_help(verbose)
\opts["d"] & debug := 1
ip := position(1,1)
 
# initial direction
dir := DRIGHT
 
# prepare initial memory
ram := list(1, 0)
 
# prepare code field
codespace := []
 
fn := open(argv[1], "r") | &input
if (fn === &input) & \opts["h"] then return
 
while line := read(fn) do {
put(codespace, line)
wid := max(*line, wid)
}
if *codespace = 0 then return
every line := !codespace do {
codespace[row] := left(codespace[row], wid)
# track starting indicator
if /col := find("$", codespace[row]) then {
ip.row := row
ip.col := col
}
row +:= 1
}
 
if \verbose then {
write("Starting at ", ip.row, ", ", ip.col, " with codespace:")
every write(!codespace)
}
 
dp := 1
repeat {
if not (ch := codespace[ip.row][ip.col]) then break
if \debug then {
write(&errout, "dir: ", dir, " ch: ", ch, " [", ord(ch), "]",
" row: ", ip.row, " col: ", ip.col,
" dp: ", dp, " ram[dp]: ", ram[dp])
}
case ch of {
# six of the bf instructions
"+": ram[dp] +:= 1
"-": ram[dp] -:= 1
">": resize(dp +:= 1)
"<": dp -:= 1
".": writes(char(ram[dp]) | char(0))
",": ram[dp] := getche()
# direction change, LURD, RULD, SKIP, SKIPZ
"\\": { # LURD
case dir of {
DRIGHT: dir := DDOWN
DLEFT: dir := DUP
DUP: dir := DLEFT
DDOWN: dir := DRIGHT
}
}
"/": { # RULD
case dir of {
DRIGHT: dir := DUP
DLEFT: dir := DDOWN
DUP: dir := DRIGHT
DDOWN: dir := DLEFT
}
}
"!": step()
"?": { # skipz
if ram[dp] = 0 then {
step()
}
}
# modular SNUSP
"@": { # Enter
push(dirs, dir)
push(ips, copy(ip))
}
"#": { # Leave
if *dirs < 1 then break
dir := pop(dirs)
ip := pop(ips)
step()
}
}
step()
}
end
 
# advance the ip depending on direction
procedure step()
case dir of {
DRIGHT: ip.col +:= 1
DLEFT: ip.col -:= 1
DUP: ip.row -:= 1
DDOWN: ip.row +:= 1
}
end
 
# enlarge memory when needed
procedure resize(elements)
until *ram >= elements do put(ram, 0)
end
 
# quick help or verbose help
procedure show_help(verbose)
write("SNUSP interpeter in Unicon, version ", VERSION)
write("CORE and MODULAR, not yet BLOATED")
write()
write("Usage: unicon snusp.icn -x [filename] [-h|-v|-d]")
write(" -h, help")
write(" -v, verbose (and verbose help")
write(" -d, debug (step tracer)")
if \verbose then {
write()
write("Instructions:")
write(" + INCR, Increment current memory location")
write(" - DECR, Decrement current memory location")
write(" > RIGHT, Advance memory pointer")
write(" < LEFT, Retreat memory pointer")
write(" . WRITE, Output contents of current memory cell, in ASCII")
write(" , READ, Accept key and place byte value in current memory cell")
write(" \\ LURD, If going:")
write(" left, go up")
write(" up, go left")
write(" right, go down")
write(" down, go right")
write(" / RULD, If going:")
write(" right, go up")
write(" up, go right")
write(" left, go down")
write(" down, go left")
write(" !, SKIP, Move forward one step in current direction")
write(" ?, SKIPZ, If current memory cell is zero then SKIP")
write("Modular SNUSP adds:")
write(" @, ENTER, Push direction and instruction pointer")
write(" #, LEAVE, Pop direction and instruction pointer and SKIP")
write()
write("All other characters are NOOP, explicitly includes =,|,spc")
write(" $, can set the starting location; first one found")
write()
write("Hello world examples:")
write()
write("CORE SNUSP:")
write("/++++!/===========?\\>++.>+.+++++++..+++\\")
write("\\+++\\ | /+>+++++++>/ /++++++++++<<.++>./")
write("$+++/ | \\+++++++++>\\ \\+++++.>.+++.-----\\")
write(" \\==-<<<<+>+++/ /=.>.+>.--------.-/")
write()
write("Modular SNUSP:")
write(" /@@@@++++# #+++@@\ #-----@@@\\n")
write("$@\\H.@/e.+++++++l.l.+++o.>>++++.< .<@/w.@\\o.+++r.++@\\l.@\\d.>+.@/.#")
write(" \\@@@@=>++++>+++++<<@+++++# #---@@/!=========/!==/")
write()
}
end</syntaxhighlight>
 
{{out}}
Using the Modular SNUSP sample
<pre>prompt$ unicon -s snusp.icn -x hello.snusp
Hello, world!</pre>
 
=={{header|J}}==
This program places no limits on the program or data size. Perhaps I'll revisit and write a tacit version of the SNUSP interpreter.
<syntaxhighlight lang="j">
<lang J>
Note 'snusp'
 
Line 150 ⟶ 416:
end.
)
</syntaxhighlight>
</lang>
Store <langsyntaxhighlight SNUSPlang="snusp">\ display JJ and linefeed, then loop forever
\ +++++++++++++++++++++++++++++++++++++\
! /+++++++++++++++++++++++++++++++++++++/
/ \..<+++++\
\ . +++++/
</langsyntaxhighlight> as J.snusp
<pre>
load'snusp.ijs' NB. the j code above
Line 176 ⟶ 442:
=={{header|Julia}}==
This Modular SNUSP interpreter uses modular calls to echo the first 2 characters entered. Try typing "Hi" at the prompt.
<langsyntaxhighlight lang="julia">const echo2 = raw"""
/==!/======ECHO==,==.==#
| |
Line 230 ⟶ 496:
end
 
snusp(100, echo2)</langsyntaxhighlight> {{output}} <pre>
> Hi
Hi
Line 238 ⟶ 504:
=={{header|Kotlin}}==
{{trans|Go}}
<langsyntaxhighlight lang="scala">// version 1.1.2
 
// requires 5 chars (10 bytes) of data store
Line 300 ⟶ 566:
fun main(args: Array<String>) {
snusp(5, hw)
}</langsyntaxhighlight>
 
{{out}}
Line 310 ⟶ 576:
See [[RCSNUSP/Lua]].
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
See [[RCSNUSP/Mathematica]].
 
=={{header|Nim}}==
{{trans|Python}}
<syntaxhighlight lang="nim">import strutils
 
# Requires 5 bytes of data store.
const Hw = r"""
/++++!/===========?\>++.>+.+++++++..+++\
\+++\ | /+>+++++++>/ /++++++++++<<.++>./
$+++/ | \+++++++++>\ \+++++.>.+++.-----\
\==-<<<<+>+++/ /=.>.+>.--------.-/"""
 
#---------------------------------------------------------------------------------------------------
 
proc snusp(dsLen: int; code: string) =
## The interpreter.
 
var
ds = newSeq[byte](dsLen) # Data store.
dp = 0 # Data pointer.
cs = code.splitLines() # Two dimensional code store.
ipr, ipc = 0 # Instruction pointers in row ans column.
dir = 0 # Direction (0 = right, 1 = down, 2 = left, 3 = up).
 
# Initialize instruction pointers.
for r, row in cs:
ipc = row.find('$')
if ipc >= 0:
ipr = r
break
 
#.................................................................................................
 
func step() =
## Update the instruction pointers acccording to the direction.
 
if (dir and 1) == 0:
inc ipc, 1 - (dir and 2)
else:
inc ipr, 1 - (dir and 2)
 
#.................................................................................................
 
# Interpreter loop.
while ipr in 0..cs.high and ipc in 0..cs[ipr].high:
case cs[ipr][ipc]
of '>': inc dp
of '<': dec dp
of '+': inc ds[dp]
of '-': dec ds[dp]
of '.': stdout.write chr(ds[dp])
of ',': ds[dp] = byte(stdin.readLine()[0])
of '/': dir = not dir
of '\\': dir = dir xor 1
of '!': step()
of '?': (if ds[dp] == 0: step())
else: discard
step()
 
#———————————————————————————————————————————————————————————————————————————————————————————————————
 
when isMainModule:
snusp(5, Hw)</syntaxhighlight>
 
{{out}}
<pre>Hello World!</pre>
 
=={{header|OCaml}}==
Line 320 ⟶ 652:
 
=={{header|Phix}}==
{{trans|Go}}<lang Phix>integer id = 0, ipr = 1, ipc = 1
<!--<syntaxhighlight lang="phix">(phixonline)-->
 
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
procedure step()
<span style="color: #004080;">integer</span> <span style="color: #000000;">id</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ipr</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">ipc</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
if and_bits(id,1) == 0 then
ipc += 1 - and_bits(id,2)
<span style="color: #008080;">procedure</span> <span style="color: #000000;">step</span><span style="color: #0000FF;">()</span>
else
<span style="color: #008080;">if</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">id</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">==</span> <span style="color: #000000;">0</span> <span style="color: #008080;">then</span>
ipr += 1 - and_bits(id,2)
<span style="color: #000000;">ipc</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span> <span style="color: #0000FF;">-</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">id</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
end if
<span style="color: #008080;">else</span>
end procedure
<span style="color: #000000;">ipr</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span> <span style="color: #0000FF;">-</span> <span style="color: #7060A8;">and_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">id</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">)</span>
 
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
procedure snusp(integer dlen, string s)
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
sequence ds = repeat(0,dlen) -- data store
integer dp = 1 -- data pointer
<span style="color: #008080;">procedure</span> <span style="color: #000000;">snusp</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">dlen</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">ds</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">dlen</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- data store</span>
-- remove leading '\n' from string if present
<span style="color: #004080;">integer</span> <span style="color: #000000;">dp</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span> <span style="color: #000080;font-style:italic;">-- data pointer
s = trim_head(s,'\n')
-- remove leading '\n' from string if present</span>
-- make 2 dimensional instruction store and set instruction pointers
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">trim_head</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>
sequence cs = split(s,'\n')
ipr = 1
<span style="color: #000080;font-style:italic;">-- make 2 dimensional instruction store and set instruction pointers</span>
ipc = 1
<span style="color: #004080;">sequence</span> <span style="color: #000000;">cs</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'\n'</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">ipr</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
-- look for starting instruction
<span style="color: #000000;">ipc</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span>
for i=1 to length(cs) do
ipc = find('$',cs[i])
<span style="color: #000080;font-style:italic;">-- look for starting instruction</span>
if ipc then
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cs</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
ipr = i
<span style="color: #000000;">ipc</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #008000;">'$'</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cs</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">])</span>
exit
<span style="color: #008080;">if</span> <span style="color: #000000;">ipc</span> <span style="color: #008080;">then</span>
end if
<span style="color: #000000;">ipr</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">i</span>
end for
<span style="color: #008080;">exit</span>
 
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
id = 0
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
-- execute
<span style="color: #000000;">id</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
while ipr>=1 and ipr<=length(cs)
and ipc>=1 and ipc<=length(cs[ipr]) do
<span style="color: #000080;font-style:italic;">-- execute</span>
integer op = cs[ipr][ipc]
<span style="color: #008080;">while</span> <span style="color: #000000;">ipr</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">1</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ipr</span><span style="color: #0000FF;"><=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cs</span><span style="color: #0000FF;">)</span>
switch op do
<span style="color: #008080;">and</span> <span style="color: #000000;">ipc</span><span style="color: #0000FF;">>=</span><span style="color: #000000;">1</span> <span style="color: #008080;">and</span> <span style="color: #000000;">ipc</span><span style="color: #0000FF;"><=</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">cs</span><span style="color: #0000FF;">[</span><span style="color: #000000;">ipr</span><span style="color: #0000FF;">])</span> <span style="color: #008080;">do</span>
case '>' : dp += 1
<span style="color: #004080;">integer</span> <span style="color: #000000;">op</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cs</span><span style="color: #0000FF;">[</span><span style="color: #000000;">ipr</span><span style="color: #0000FF;">][</span><span style="color: #000000;">ipc</span><span style="color: #0000FF;">]</span>
case '<' : dp -= 1
<span style="color: #008080;">switch</span> <span style="color: #000000;">op</span> <span style="color: #008080;">do</span>
case '+' : ds[dp] += 1
<span style="color: #008080;">case</span> <span style="color: #008000;">'&gt;'</span> <span style="color: #0000FF;">:</span> <span style="color: #000000;">dp</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
case '-' : ds[dp] -= 1
<span style="color: #008080;">case</span> <span style="color: #008000;">'&lt;'</span> <span style="color: #0000FF;">:</span> <span style="color: #000000;">dp</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">1</span>
case '.' : puts(1,ds[dp])
<span style="color: #008080;">case</span> <span style="color: #008000;">'+'</span> <span style="color: #0000FF;">:</span> <span style="color: #000000;">ds</span><span style="color: #0000FF;">[</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
case ',' : ds[dp] = getc(0)
<span style="color: #008080;">case</span> <span style="color: #008000;">'-'</span> <span style="color: #0000FF;">:</span> <span style="color: #000000;">ds</span><span style="color: #0000FF;">[</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">-=</span> <span style="color: #000000;">1</span>
case '/' : id = not_bits(id)
<span style="color: #008080;">case</span> <span style="color: #008000;">'.'</span> <span style="color: #0000FF;">:</span> <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ds</span><span style="color: #0000FF;">[</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">])</span>
case '\\': id = xor_bits(id,1)
<span style="color: #008080;">case</span> <span style="color: #008000;">','</span> <span style="color: #0000FF;">:</span> <span style="color: #000000;">ds</span><span style="color: #0000FF;">[</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">getc</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">)</span>
case '!' : step()
<span style="color: #008080;">case</span> <span style="color: #008000;">'/'</span> <span style="color: #0000FF;">:</span> <span style="color: #000000;">id</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">not_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">id</span><span style="color: #0000FF;">)</span>
case '?' : if ds[dp]=0 then step() end if
<span style="color: #008080;">case</span> <span style="color: #008000;">'\\'</span><span style="color: #0000FF;">:</span> <span style="color: #000000;">id</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">xor_bits</span><span style="color: #0000FF;">(</span><span style="color: #000000;">id</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">)</span>
end switch
<span style="color: #008080;">case</span> <span style="color: #008000;">'!'</span> <span style="color: #0000FF;">:</span> <span style="color: #000000;">step</span><span style="color: #0000FF;">()</span>
step()
<span style="color: #008080;">case</span> <span style="color: #008000;">'?'</span> <span style="color: #0000FF;">:</span> <span style="color: #008080;">if</span> <span style="color: #000000;">ds</span><span style="color: #0000FF;">[</span><span style="color: #000000;">dp</span><span style="color: #0000FF;">]=</span><span style="color: #000000;">0</span> <span style="color: #008080;">then</span> <span style="color: #000000;">step</span><span style="color: #0000FF;">()</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
end while
<span style="color: #008080;">end</span> <span style="color: #008080;">switch</span>
end procedure
<span style="color: #000000;">step</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
constant hw = """
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
/++++!/===========?\>++.>+.+++++++..+++\
\+++\ | /+>+++++++>/ /++++++++++<<.++>./
<span style="color: #008080;">constant</span> <span style="color: #000000;">hw</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"""
$+++/ | \+++++++++>\ \+++++.>.+++.-----\
/++++!/===========?\&gt;++.&gt;+.+++++++..+++\
\==-<<<<+>+++/ /=.>.+>.--------.-/"""
\+++\ | /+&gt;+++++++&gt;/ /++++++++++&lt;&lt;.++&gt;./
 
$+++/ | \+++++++++&gt;\ \+++++.&gt;.+++.-----\
snusp(5, hw)</lang>
\==-&lt;&lt;&lt;&lt;+&gt;+++/ /=.&gt;.+&gt;.--------.-/"""</span>
<span style="color: #000000;">snusp</span><span style="color: #0000FF;">(</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">hw</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 390 ⟶ 726:
=={{header|Python}}==
{{trans|Go}}
<langsyntaxhighlight lang="python">#!/usr/bin/env python3
 
HW = r'''
Line 444 ⟶ 780:
 
if __name__ == '__main__':
snusp(5, HW)</langsyntaxhighlight>
{{out}}
<pre>
Line 457 ⟶ 793:
{{works with|Rakudo|2017.02}}
Implementation of modular SNUSP.
<syntaxhighlight lang="raku" perl6line>class SNUSP {
 
has @!inst-pointer;
Line 527 ⟶ 863:
 
my $snusp = SNUSP.new;
$snusp.run($hw)</langsyntaxhighlight>
{{out}}
<pre>Hello World!</pre>
Line 537 ⟶ 873:
The interpreter below implements Core SNUSP:
 
<langsyntaxhighlight lang="seed7">$ include "seed7_05.s7i";
 
const proc: snusp (in string: sourceCode, in integer: memSize, inout file: input, inout file: output) is func
Line 597 ⟶ 933:
begin
snusp(helloWorld, 5, IN, OUT);
end func;</langsyntaxhighlight>
 
{{out}}
Line 606 ⟶ 942:
=={{header|Tcl}}==
See [[RCSNUSP/Tcl]].
 
=={{header|Wren}}==
{{trans|Go}}
<syntaxhighlight lang="wren">import "io" for Stdin
 
// 'raw' is a multi-line string
var snusp = Fn.new { |dlen, raw|
var ds = List.filled(dlen, 0) // data store
var dp = 0 // data pointer
 
// remove leading \n if it's there
if (raw[0] == "\n") raw = raw[1..-1]
 
// make 2 dimensional instruction store & declare instruction pointers
var s = raw.split("\n")
var ipr = 0
var ipc = 0
 
// look for starting instruction
for (r in 0...s.count) {
var row = s[r]
var outer = false
for (c in 0...row.count) {
var i = row[c]
if (i == "$") {
ipr = r
ipc = c
outer = true
break
}
}
if (outer) break
}
 
var id = 0
var step = Fn.new {
if (id&1 == 0) {
ipc = ipc + 1 - (id&2)
} else {
ipr = ipr + 1 - (id&2)
}
}
 
// execute
while (ipr >= 0 && ipr < s.count && ipc >= 0 && ipc < s[ipr].count) {
var c = s[ipr][ipc]
if (c == ">") {
dp = dp + 1
} else if (c == "<") {
dp = dp - 1
} else if (c == "+") {
ds[dp] = ds[dp] + 1
} else if (c == "-") {
ds[dp] = ds[dp] - 1
} else if (c == ".") {
System.write(String.fromByte(ds[dp]))
} else if (c == ",") {
ds[dp] = Stdin.readByte()
} else if (c == "/") {
id = ~id
} else if (c == "\\") {
id = id ^ 1
} else if (c == "!") {
step.call()
} else if (c == "?") {
if (ds[dp] == 0) step.call()
}
step.call()
}
}
 
var hw =
"/++++!/===========?\\>++.>+.+++++++..+++\\\n" +
"\\+++\\ | /+>+++++++>/ /++++++++++<<.++>./\n" +
"$+++/ | \\+++++++++>\\ \\+++++.>.+++.-----\\\n" +
" \\==-<<<<+>+++/ /=.>.+>.--------.-/"
snusp.call(5, hw)</syntaxhighlight>
 
{{out}}
<pre>
Hello World!
</pre>
 
{{omit from|GUISS}}
1,964

edits