Fixes in 1986/marshall/compilers.{md,html}

1986/marshall/compilers.md

@@ -1,6 +1,6 @@
 # Conflicting compilers and optimisers that broke this entry in 2023
 
-As briefly noted in the [index.html](index.html) gcc and clang caused different
+As briefly noted in the [index.html](index.html) `gcc` and `clang` caused different
 problems with this entry depending on the optimiser being enabled or not, where
 if the optimiser was enabled it would work with one compiler and not the other.
 But if you then disabled the optimiser the opposite problem would occur: the
@@ -10,7 +10,7 @@ work! And then there's the problem of linux versus macOS causing problems.
 The [alternate code](%%REPO_URL%%/1986/marshall/marshall.alt.c) (source code) demonstrates the problem so
 you can see if your compiler has the problem as described below.
 
-In some versions of gcc and clang (this was first discovered in fedora linux 38)
+In some versions of `gcc` and `clang` (this was first discovered in fedora linux 38)
 if the compiler was enabled one compiler would generate code that segfaulted but
 the other one would not. However, when then disabling the optimiser the compiler
 that had no problem suddenly did and the one that did suddenly did not. But
@@ -22,11 +22,12 @@ segfault.
 
 It was not only one compiler that dumped core. Both dumped core with other
 behaviour, depending on what changes in code were made and the optimiser being
-on or off. Clang in macOS also dumped core!
+on or off. `Clang` in macOS also dumped core!
 
-The [index.html](index.html) has the original fix
-for clang which works with some compilers depending on the optimiser. When we
-refer to the code below we refer to the alternate code.
+The [marshall.c](%%REPO_URL%%/1986/marshall/marshall.c) has the original fix
+for `clang` which works with some compilers depending on the optimiser. When we
+refer to the code below we refer to the [alternate code,
+marshall.alt.c](%%REPO_URL%%/1986/marshall/marshall.alt.c).
 
 ## The conflicting compiler problems:
 
@@ -35,20 +36,20 @@ the original code.
 
 ### Linux
 
-With the optimiser disabled GCC compiled the code to enter an infinite loop.
-Enabling the optimiser and it worked fine. But if the optimiser is enabled clang
-generates code that first prints the text twice (it should print it once) and
+With the optimiser disabled `GCC` compiled the code to enter an infinite loop.
+If the optimiser was enabled it worked fine. But if the optimiser is enabled
+`clang` generates code that first prints the text twice (it should print it once) and
 then immediately dumps core!
 
 But then there's that infinite loop. What happens if we remove it?
 
-Once the loop is removed if we compile with clang and the optimiser is disabled
-all is okay. If however we compile with gcc and the optimiser is disabled the
+Once the loop is removed if we compile with `clang` and the optimiser is disabled
+all is okay. If however we compile with `gcc` and the optimiser is disabled the
 string is printed once and then the program dumps core! Why is this? It is
 because of the call to `_exit()` (see below).
 
-Clang works fine with the loop removed and the optimiser disabled. If however we
-enable the optimiser clang will generate code that prints the string twice and
+`Clang` works fine with the loop removed and the optimiser disabled. If however we
+enable the optimiser `clang` will generate code that prints the string twice and
 dumps core just like before!  What about the call to `_exit()`?
 
 The call was:
@@ -90,7 +91,7 @@ And that is the tale of a little <del>engine</del> train that
 could...eventually! Or perhaps it's the compilers, optimisers and OSes that
 eventually could?
 
-Whichever you wish it to be, it now works with both clang and gcc! Choo choo!
+Whichever you wish it to be, it now works with both `clang` and `cc` Choo choo!
 
 
 <hr style="width:10%;text-align:left;margin-left:0">