improved indentation and whitespace for markdown code blocks

All code blocks in markdown have been intended by at least 4 spaces. 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 from "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`. Fixed excess whitespace after list Author on entry `index.html` page. Changed `bin/output-index-author.sh` VERSION from "1.5.2 2024-03-26" to "1.6 2024-03-31". Performed `make www` to perform the above and test under macOS. TODO: Fix the problem of the initial line of code being extra intended. TODO: Fix excess whitespace around code that is inline.
2024-04-01 04:48:48 -07:00
1 parent b84c27ce02
commit a996f8d2b8
@@ -1,7 +1,7 @@
 ## To build:

 ```sh
-make
+    make
 ```


@@ -10,7 +10,7 @@ make
 The current status of this entry is:

 ```
-STATUS: INABIAF - please **DO NOT** fix
+    STATUS: INABIAF - please **DO NOT** fix
 ```

 For more detailed information see [2013 endoh1 bugs](../../bugs.html#2013_endoh1).
@@ -19,20 +19,20 @@ For more detailed information see [2013 endoh1 bugs](../../bugs.html#2013_endoh1
 ## To use:

 ```sh
-./endoh1 [file.lazy]
+    ./endoh1 [file.lazy]
 ```


 ## Try:

 ```sh
-./try.sh
+    ./try.sh
 ```

 You might also enjoy running:

 ```sh
-cc -E endoh1.c | less
+    cc -E endoh1.c | less
 ```


@@ -51,9 +51,9 @@ This entry can be considered an abuse of the GCC's optimizer; it takes GCC about
 ### Remarks

 ```sh
-less endoh1.c
-gcc -o endoh1 endoh1.c
-./endoh1
+    less endoh1.c
+    gcc -o endoh1 endoh1.c
+    ./endoh1
 ```

 ... Isn't there any more to it?
@@ -67,8 +67,8 @@ This program will shine when it is used as a library.  For example,
 [hello.lazy](hello.lazy) is a "Hello world" program written in Lazy K.

 ```sh
-$ lazy hello.lazy
-Hello, world!
+    $ lazy hello.lazy
+    Hello, world!
 ```

 where `lazy` is [a reference implementation of Lazy K][3].  At the same time,
@@ -76,9 +76,9 @@ where `lazy` is [a reference implementation of Lazy K][3].  At the same time,
 as a library.

 ```sh
-$ gcc -o hello -xc hello.lazy
-$ ./hello
-Hello, world!
+    $ gcc -o hello -xc hello.lazy
+    $ ./hello
+    Hello, world!
 ```

 In other words, this program is a kind of [polyglot][4].
@@ -137,9 +137,9 @@ I confirmed that the program successfully worked with the following compilers:
 Recent compilers with `-Wall -W -Wextra -pedantic` say nothing.

 ```sh
-gcc -Wall -W -Wextra -pedantic prog.c
-clang -Wall -W -Wextra -pedantic prog.c
-tcc -Wall -W -Wextra -pedantic prog.c
+    gcc -Wall -W -Wextra -pedantic prog.c
+    clang -Wall -W -Wextra -pedantic prog.c
+    tcc -Wall -W -Wextra -pedantic prog.c
 ```

 I think it will work on almost all platforms.  I confirmed:
@@ -174,7 +174,7 @@ combinator calculus.  The rewriting rules are shown in the shape of the code.
 Consider a sequence of function applications in C:

 ```c
-s(x)(x)(x)(x)...
+    s(x)(x)(x)(x)...
 ```

 What type should `s` have?  Unfortunately, C does *not* provide a "recursive
@@ -183,7 +183,7 @@ type", such as `typedef f (*f)();`.
 So, I used a heavily nested function pointer type:

 ```c
-typedef void *(*(*(*...(*(f))()...)())())
+    typedef void *(*(*(*...(*(f))()...)())())
 ```

 This limits how many arguments one function can be consecutively applied to.
@@ -208,11 +208,11 @@ So, I addressed this issue by generating many function definitions
 statically by (ab)using macros:

 ```c
-void *x1; void f1(void *y) { return apply(x1, y); }
-void *x2; void f2(void *y) { return apply(x2, y); }
-void *x3; void f3(void *y) { return apply(x3, y); }
-...
-void *(h[]) = { f1, f2, f3, ... }
+    void *x1; void f1(void *y) { return apply(x1, y); }
+    void *x2; void f2(void *y) { return apply(x2, y); }
+    void *x3; void f3(void *y) { return apply(x3, y); }
+    ...
+    void *(h[]) = { f1, f2, f3, ... }
 ```

 and by allotting each of them when a closure is needed.
@@ -132,8 +132,7 @@
 <h2 id="author"><a name="author"></a>Author:</h2>
 <ul>
 <li>Name: <a href="../../authors.html#Yusuke_Endoh">Yusuke Endoh</a><br>
-Location: <a href="../../location.html#JP">JP</a> - <em>Japan</em>
-<br><br></li>
+Location: <a href="../../location.html#JP">JP</a> - <em>Japan</em></li>
 </ul>

 <!-- END: next line ends content generated by: bin/output-index-author.sh -->
@@ -142,17 +141,17 @@ Location: <a href="../../location.html#JP">JP</a> - <em>Japan</em>
 <!-- START: this line starts content for HTML phase 21 by: bin/pandoc-wrapper.sh via bin/md2html.sh -->

 <h2 id="to-build">To build:</h2>
-<div class="sourceCode" id="cb1"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a><span class="fu">make</span></span></code></pre></div>
+<div class="sourceCode" id="cb1"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb1-1"><a href="#cb1-1" aria-hidden="true" tabindex="-1"></a>    <span class="fu">make</span></span></code></pre></div>
 <h3 id="bugs-and-misfeatures">Bugs and (Mis)features:</h3>
 <p>The current status of this entry is:</p>
-<pre><code>STATUS: INABIAF - please **DO NOT** fix</code></pre>
+<pre><code>    STATUS: INABIAF - please **DO NOT** fix</code></pre>
 <p>For more detailed information see <a href="../../bugs.html#2013_endoh1">2013 endoh1 bugs</a>.</p>
 <h2 id="to-use">To use:</h2>
-<div class="sourceCode" id="cb3"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a><span class="ex">./endoh1</span> <span class="pp">[</span><span class="ss">file.lazy</span><span class="pp">]</span></span></code></pre></div>
+<div class="sourceCode" id="cb3"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb3-1"><a href="#cb3-1" aria-hidden="true" tabindex="-1"></a>    <span class="ex">./endoh1</span> <span class="pp">[</span><span class="ss">file.lazy</span><span class="pp">]</span></span></code></pre></div>
 <h2 id="try">Try:</h2>
-<div class="sourceCode" id="cb4"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a><span class="ex">./try.sh</span></span></code></pre></div>
+<div class="sourceCode" id="cb4"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb4-1"><a href="#cb4-1" aria-hidden="true" tabindex="-1"></a>    <span class="ex">./try.sh</span></span></code></pre></div>
 <p>You might also enjoy running:</p>
-<div class="sourceCode" id="cb5"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a><span class="fu">cc</span> <span class="at">-E</span> endoh1.c <span class="kw">|</span> <span class="fu">less</span></span></code></pre></div>
+<div class="sourceCode" id="cb5"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb5-1"><a href="#cb5-1" aria-hidden="true" tabindex="-1"></a>    <span class="fu">cc</span> <span class="at">-E</span> endoh1.c <span class="kw">|</span> <span class="fu">less</span></span></code></pre></div>
 <h2 id="judges-remarks">Judges’ remarks:</h2>
 <p>We liked this entry because it can serve as a standalone program as well as an
 include file; and, as usual, because its input data is at least as obfuscated as
@@ -161,23 +160,23 @@ the program itself.</p>
 4x longer to compile it with -O3 than without, compared to clang’s 2x.</p>
 <h2 id="authors-remarks">Author’s remarks:</h2>
 <h3 id="remarks">Remarks</h3>
-<div class="sourceCode" id="cb6"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a><span class="fu">less</span> endoh1.c</span>
-<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a><span class="fu">gcc</span> <span class="at">-o</span> endoh1 endoh1.c</span>
-<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a><span class="ex">./endoh1</span></span></code></pre></div>
+<div class="sourceCode" id="cb6"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb6-1"><a href="#cb6-1" aria-hidden="true" tabindex="-1"></a>    <span class="fu">less</span> endoh1.c</span>
+<span id="cb6-2"><a href="#cb6-2" aria-hidden="true" tabindex="-1"></a>    <span class="fu">gcc</span> <span class="at">-o</span> endoh1 endoh1.c</span>
+<span id="cb6-3"><a href="#cb6-3" aria-hidden="true" tabindex="-1"></a>    <span class="ex">./endoh1</span></span></code></pre></div>
 <p>… Isn’t there any more to it?</p>
 <p>Yes, of course.</p>
 <p>This is a tool <em>for C programmers</em> to play the <a href="http://en.wikipedia.org/wiki/SKI_combinator_calculus">SKI combinator calculus</a>,
 especially, <a href="https://tromp.github.io/cl/lazy-k.html">Lazy K</a>.</p>
 <p>This program will shine when it is used as a library. For example,
 <a href="hello.lazy">hello.lazy</a> is a “Hello world” program written in Lazy K.</p>
-<div class="sourceCode" id="cb7"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a><span class="ex">$</span> lazy hello.lazy</span>
-<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a><span class="ex">Hello,</span> world!</span></code></pre></div>
+<div class="sourceCode" id="cb7"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb7-1"><a href="#cb7-1" aria-hidden="true" tabindex="-1"></a>    <span class="ex">$</span> lazy hello.lazy</span>
+<span id="cb7-2"><a href="#cb7-2" aria-hidden="true" tabindex="-1"></a>    <span class="ex">Hello,</span> world!</span></code></pre></div>
 <p>where <code>lazy</code> is <a href="https://github.com/irori/lazyk">a reference implementation of Lazy K</a>. At the same time,
 <a href="hello.lazy">hello.lazy</a> is <em>a valid C program</em> that uses <a href="endoh1.c">endoh1.c</a>
 as a library.</p>
-<div class="sourceCode" id="cb8"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a><span class="ex">$</span> gcc <span class="at">-o</span> hello <span class="at">-xc</span> hello.lazy</span>
-<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a><span class="ex">$</span> ./hello</span>
-<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a><span class="ex">Hello,</span> world!</span></code></pre></div>
+<div class="sourceCode" id="cb8"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb8-1"><a href="#cb8-1" aria-hidden="true" tabindex="-1"></a>    <span class="ex">$</span> gcc <span class="at">-o</span> hello <span class="at">-xc</span> hello.lazy</span>
+<span id="cb8-2"><a href="#cb8-2" aria-hidden="true" tabindex="-1"></a>    <span class="ex">$</span> ./hello</span>
+<span id="cb8-3"><a href="#cb8-3" aria-hidden="true" tabindex="-1"></a>    <span class="ex">Hello,</span> world!</span></code></pre></div>
 <p>In other words, this program is a kind of <a href="http://en.wikipedia.org/wiki/Polyglot_%28computing%29">polyglot</a>.</p>
 <p>The usage is simple: you just have to wrap Lazy K program with <code>#include "endoh1.c"</code>. Note that <code>#</code> is a comment in Lazy K.</p>
 <h3 id="obfuscation">Obfuscation</h3>
@@ -211,9 +210,9 @@ section</a>.</p>
 </ul></li>
 </ul>
 <p>Recent compilers with <code>-Wall -W -Wextra -pedantic</code> say nothing.</p>
-<div class="sourceCode" id="cb9"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a><span class="fu">gcc</span> <span class="at">-Wall</span> <span class="at">-W</span> <span class="at">-Wextra</span> <span class="at">-pedantic</span> prog.c</span>
-<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a><span class="fu">clang</span> <span class="at">-Wall</span> <span class="at">-W</span> <span class="at">-Wextra</span> <span class="at">-pedantic</span> prog.c</span>
-<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a><span class="ex">tcc</span> <span class="at">-Wall</span> <span class="at">-W</span> <span class="at">-Wextra</span> <span class="at">-pedantic</span> prog.c</span></code></pre></div>
+<div class="sourceCode" id="cb9"><pre class="sourceCode sh"><code class="sourceCode bash"><span id="cb9-1"><a href="#cb9-1" aria-hidden="true" tabindex="-1"></a>    <span class="fu">gcc</span> <span class="at">-Wall</span> <span class="at">-W</span> <span class="at">-Wextra</span> <span class="at">-pedantic</span> prog.c</span>
+<span id="cb9-2"><a href="#cb9-2" aria-hidden="true" tabindex="-1"></a>    <span class="fu">clang</span> <span class="at">-Wall</span> <span class="at">-W</span> <span class="at">-Wextra</span> <span class="at">-pedantic</span> prog.c</span>
+<span id="cb9-3"><a href="#cb9-3" aria-hidden="true" tabindex="-1"></a>    <span class="ex">tcc</span> <span class="at">-Wall</span> <span class="at">-W</span> <span class="at">-Wextra</span> <span class="at">-pedantic</span> prog.c</span></code></pre></div>
 <p>I think it will work on almost all platforms. I confirmed:</p>
 <ul>
 <li>Ubuntu Linux</li>
@@ -236,11 +235,11 @@ evaluates it.</p>
 combinator calculus. The rewriting rules are shown in the shape of the code.</p>
 <h4 id="abuse-of-function-pointers">Abuse of function pointers</h4>
 <p>Consider a sequence of function applications in C:</p>
-<div class="sourceCode" id="cb10"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a>s<span class="op">(</span>x<span class="op">)(</span>x<span class="op">)(</span>x<span class="op">)(</span>x<span class="op">)...</span></span></code></pre></div>
+<div class="sourceCode" id="cb10"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb10-1"><a href="#cb10-1" aria-hidden="true" tabindex="-1"></a>    s<span class="op">(</span>x<span class="op">)(</span>x<span class="op">)(</span>x<span class="op">)(</span>x<span class="op">)...</span></span></code></pre></div>
 <p>What type should <code>s</code> have? Unfortunately, C does <em>not</em> provide a “recursive
 type”, such as <code>typedef f (*f)();</code>.</p>
 <p>So, I used a heavily nested function pointer type:</p>
-<div class="sourceCode" id="cb11"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a><span class="kw">typedef</span> <span class="dt">void</span> <span class="op">*(*(*(*...(*(</span>f<span class="op">))()...)())())</span></span></code></pre></div>
+<div class="sourceCode" id="cb11"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb11-1"><a href="#cb11-1" aria-hidden="true" tabindex="-1"></a>    <span class="kw">typedef</span> <span class="dt">void</span> <span class="op">*(*(*(*...(*(</span>f<span class="op">))()...)())())</span></span></code></pre></div>
 <p>This limits how many arguments one function can be consecutively applied to.
 But you can increase the number by tweaking the definition of macro <code>p</code>.</p>
 <h4 id="code-duplication-by-macros">Code duplication by macros</h4>
@@ -256,11 +255,11 @@ environment which is a reference to non-local variable.</p>
 (It is feasible by dynamic code generation, but it is far from portable.)</p>
 <p>So, I addressed this issue by generating many function definitions
 statically by (ab)using macros:</p>
-<div class="sourceCode" id="cb12"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> <span class="op">*</span>x1<span class="op">;</span> <span class="dt">void</span> f1<span class="op">(</span><span class="dt">void</span> <span class="op">*</span>y<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> apply<span class="op">(</span>x1<span class="op">,</span> y<span class="op">);</span> <span class="op">}</span></span>
-<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> <span class="op">*</span>x2<span class="op">;</span> <span class="dt">void</span> f2<span class="op">(</span><span class="dt">void</span> <span class="op">*</span>y<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> apply<span class="op">(</span>x2<span class="op">,</span> y<span class="op">);</span> <span class="op">}</span></span>
-<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> <span class="op">*</span>x3<span class="op">;</span> <span class="dt">void</span> f3<span class="op">(</span><span class="dt">void</span> <span class="op">*</span>y<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> apply<span class="op">(</span>x3<span class="op">,</span> y<span class="op">);</span> <span class="op">}</span></span>
-<span id="cb12-4"><a href="#cb12-4" aria-hidden="true" tabindex="-1"></a><span class="op">...</span></span>
-<span id="cb12-5"><a href="#cb12-5" aria-hidden="true" tabindex="-1"></a><span class="dt">void</span> <span class="op">*(</span>h<span class="op">[])</span> <span class="op">=</span> <span class="op">{</span> f1<span class="op">,</span> f2<span class="op">,</span> f3<span class="op">,</span> <span class="op">...</span> <span class="op">}</span></span></code></pre></div>
+<div class="sourceCode" id="cb12"><pre class="sourceCode c"><code class="sourceCode c"><span id="cb12-1"><a href="#cb12-1" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> <span class="op">*</span>x1<span class="op">;</span> <span class="dt">void</span> f1<span class="op">(</span><span class="dt">void</span> <span class="op">*</span>y<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> apply<span class="op">(</span>x1<span class="op">,</span> y<span class="op">);</span> <span class="op">}</span></span>
+<span id="cb12-2"><a href="#cb12-2" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> <span class="op">*</span>x2<span class="op">;</span> <span class="dt">void</span> f2<span class="op">(</span><span class="dt">void</span> <span class="op">*</span>y<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> apply<span class="op">(</span>x2<span class="op">,</span> y<span class="op">);</span> <span class="op">}</span></span>
+<span id="cb12-3"><a href="#cb12-3" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> <span class="op">*</span>x3<span class="op">;</span> <span class="dt">void</span> f3<span class="op">(</span><span class="dt">void</span> <span class="op">*</span>y<span class="op">)</span> <span class="op">{</span> <span class="cf">return</span> apply<span class="op">(</span>x3<span class="op">,</span> y<span class="op">);</span> <span class="op">}</span></span>
+<span id="cb12-4"><a href="#cb12-4" aria-hidden="true" tabindex="-1"></a>    <span class="op">...</span></span>
+<span id="cb12-5"><a href="#cb12-5" aria-hidden="true" tabindex="-1"></a>    <span class="dt">void</span> <span class="op">*(</span>h<span class="op">[])</span> <span class="op">=</span> <span class="op">{</span> f1<span class="op">,</span> f2<span class="op">,</span> f3<span class="op">,</span> <span class="op">...</span> <span class="op">}</span></span></code></pre></div>
 <p>and by allotting each of them when a closure is needed.</p>
 <p>This leads to another limitation: the number of pre-defined closures limits how
 many identifiers (<code>S</code> <code>K</code> <code>I</code>) one program can use.</p>