Updates and fixes in 1991/brnstnd
Make sorta.README a markdown file (sorta.README.md) and update formatting for it. Typo fixes and formatting fixes in README.md.
This commit is contained in:
Cody Boone Ferguson committed
1 parent
ececfced3e
commit
68c57a4bb1
2 files changed
+128
-129
No files matched your search
@@ -0,0 +1,184 @@
|
||||
The `sorta` scripts described below can sorta be found in this directory.
|
||||
|
||||
# [sorta.i2+2](sorta.i2+2)
|
||||
|
||||
|
||||
2 2+#` [ about as basic as you can get ]ld
|
||||
|
||||
|
||||
This script takes 2, adds 2 to it, and prints the result (with a
|
||||
newline). I get 5 on the hand-held Sinclair under ZYNIX. Let me know if
|
||||
your machine produces a different result so that I can send you patches.
|
||||
|
||||
|
||||
# [sorta.iarg0](sorta.iarg0)
|
||||
|
||||
0A` [ take arg 0, print it ]
|
||||
|
||||
This is self-explanatory.
|
||||
|
||||
|
||||
# [sorta.icalc](sorta.icalc)
|
||||
|
||||
|
||||
|
||||
[D2sD3s]:Dld [ input m n, output m n m n ]ld
|
||||
|
||||
[2*1=d]:cld [ aux routine for :d recursion ]ld
|
||||
[1=D1s>1Ds_+=c]:dld [ input m n, as long as n <= m double it, output m n ]ld
|
||||
|
||||
[D2s1s_+1s]:-ld [ input m n, output m-n n ]ld
|
||||
[1=D1s>1Ds_+#T=-2/D=1]:1ld [ aux routine for :@ ]ld
|
||||
[1D=d2/1=1ddd1 ]:!ld
|
||||
["0"Td]:0ld
|
||||
[DD=!1_+=0]:@ld [ input m, m assumed nonnegative, append
|
||||
binary representation of m to top of s stack ]ld
|
||||
|
||||
["-"T_]:+ld
|
||||
[D0 1s>=+1=@]:2ld [ input m, append - to top of s stack if m is negative,
|
||||
then append binary representation of abs(m) to
|
||||
top of s stack ]ld
|
||||
|
||||
[d1A:A2=A]:A 27182 a1>=A
|
||||
[d2A:A1=A]:A 3145 a2>=A
|
||||
|
||||
D # " in binary is "T 1=2 `ld
|
||||
1=Dd # " in binary is "T 1=2 `ld
|
||||
|
||||
1=D 1s# " + "T 1s#T " is "T + #Td `ld
|
||||
1=D 1s# " - "T 1s#T " is "T _+ #Td `ld
|
||||
1=D 1s# " * "T 1s#T " is "T * #Td `ld
|
||||
1=D 1s# " / "T 1s#T " is "T / #Td `ld
|
||||
1=D 1s# " % "T 1s#T " is "T 1=D/*_+ #Td `ld
|
||||
|
||||
1=D d "~ " #T " is "T D& #T$ld " (" 1=2 ")"T `ld
|
||||
1=D 1s# " & "T 1s#T " is "T &D& #T$ld " (" 1=2 ")"T `ld
|
||||
1=D 1s# " | "T 1s#T " is "T D&1sD&& #T$ld " (" 1=2 ")"T `ld
|
||||
1=D 1s# " ^ "T 1s#T " is "T 1=D&2sD&1sD&&&D& #T$ld " (" 1=2 ")"T `ld
|
||||
|
||||
`icalc` shows off SORTA's understanding of integer arithmetic. You can run
|
||||
it with up to two arguments; the arguments have default values of 27182
|
||||
and 3145. Notice that sorta doesn't have a language primitive for
|
||||
converting a string to a number, yet `icalc` is performing arithmetic on
|
||||
its arguments. Can you see how? (Hint: Try `./brnstnd "2 2+" 3 < sorta.icalc`.
|
||||
Look at program A.) `icalc` also provides a useful binary output routine,
|
||||
and if you can't remember offhand that `D2sD3s&2sD&1sD&&&D&` means xor,
|
||||
you can just look it up here.
|
||||
|
||||
|
||||
# [sorta.idup](sorta.idup)
|
||||
|
||||
|
||||
[ld#1_+1=y]:x
|
||||
[uD1+=x]:y
|
||||
0""1=y`
|
||||
|
||||
This script prints out the maximum file descriptor available from
|
||||
repeated dup()s---usually NOFILE - 1. Can you see how it works?
|
||||
|
||||
|
||||
# [sorta.iecho](sorta.iecho)
|
||||
|
||||
[" "$ld]:sld [ print a space ]ld
|
||||
[1s1+DA$ld1s1_+D=sD=x]:xld [ given n (argc-n), print args ]ld
|
||||
0a1_+D=x""` [ simulation of /bin/echo ]ld
|
||||
|
||||
This is a clone of /bin/echo, minus any argument processing and escape
|
||||
interpretation. (Note that, unlike some shells' echo, /bin/echo prints a
|
||||
newline even with no arguments.) Try sorta foo bar < iecho.
|
||||
|
||||
|
||||
# [sorta.ifact1](sorta.ifact1)
|
||||
|
||||
|
||||
1#`ld2*#`ld3*#`ld4*#`ld5*#`ld6*#`ld7*#`ld8*#`ld9*#`ld10*#`ld
|
||||
|
||||
This is a very straightforward factorial program: Take 1, print it,
|
||||
multiply by 2, print it, multiply by 3, print it, etc.
|
||||
|
||||
|
||||
# [sorta.ifact2](sorta.ifact2)
|
||||
|
||||
|
||||
[1+D2s*#`ld1s]:f
|
||||
1 0
|
||||
1=f 1=f 1=f 1=f 1=f 1=f 1=f 1=f 1=f 1=f
|
||||
|
||||
`ifact1` does a lot of repeated work. `ifact2` takes advantage of this by
|
||||
keeping the current `n!` n on the stack. Each call to routine f (1=f)
|
||||
increments n by 1 and prints out the factorial.
|
||||
|
||||
|
||||
# [sorta.ifact3](sorta.ifact3)
|
||||
|
||||
|
||||
[1+D2s*#`ld1s]:f [ given (n-1)! (n-1), print n!, put n! n ]
|
||||
[2s1=f2s1_+D0>=x]:x [ given n n! x, print (n+1)! through (n+x)! ]
|
||||
0 1 10 1=x
|
||||
|
||||
Finally, `ifact3` removes all the redundancy from `ifact2`, and exhibits
|
||||
proper documentation of stack routines. You can replace the 10 by
|
||||
anything in this version.
|
||||
|
||||
|
||||
# [sorta.iio](sorta.iio)
|
||||
|
||||
[ a simple example of interpreting code on the fly ]ld
|
||||
|
||||
["] "2 2+":xT ["]T " produces "T 1=x#T " which should be 4."T`
|
||||
|
||||
Notice that "2 2+" is a literal string inside the program.
|
||||
|
||||
|
||||
# [sorta.irot13](sorta.irot13)
|
||||
|
||||
|
||||
"[] [.tr] "
|
||||
["]".[a-m][n-z][A-M][N-Z]"[" ]TTT ["]".[n-z][a-m][N-Z][A-M]"[" ]TTT
|
||||
"[tr] !q"T:xld
|
||||
["rot13: fatal: need exactly one argument"`q]:gld
|
||||
["rot13: fatal: cannot open "1ST`q]:hld
|
||||
a2_+=g
|
||||
1A 0 [ that 0 is for RDONLY ]ld
|
||||
0 'o D0 1s>=hld
|
||||
0Ou1=x [ in a more complex spawner, this would be done under a fork ]ld
|
||||
|
||||
Despite its name, `irot13` is meant to show how to exec a program with
|
||||
redirection from within sorta. You run it as `./brnstnd blah < irot13`; it
|
||||
opens `blah` and runs a (BSD-style) `tr` command to rotate all letters by 13
|
||||
spots. `1A 0 0 o` opens `argv[1]`; the ` ' ` keeps the filename around for
|
||||
subroutine `h` to print a nice error message if necessary. `0Ou` closes
|
||||
stdout and replaces it with the new descriptor. Finally, subroutine `x`
|
||||
executes the `tr`.
|
||||
|
||||
|
||||
# [sorta.isleep](sorta.isleep)
|
||||
|
||||
|
||||
["" "+sleep" "+5" "sleep" !q]:S [F0>1_+=S]:s
|
||||
"forking sleep 5..."`ld
|
||||
1=s
|
||||
"waiting for sleep to finish..."`ld
|
||||
w
|
||||
"done, sleep exit code " #T`
|
||||
|
||||
This script illustrates the classic fork-exec-wait.
|
||||
|
||||
|
||||
# [sorta.itailrec](sorta.itailrec)
|
||||
|
||||
[3*#" "T$ldD=f]:f
|
||||
1=f
|
||||
|
||||
The sole purpose of this script is to prove that sorta can do infinite
|
||||
tail recursion (in this case, in program `f`). Do `./brnstnd < itailrec | more`
|
||||
and watch the powers of 3 (mod your computer's word size) flow by.
|
||||
|
||||
|
||||
# [sorta.iwhosort](sorta.iwhosort)
|
||||
|
||||
[0Ou "" "+-u" "sort" !q]:S [F0>1_+=S]:s
|
||||
[1Ou "" "+-u" "who" !q]:W [F0>1_+=W]:w
|
||||
P1=wO1=sOww
|
||||
|
||||
This final example is a simple pipeline, `who | sort`.
|
||||
Reference in new issue
Block a user