set pandoc 8 character tab stops for HTML conversion
We add `--tab-stop=8` to all `pandoc(1)` executions in order to set a better tab stop indentation, especially for tab intended code blocks. Changed `bin/pandoc-wrapper.sh` VERSION "1.5.3 2024-03-26" to "1.6 2024-03-31". Fixed `1991/brnstnd/sorta.README.md` so that the sorta code is code blocks. Removed unneeded paragraph group in copyright in `inc/footer.default.html`. Performed `make www` to perform the above and test under macOS.
This commit is contained in:
Landon Curt Noll committed
1 parent
7141a1b808
commit
b84c27ce02
402 files changed
+2414
-2396
No files matched your search
@@ -124,47 +124,47 @@
|
||||
|
||||
<p>The <code>sorta</code> scripts described below can sorta be found in this directory.</p>
|
||||
<h1 id="sorta.i22"><a href="sorta.i2+2">sorta.i2+2</a></h1>
|
||||
<pre><code>2 2+#` [ about as basic as you can get ]ld</code></pre>
|
||||
<pre><code> 2 2+#` [ about as basic as you can get ]ld</code></pre>
|
||||
<p>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.</p>
|
||||
<h1 id="sorta.iarg0"><a href="sorta.iarg0">sorta.iarg0</a></h1>
|
||||
<pre><code>0A` [ take arg 0, print it ]</code></pre>
|
||||
<pre><code> 0A` [ take arg 0, print it ]</code></pre>
|
||||
<p>This is self-explanatory.</p>
|
||||
<h1 id="sorta.icalc"><a href="sorta.icalc">sorta.icalc</a></h1>
|
||||
<pre><code>[D2sD3s]:Dld [ input m n, output m n m n ]ld
|
||||
<pre><code> [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
|
||||
[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
|
||||
[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
|
||||
["-"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
|
||||
[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
|
||||
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 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</code></pre>
|
||||
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</code></pre>
|
||||
<p><code>icalc</code> shows off <code>SORTA</code>’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 <code>SORTA</code> doesn’t have a language primitive for
|
||||
@@ -174,51 +174,51 @@ Look at program A.) <code>icalc</code> also provides a useful binary output rout
|
||||
and if you can’t remember offhand that <code>D2sD3s&2sD&1sD&&&D&</code> means XOR,
|
||||
you can just look it up here.</p>
|
||||
<h1 id="sorta.idup"><a href="sorta.idup">sorta.idup</a></h1>
|
||||
<pre><code>[ld#1_+1=y]:x
|
||||
[uD1+=x]:y
|
||||
0""1=y`</code></pre>
|
||||
<pre><code> [ld#1_+1=y]:x
|
||||
[uD1+=x]:y
|
||||
0""1=y`</code></pre>
|
||||
<p>This script prints out the maximum file descriptor available from
|
||||
repeated <code>dup(2)</code>s—usually <code>NOFILE - 1</code>. Can you see how it works?</p>
|
||||
<h1 id="sorta.iecho"><a href="sorta.iecho">sorta.iecho</a></h1>
|
||||
<pre><code>[" "$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</code></pre>
|
||||
<pre><code> [" "$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</code></pre>
|
||||
<p>This is a clone of <code>/bin/echo</code>, minus any argument processing and escape
|
||||
interpretation. (Note that, unlike some shells’ echo, <code>/bin/echo</code> prints a
|
||||
newline even with no arguments.) Try <code>./sorta foo bar < iecho</code>.</p>
|
||||
<h1 id="sorta.ifact1"><a href="sorta.ifact1">sorta.ifact1</a></h1>
|
||||
<pre><code>1#`ld2*#`ld3*#`ld4*#`ld5*#`ld6*#`ld7*#`ld8*#`ld9*#`ld10*#`ld</code></pre>
|
||||
<pre><code> 1#`ld2*#`ld3*#`ld4*#`ld5*#`ld6*#`ld7*#`ld8*#`ld9*#`ld10*#`ld</code></pre>
|
||||
<p>This is a very straightforward factorial program: Take 1, print it,
|
||||
multiply by 2, print it, multiply by 3, print it, etc.</p>
|
||||
<h1 id="sorta.ifact2"><a href="sorta.ifact2">sorta.ifact2</a></h1>
|
||||
<pre><code>[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</code></pre>
|
||||
<pre><code> [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</code></pre>
|
||||
<p><code>ifact1</code> does a lot of repeated work. <code>ifact2</code> takes advantage of this by
|
||||
keeping the current <code>n!</code> <code>n</code> on the stack. Each call to routine <code>f (1=f)</code>
|
||||
increments <code>n</code> by <code>1</code> and prints out the factorial.</p>
|
||||
<h1 id="sorta.ifact3"><a href="sorta.ifact3">sorta.ifact3</a></h1>
|
||||
<pre><code>[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</code></pre>
|
||||
<pre><code> [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</code></pre>
|
||||
<p>Finally, <code>ifact3</code> removes all the redundancy from <code>ifact2</code>, and exhibits
|
||||
proper documentation of stack routines. You can replace the <code>10</code> by
|
||||
anything in this version.</p>
|
||||
<h1 id="sorta.iio"><a href="sorta.iio">sorta.iio</a></h1>
|
||||
<pre><code> [ a simple example of interpreting code on the fly ]ld
|
||||
<pre><code> [ a simple example of interpreting code on the fly ]ld
|
||||
|
||||
["] "2 2+":xT ["]T " produces "T 1=x#T " which should be 4."T`</code></pre>
|
||||
["] "2 2+":xT ["]T " produces "T 1=x#T " which should be 4."T`</code></pre>
|
||||
<p>Notice that <code>"2 2+"</code> is a literal string inside the program.</p>
|
||||
<h1 id="sorta.irot13"><a href="sorta.irot13">sorta.irot13</a></h1>
|
||||
<pre><code>"[] [.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</code></pre>
|
||||
<pre><code> "[] [.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</code></pre>
|
||||
<p>Despite its name, <code>irot13</code> is meant to show how to exec a program with
|
||||
redirection from within <code>sorta</code>. You run it as <code>./sorta blah < irot13</code>; it
|
||||
opens <code>blah</code> and runs a (BSD-style) <code>tr</code> command to rotate all letters by 13
|
||||
@@ -227,23 +227,23 @@ subroutine <code>h</code> to print a nice error message if necessary. <code>0Ou<
|
||||
stdout and replaces it with the new descriptor. Finally, subroutine <code>x</code>
|
||||
executes the <code>tr</code>.</p>
|
||||
<h1 id="sorta.isleep"><a href="sorta.isleep">sorta.isleep</a></h1>
|
||||
<pre><code>["" "+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`</code></pre>
|
||||
<pre><code> ["" "+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`</code></pre>
|
||||
<p>This script illustrates the classic fork-exec-wait.</p>
|
||||
<h1 id="sorta.itailrec"><a href="sorta.itailrec">sorta.itailrec</a></h1>
|
||||
<pre><code>[3*#" "T$ldD=f]:f
|
||||
1=f</code></pre>
|
||||
<pre><code> [3*#" "T$ldD=f]:f
|
||||
1=f</code></pre>
|
||||
<p>The sole purpose of this script is to prove that <code>sorta</code> can do infinite
|
||||
tail recursion (in this case, in program <code>f</code>). Do <code>./sorta < itailrec | more</code>
|
||||
and watch the powers of 3 (mod your computer’s word size) flow by.</p>
|
||||
<h1 id="sorta.iwhosort"><a href="sorta.iwhosort">sorta.iwhosort</a></h1>
|
||||
<pre><code>[0Ou "" "+-u" "sort" !q]:S [F0>1_+=S]:s
|
||||
[1Ou "" "+-u" "who" !q]:W [F0>1_+=W]:w
|
||||
P1=wO1=sOww</code></pre>
|
||||
<pre><code> [0Ou "" "+-u" "sort" !q]:S [F0>1_+=S]:s
|
||||
[1Ou "" "+-u" "who" !q]:W [F0>1_+=W]:w
|
||||
P1=wO1=sOww</code></pre>
|
||||
<p>This final example is a simple pipeline, <code>who | sort</code>.</p>
|
||||
<!--
|
||||
|
||||
@@ -251,11 +251,11 @@ P1=wO1=sOww</code></pre>
|
||||
|
||||
You are free to share and adapt this file under the terms of this license:
|
||||
|
||||
Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
|
||||
Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)
|
||||
|
||||
For more information, see:
|
||||
|
||||
https://creativecommons.org/licenses/by-sa/4.0/
|
||||
https://creativecommons.org/licenses/by-sa/4.0/
|
||||
|
||||
-->
|
||||
|
||||
@@ -292,7 +292,7 @@ P1=wO1=sOww</code></pre>
|
||||
<div class="footer">
|
||||
<h2>Copyright and CC BY-SA 4.0 License</h2>
|
||||
<p>This file and web page is:</p>
|
||||
<blockquote><p><b>Copyright © 1984-2024 by Landon Curt Noll. All Rights Reserved.</b></p></blockquote>
|
||||
<blockquote><b>Copyright © 1984-2024 by Landon Curt Noll. All Rights Reserved.</b></blockquote>
|
||||
<p>You are free to share and adapt this file under the terms of this license:</p>
|
||||
<blockquote><b>Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0)</b></blockquote>
|
||||
<p>For more information, see:</p>
|
||||
|
||||
Reference in new issue
Block a user