Fix formatting issues in Chapter 3

Missing newlines cause RedCloth to evaluate
code as formatting. Adding them in fixes ths issues.

Added inline backticks when discussing some variables.

Author: hamiltop

name.textile

@@ -16,7 +16,7 @@ h3. Summary
 
 I previously mentioned that the `st_table` is a hash table. What is a hash
 table? It is a data structure that records one-to-one relations, for
-example, variable name and its value, function name and its body, etc.
+example, a variable name and its value, a function name and its body, etc.
 
 However, data structures other than hash tables can, of course, record
 one-to-one relations. For example, a list of following data structure will
@@ -42,6 +42,7 @@ Now then, let us examine the `st_table`. But first, this library is not
 created by Matsumoto, rather:
 
 ▼ `st.c` credits
+
 <pre class="longlist">
    1  /* This is a public domain general purpose hash table package
          written by Peter Moore @ UCB. */
@@ -52,32 +53,32 @@ created by Matsumoto, rather:
 as shown above.
 
 By the way, when I searched Google and found another version, it mentioned
-that st_table is a contraction of "STring TABLE". However, I find it
+that `st_table` is a contraction of "STring TABLE". However, I find it
 contradictory that it has both "general purpose" and "string" aspects.
 
 h4. What is a hash table?
 
 A hash table can be thought as the following: Let us think of an array with
-n items. For example, let us make n=64 (figure 1).
+`n` items. For example, let us make `n`=64 (figure 1).
 
 !images/ch_name_array.png(Array)!
 
-Then let us specify a function f that takes a key and produces an integer i
-from 0 to n-1 (0-63). We call this f a hash function. f when given the same
-key always produces the i. For example, if we make the assumption that the
+Then let us specify a function f that takes a key and produces an integer `i`
+from 0 to `n`-1 (0-63). We call this `f` a hash function. `f` when given the same
+key always produces the `i`. For example, if we make the assumption that the
 key is limited to positive integers, then if the key is divided by 64 then
 the remainder will always fall between 0 and 63. This method of calculation
-can become function f.
+can become function `f`.
 
-When recording relationships, given a key, function f generates i, and
-place the value into index i of the array we have prepared. In other words,
+When recording relationships, given a key, function `f` generates `i`, and
+place the value into index `i` of the array we have prepared. In other words,
 the index access into an array is very fast. Therefore the fundamental idea
-is to change the key into a integer.
+is to change the key into an integer.
 
 !images/ch_name_aset.png(Array assignment)!
 
 However, in the real world it isn't that easy. There is a critical problem
-with this idea. Because n is only 64, if there are more than 64
+with this idea. Because `n` is only 64, if there are more than 64
 relationships to be recorded, it is certain that i will be the same for two different keys.
 It is also possible that with fewer than 64, the same thing can occur.
 For example, given the previous hash function "key % 64", keys 65 and 129
@@ -111,6 +112,7 @@ chapter, if there is data and code, it is better to read the data first.
 The following is the data type of `st_table`.
 
 ▼ `st_table`
+
 <pre class="longlist">
    9  typedef struct st_table st_table;
 
@@ -125,6 +127,7 @@ The following is the data type of `st_table`.
 </pre>
 
 ▼ `struct st_table_entry`
