VADE: cleanup conversion from latex

Author: chrisws

_build/pages/vade.markdown

@@ -22,7 +22,7 @@ Contents
 :::
 
 The process of preparing programs for a digital computer is especially
-attractive because it not only can be economically and scientifially
+attractive because it not only can be economically and scientifically
 rewarding, it can also be an aesthetic experience much like composing
 poetry or music. -- [Donald F. Knuth]{.smallcaps}
 

_build/pages/vade_control.markdown

@@ -48,7 +48,7 @@ they don't need to refer to the same variable. If you want to test a
 single value against several possible outcomes, is probably a better
 option, see .
 
-Several clauses can be nested. It's your resposibility to make sure than
+Several clauses can be nested. It's your responsibility to make sure than
 they are properly closed, especially when you're using many / branches.
 
 If your »deserts are small«,[^1] and you don't have to process
@@ -112,7 +112,7 @@ Note that, compared to other programming languages, there are several
 limitations to the construct:
 
 -   No required or even allowed. This makes it impossible to achieve
-    a »fallthrough« of several clauses (intentionally or
+    a »fall through« of several clauses (intentionally or
     accidentally).
 
 -   There is no way to compare for inequality (like -- this would be an
@@ -137,14 +137,14 @@ other programming languages:
 
 The keyword and the subsequent increment (which can be any expression,
 not necessarily only a variable) are optional; if they're missing, the
-increment is set to $1$. There is no need to add to the keyword the name
+increment is set to `1`. There is no need to add to the keyword the name
 of the loop variable.[^2]
 
 The index loop variable will be set to the initial value , and the code
 inside the loop executed at least once. Upon reaching the corresponding
 statement, the index is compared to the limit given after the keyword.
 If the index is smaller or equal to , the index is incremented by the ,
-if this is provided, or by $1$), and the loop is traversed once more.
+if this is provided, or by `1`), and the loop is traversed once more.
 (If is negative, the situation is obviously reversed.)
 
 This means that to traverse through a complete array (assuming it uses
@@ -241,8 +241,8 @@ repeated until an expression will be fulfilled. Note two important
 differences though:
 
 -   In a loop, the loop is executed as long as the expression is *true*
-    (ie, unequal to $0$), whereas a loop is executed as long as the
-    expression is *false*, or $0$.
+    (ie, unequal to `0`), whereas a loop is executed as long as the
+    expression is *false*, or `0`.
 
 -   In a loop, the test for the expression is performed at the
     *beginning* of the loop, but in a loop, the expression test takes
@@ -297,7 +297,7 @@ Exceptions:
 ------------
 
 Exceptions provide a fairly comfortable way to catch runtime errors
-occuring unexpectedly in your program. Of course, they can't help with
+occurring unexpectedly in your program. Of course, they can't help with
 faulty program logic. Rather, exceptions are supposed to handle files
 not conforming to an expected format, hardware problems and the like.
 
@@ -335,7 +335,7 @@ to this variable (provided any error occured at all). The corresponding
 section will then be executed, regardless of the exact nature of the
 error.
 
-The second option is thus preferrable if you either want to have a
+The second option is thus preferable if you either want to have a
 simple »catch all« which will deal with any imaginable error in a
 single sweep, or, at the other extreme, if the error conditions you
 expect to encounter are so confusing that you'd rather dedicate some

_build/pages/vade_data.markdown

@@ -39,9 +39,9 @@ data it is fed with.
 Simple Variables
 ----------------
 
-Simple variables **need not be declared**; they come into existance by
+Simple variables **need not be declared**; they come into existence by
 their first appearance in the source code. If they are not created
-through an assignment, they will be initiated to the value »$0$«
+through an assignment, they will be initiated to the value »`0`«
 (or, equivalently, to the empty string »\"\"«. (This example
 admittedly looks a little silly.)
 
@@ -80,16 +80,12 @@ Many languages have different types for various flavours of numbers --
 signed or unsigned integers, reals, etc. -- In contrast, SmallBASIC only has a
 single class of numbers.[^4]
 
-SmallBASIC numbers can have absolute values roughly between $2.2\cdot
-10^{-208}$ (smaller values are considered $0$) and $1.8\cdot 10^{308}$
-(larger values raise a flag (for »infinity«).
-
 ### Strings
 
 Strings are chains of one or several letters, used to represent words,
 sentences or complete texts. A string consisting of zero letters is
 called an »empty« string. (While I have a strong hunch that
-strings are internally represented with UTF-8 unicode characters, it's
+strings are internally represented with UTF-8 Unicode characters, it's
 probably safer to only assign ASCII letters to them.)
 
     my_name= "Elmar Vogt"
@@ -102,7 +98,7 @@ length: In the course of a program, they can change their length
 arbitrarily, and there is no need to define a maximum length for them. A
 theoretical upper length limit is set at 2 billion characters.[^5]
 
-**String concatenation** is done with the $+$ operator:
+**String concatenation** is done with the `+` operator:
 
     my_name= "Elmar Vogt"
     greeting= "Hello, my name is "
@@ -111,7 +107,7 @@ theoretical upper length limit is set at 2 billion characters.[^5]
 
     > Hello, my name is Elmar Vogt
 
-The $+$ operator combines the string operands to the left and to the
+The `+` operator combines the string operands to the left and to the
 right of it to a new, third string, the length of which is the sum of
 the individual strings' lengths. If either the left or the right operand
 is a number -- a literal or a variable --, then this operand will be
@@ -127,7 +123,7 @@ contained in the string:[^7]
     > 11
 
 **String indexing** is done with the first character of a string being
-considere to be at position $1$:[^8]
+considered to be at position `1`:[^8]
 
     ? mid("Help me", 4, 1)
 
@@ -149,8 +145,8 @@ look like this:
     next i
 
 Note that this in contrast with the use of arrays (see below), where the
-first array element has the index $0$, and for an array with $n$
-elements the highest index is $n-1$.
+first array element has the index `0`, and for an array with `n`
+elements the highest index is `n-1`.
 
 Complex data structures
 -----------------------
@@ -186,7 +182,7 @@ array member, its name is followed by the index in parentheses :
     hoogla(i)= boogla(250)
 
 will assign the value of 's 250th member to the member of with the
-numberical index .
+numerical index .
 
 Array members can be of **mixed content**, ie it's perfectly okay for
 one member of an array to hold a number, and for a different member of
@@ -199,10 +195,10 @@ numerical value:
 
     dim hoogla(250)
 
-will define to initially have $251$ members with indices $0..250$. This
+will define to initially have `251` members with indices `0..250`. This
 **array indexing** contrasts with the indexing of strings.
 
-Array members can be erased from the array with . Note that if the $i$th
+Array members can be erased from the array with . Note that if the `i`th
 member of an array is deleted, then all array members with higher
 indices »move down« one notch, ie the value of will now be in .
 
@@ -212,8 +208,8 @@ operator .[^11]
     dim hoogla(250)
     hoogla << 132
 
-means that now will have $252$ members, and the new $252$nd member (with
-the index $251$) will have the value $132$.
+means that now will have `252` members, and the new `252`nd member (with
+the index `251`) will have the value `132`.
 
 Arrays are not limited to being a chain of values. **Several array
 dimensions** can be defined to render arrays of &raquo;rectangular&laquo;,
@@ -222,17 +218,17 @@ dimensions** can be defined to render arrays of &raquo;rectangular&laquo;,
     dim hoogla(10, 20, 10)
     hoogla(5, 9, 8)= "blubbdi"
 
-will create an array with $11 \times 21 \times 11$ members, or access
+will create an array with `11 \times 21 \times 11` members, or access
 one particular member, resp. For obvious reasons, it's not possible to
-members of such a higher-dimensional array in the abovementioned way.
+members of such a higher-dimensional array in the above mentioned way.
 Likewise, using the appendix operator with a higher-dimensional array
 should be avoided.[^12]
 
 The maximum array size is virtually unlimited. But note that with the
 introduction of new array dimensions, the space and performance
 requirements increase exponentially.
 
-### Maps [\[map\]]{#map label="map"}
+### Maps
 
 Maps differ from arrays in two ways: Firstly, while arrays always have a
 linear or &raquo;rectangular&laquo; structure, **maps are &raquo;data trees&laquo;,
@@ -261,13 +257,13 @@ and thus to create havoc at runtime.
 **Map initialisation** can be done by in three ways: Either explicitly,
 by using the keyword *without* an array size (ie, simply is enough),
 through the keyword (see below), or implicitly by assigning the map
-members values by a sequence of comma-seperated values, enclosed in
+members values by a sequence of comma-separated values, enclosed in
 square brackets :
 
     hoogla= [10, 9, 8, 7, 6, 1]
 
-initialises a simple map with $6$ members with automatically generated
-indices from $0$ to $5$.
+initialises a simple map with `6` members with automatically generated
+indices from `0` to `5`.
 
 To create more complex structures, each map member which is a map again
 must be enclosed in brackets. For example,
@@ -319,7 +315,7 @@ be a real value, or even a string:
     boogla("nuffda")= ...
 
 The second option uses the &raquo;dot notation&laquo; familiar from other
-languages like &raquo;C&laquo;, seperating the name from the member key with a
+languages like &raquo;C&laquo;, separating the name from the member key with a
 dot :
 
     boogla.nuffda= ...
@@ -358,35 +354,30 @@ When accessing in the third line, in the first term , is replaced with
 its value by the interpreter, before looking the map member with that
 name up and returning the result, . In the second term , the interpreter
 looks for a member of with the key , can't find one, and tacitly creates
-a new one which is initialized with the value $0$.[^15]
+a new one which is initialized with the value `0`.[^15]
 
 This makes the parentheses notation particularly useful when you want to
 decide at runtime which map member you want to access: With dot
 notation, access is fixed, but with parentheses notation you can pass a
 variable to determine which member to use in that instance.
 
-###  [\[cLen\]]{#cLen label="cLen"}
-
 For both arrays and maps, will give you the number of elements in the
 structure. But note that this isn't the total number of elements, but
 only the number of elements in the &raquo;top dimension&laquo;.
 
 For example, when initializing an array as
 
     boogla= [1, 2, [4, 5, 6, 7], 2390023, [3.1415926, "hoogla!"], 99]
-    \end
 
-    \Co{len(boogla)} will be $6$, as this is the number of first-dimension
-    members, not 10, which would be the total number of elements.
+    'boogla will be 6, as this is the number of first-dimension
+    'members, not 10, which would be the total number of elements.
 
-    \subsection{Almost, but Not Quite the Same (Not a Rose by any other
-    Name)}
+    'Almost, but Not Quite the Same (Not a Rose by any other Name
 
-    The \textbf{near-but-not-quite equivalency of maps and arrays} leads to
-    interesting consequences, read: causes for unexpected trouble. For
-    example, in the following code
+    'The near-but-not-quite equivalency of maps and arrays leads to
+    'interesting consequences, read: causes for unexpected trouble. For
+    'example, in the following code
 
-    \begin{lstlisting}
     dim x
     dim z
     x("hello")= 10
@@ -462,7 +453,7 @@ Continue the above code:
 
     > 20        50
 
-What gives? When executing , the value $50$ is assigned to the variable
+What gives? When executing , the value `50` is assigned to the variable
 , which from this point on no longer holds 's address; the link between
 the two variables is broken, and the variables go their seperate ways.
 So, as long as is a reference to , it will always reflect the current
@@ -537,15 +528,15 @@ it *must*.
 [^5]: Even before that SmallBASIC tends to get too tediously slow for all
     practical purposes.
 
-[^6]: Obviously, if *both* operands are numbers, $+$ will perform a
+[^6]: Obviously, if *both* operands are numbers, `+` will perform a
     simple addition and assign the sum of both values to the variable on
     the left of the equality sign.
 
 [^7]: The function returns the length of the following argument in
     brackets
 
-[^8]: The function returns $z$ characters from the string $x$, beginning
-    with the $y$th
+[^8]: The function returns `z` characters from the string `x`, beginning
+    with the `y`th
 
 [^9]: The function returns the length of its string argument, in number
     of characters

_build/pages/vade_intro.markdown

@@ -89,12 +89,10 @@ you when you want to get more closely acquainted with :
 Licenses
 --------
 
--   SmallBASIC is released under the [GNU General Public License version 2.0
-    (GPLv2)](http://www.gnu.org/licenses/old-licenses/gpl-2.0)
+-   SmallBASIC is released under the [GNU General Public License version 2.0 (GPLv2)](http://www.gnu.org/licenses/old-licenses/gpl-2.0)
 
 -   This document, the »Vademecum«, is released under the
-    [Creative Commons License
-    by-nc-nd](http://creativecommons.org/licenses/by-nc-nd/3.0/de/deed.en_GB).
+    [Creative Commons License by-nc-nd](http://creativecommons.org/licenses/by-nc-nd/3.0/de/deed.en_GB).
     In short, this license means that you are free to reproduce and
     distribute this document in any non-commercial manner, as long as
     you don't change the author's name (that's mine), and as long as the

_build/pages/vade_structure.markdown

@@ -108,7 +108,7 @@ also maintain their own »household« of variables accessible only
 to them.
 
 The keyword is used to define variables »attached« to a routine.
-The variables come into existance the minute the routine is invoked, and
+The variables come into existence the minute the routine is invoked, and
 they're deleted again as soon as the routine is terminated. If a local
 variable (or a routine parameter) has the same name as variable
 previously defined (in the main program or a routine which called the
@@ -144,11 +144,11 @@ details from that of other programming languages and BASIC dialects:
     > In main:      100 99
 
 Let's have a look at what is actually happening here. First, the global
-variables and are defined and assigned the values $100$ and $200$, resp.
+variables and are defined and assigned the values `100` and `200`, resp.
 Next, is invoked and defines a local variable which »shadows« the
-global variable of the same name. Thus, the value $30$ is assigned to
+global variable of the same name. Thus, the value `30` is assigned to
 the local instance of , not to the global one. As opposed to that, there
-only is one instance of , and the value $200$ is written to that.
+only is one instance of , and the value `200` is written to that.
 
 Next, is called, which has access to all the »knowledge« has. When
 the old values of and are overwritten, this happens again to the local
@@ -176,8 +176,8 @@ create a new *global* variable first:
     > 10
 
 This creates (or overwrites) a global variable with the name and the
-value $100$, then creates a local variable with the same name, assigns
-it the value $10$, and then destroys the local copy at the end of the
+value `100`, then creates a local variable with the same name, assigns
+it the value `10`, and then destroys the local copy at the end of the
 procedure, while the global copy still lives on.
 
 Routines can **recurse**, ie invoke themselves again before they're
@@ -327,7 +327,7 @@ Think of it as a simple copy-paste operation.
 creation of genuine program libraries with their own namespace and
 well-defined interfaces.
 
-Units are kept in seperate source files; each file contains exactly one
+Units are kept in separate source files; each file contains exactly one
 unit which bears the same name as the file *sans* the extension.[^6]
 
     file hoogla.bas:
@@ -338,7 +338,7 @@ unit which bears the same name as the file *sans* the extension.[^6]
     zoogla= "Hello world!"
 
     sub boogla(name)
-        print "Goodybe", name, "!"
+        print "Goodbye", name, "!"
     end
 
 Inside the unit file, you can write code as you would in any source
@@ -350,7 +350,7 @@ keyword .
 First level code is executed when the library is loaded, but it takes
 place in a separate namespace, ie a variable called in the unit file
 will not conflict with a variable with the same name in the mother file;
-they're two seperate entities.
+they're two separate entities.
 
 To use a unit, it must be first be compiled into bytecode. You can do so
 from the IDE, or use the command line:
@@ -375,7 +375,7 @@ With the above code segment from you get:
 
 It should be painfully obvious that a unit can't import itself again.
 
-[^1]: Most times a disctinction between »arguments« and
+[^1]: Most times a distinction between »arguments« and
     »parameters« is made in computer literature, but we'll treat
     both as synonyms.