Updates requested in the review: Bug-fixes, typos, rephrasing.

Author: marek-trtik

src/analyses/README.md

@@ -135,28 +135,29 @@ We discuss all of them in the following sub-sections.
 #### Struct `reaching_definitiont`
 
 Identifies a GOTO instruction where a given variable is defined (i.e. it is set
-a certain value). In consists of these data:
+to a certain value). It consists of these data:
 - `identifier` The name of the variable which was defined.
-- `definition_at` The iterator to the GOTO instruction where the variable is
+- `definition_at` The iterator to the GOTO instruction where the variable 
+  has been written to.
 - `bit_begin` and `bit_end` These two integers define a range of bits (i.e. the
-  begin and end bit indices) which represent the value of the variable. Clearly,
-  `0 <= bit_begin < bit_end`. However, `bit_end` can also be set a special value
-  `-`, which means infinite/unknown index.
+  begin and end bit indices) which represent the value of the variable. So, the
+  integers represents the half-open interval `[bit_begin, bit_end)` of bits.
+  However, `bit_end` can also be set a special value `-1`, which means
+  infinite/unknown index.
 
-There is defined an order of instances of this structure. But its purpose is
-only for to be able to use instances as keys in ordered containers, like
-`std::map`.
+In order to use instances of this structure as keys in ordered containers, such
+as std::map, an ordering is defined.
 
 #### Class `sparse_bitvector_analysist`
 
 An instance of this class provides an assignment of unique numeric `ID` to each
 inserted `reaching_definitionst` instance. Internally, the class holds two data
 members:
 
-- `value_map` It is (an unordered) map from names of program variables to a set
+- `value_map` is an unordered map from names of program variables to a set
   of pairs (`reaching_definitiont`, `ID`). Formally, the map is defined as
   `value_map: var_names -> (reaching_definitionst -> ID)`.
-- `values` It is a map from an `ID` to the corresponding `reaching_definitiont`
+- `values` is a map from an `ID` to the corresponding `reaching_definitiont`
   instance inside the map `value_map`. Namely, the map is implemented as an 
   `std::vector` of iterators to elements of the map `value_map`. An index to
   `values` vector is the `ID` of the related `reaching_definitionst` instance.
@@ -172,8 +173,8 @@ information is held in these data members:
 
 - `has_value` This (three value logic) flag determines, whether the instance
   represents `top`, `bottom`, or any other element of the lattice, by values
-  `TRUE`, `FALSE`, and `UNKNOW` respectively. Initially it is set to `FALSE`.
-- `bv_container` It is a pointer to a
+  `TRUE`, `FALSE`, and `UNKNOWN` respectively. Initially it is set to `FALSE`.
+- `bv_container` is a pointer to a
    `sparse_bitvector_analysist<reaching_definitiont>` instance. It holds the
    actual reaching definitions data of individual program variables. This
    pointer is initially `nullptr` and it is later set (by
@@ -182,13 +183,13 @@ information is held in these data members:
    all `rd_range_domaint` instances. NOTE: `reaching_definitions_analysist`
    inherits from `sparse_bitvector_analysist<reaching_definitiont>` and so
    `this` is passed to `set_bitvector_container` for all instances.  
-- `values` It is (an ordered) map from program variable names to `ID`s of
+- `values` is an ordered map from program variable names to `ID`s of
   `reaching_definitiont` instances stored in map pointed to by `bv_container`.
   The map is not empty only if `has_value` is `UNKNOWN`. Variables in the map
   are all those which are live at the associated instruction.
-- `export_cache` It is a helper data structure. It consists of data already
+- `export_cache` is a helper data structure. It consists of data already
   stored in `values` and `bv_container`. The purpose of this structure is to
-  provide a boost for certain operations (discussed below). It is basically
+  provide a speed-up for certain operations (discussed below). It is basically
   (an ordered) map from (a subset of) variables in `values` to iterators to
   GOTO instructions where the variables are defined. Moreover, each such
   iterator is also associated with a range of bits defining the value of that
@@ -208,7 +209,7 @@ NOTE: The operation actually does not produce a new `join` element. The element
 `a` is modified to become the `join` element. 
 
 NOTE: When union of `a.values[v]` and `b.values[v]` is computed, then `v` must
-removed from the cache `export_cache` 
+be removed from the cache `export_cache`.
 
 ##### Method `transform`
 
@@ -250,7 +251,7 @@ A utility function which updates internal data structures by inserting a
 new reaching definition record, for a passed variable name, written in given
 GOTO instruction (identified by an iterator), at same range of bits.
 
-##### Method `polulate_cache`
+##### Method `populate_cache`
 
 Given a variable name `v` it collects data from `bv_container` for each `ID`
 in `values[v]` and stores them into `export_cache[v]`. Namely, for each