+
 <pre class="longlist">
   16  struct st_table_entry {
   17      unsigned int hash;
@@ -138,15 +141,17 @@ The following is the data type of `st_table`.
 
 `st_table` is the main table structure. `st_table_entry` is a holder that
 stores one value. `st_table_entry` contains a member called `next` which of
-course is used to make `st_table_entry` into a linked list. This is the chain part of the chaining method.
-The `st_hash_type` data type is used, but I will explain this later. First let
-me explain the other parts so you can compare and understand the roles.
+course is used to make `st_table_entry` into a linked list. This is the chain
+ part of the chaining method. The `st_hash_type` data type is used, but I will
+ explain this later. First let me explain the other parts so you can compare
+and understand the roles.
 
 !images/ch_name_sttable.png(`st_table` data structure)!
 
 So, let us comment on `st_hash_type`.
 
 ▼ `struct st_hash_type`
+
 <pre class="longlist">
   11  struct st_hash_type {
   12      int (*compare)();   /* comparison function */
@@ -187,11 +192,11 @@ And it is called like this:
 </pre>
 
 Here let us return to the `st_hash_type` commentary. Of the two members
-`hash` and `compare`, `hash` is the hash function f explained previously.
+`hash` and `compare`, `hash` is the hash function `f` explained previously.
 
 On the other hand, `compare` is a function that evaluates if the key is actually the
 same or not. With the chaining method, in the spot with the same hash value
-n, multiple elements can be inserted. To know exactly which element is
+`n`, multiple elements can be inserted. To know exactly which element is
 being searched for, this time it is necessary to use a comparison function
 that we can absolutely trust. `compare` will be that function.
 
@@ -202,7 +207,7 @@ same kind of hash for each (data type) is foolish. Usually, the things
 that change with the different key data types are things like the hash
 function. For things like memory allocation and collision detection,
 typically most of the code is the same. Only the parts where the
-implementation changes with a differing data type will bundled up into a
+implementation changes with a differing data type will be bundled up into a
 function, and a pointer to that function will be used. In this fashion, the
 majority of the code that makes up the hash table implementation can
 use it.
@@ -223,6 +228,7 @@ introduced in the previous chapter. This function creates a table for
 integer data type keys.
 
 ▼ `st_init_numtable()`
+
 <pre class="longlist">
  182  st_table*
  183  st_init_numtable()
@@ -238,6 +244,7 @@ on. `type_numhash` is an `st_hash_type` (it is the member named "type" of `st_ta
 Regarding this `type_numhash`:
 
 ▼ `type_numhash`
+
 <pre class="longlist">
   37  static struct st_hash_type type_numhash = {
   38      numcmp,
@@ -271,6 +278,7 @@ it's a good idea to look at the function that does the searching. Shown below is
 function that searches the hash table, `st_lookup()`.
 
 ▼ `st_lookup()`
+
 <pre class="longlist">
  247  int
  248  st_lookup(table, key, value)
@@ -300,6 +308,7 @@ The important parts are pretty much in `do_hash()` and `FIND_ENTRY()`. Let us
 look at them in order.
 
 ▼ `do_hash()`
+
 <pre class="longlist">
   68  #define do_hash(key,table) (unsigned int)(*(table)->type->hash)((key))
 
@@ -320,6 +329,7 @@ function `type->hash` for each data type.
 Next, let us examine `FIND_ENTRY()`.
 
 ▼ `FIND_ENTRY()`
+
 <pre class="longlist">
  235  #define FIND_ENTRY(table, ptr, hash_val, bin_pos) do {\
  236      bin_pos = hash_val%(table)->num_bins;\
@@ -376,6 +386,7 @@ already registered. It always adds a new entry. This is the meaning of `direct`
 in the function name.
 
 ▼ `st_add_direct()`
+
 <pre class="longlist">
  308  void
  309  st_add_direct(table, key, value)
@@ -401,6 +412,7 @@ Then the insertion operation seems to be implemented by `ADD_DIRECT()`.
 Since the name is all uppercase, we can anticipate that is a macro.
 
 ▼ `ADD_DIRECT()`
+
 <pre class="longlist">
  268  #define ADD_DIRECT(table, key, value, hash_val, bin_pos) \
  269  do {                                                     \
@@ -445,6 +457,7 @@ is NULL, this code holds true.
 Now, let me explain the code I left aside.
 
 ▼ `ADD_DIRECT()`-`rehash`
+
 <pre class="longlist">
  271      if (table->num_entries / (table->num_bins)           \
                               > ST_DEFAULT_MAX_DENSITY) {      \
@@ -464,6 +477,7 @@ per bin become too many, `bin` is increased and the crowding is reduced.
 The current `ST_DEFAULT_MAX_DENSITY` is
 
 ▼ `ST_DEFAULT_MAX_DENSITY`
+
 <pre class="longlist">
   23  #define ST_DEFAULT_MAX_DENSITY 5
 
@@ -479,6 +493,7 @@ h3. `st_insert()`
 `st_lookup()`, so if you understand those two, this will be easy.
 
 ▼ `st_insert()`
+
 <pre class="longlist">
  286  int
  287  st_insert(table, key, value)
@@ -521,6 +536,7 @@ The conversion from string to `ID` is executed by `rb_intern()`. This function
 is rather long, so let's omit the middle.
 
 ▼ `rb_intern()` (simplified)
+
 <pre class="longlist">
 5451  static st_table *sym_tbl;       /*  char* to ID   */
 5452  static st_table *sym_rev_tbl;   /*  ID to char*   */
@@ -571,6 +587,7 @@ This function also sets the `ID` classification flags so it is long. Let me
 simplify it.
 
 ▼ `rb_id2name()` (simplified)
+
 <pre class="longlist">
 char *
 rb_id2name(id)
@@ -605,6 +622,7 @@ And it can be obtained like so: `"string".intern`. The implementation of
 `String#intern` is `rb_str_intern()`.
 
 ▼ `rb_str_intern()`
+
 <pre class="longlist">
 2996  static VALUE
 2997  rb_str_intern(str)
@@ -636,6 +654,7 @@ And the reverse operation is accomplished using `Symbol#to_s` and such.
 The implementation is in `sym_to_s`.
 
 ▼ `sym_to_s()`
+
 <pre class="longlist">
  522  static VALUE
  523  sym_to_s(sym)