Updates requested in the review.

Mostly rewording of few sentences.
There is also added one sentence to Data representation of the grapht: initialisation of inserted node.

Author: marek-trtik

src/analyses/README.md

@@ -95,17 +95,17 @@ To be documented.
 ### Dependence graph
 
 Implemented in `src/analyses/dependence_graph.h(cpp)`. It is a graph and an
-abstract interpreter in the same time. The abstract interpretation nature
+abstract interpreter at the same time. The abstract interpretation nature
 allows a dependence graph to build itself (the graph) from a given GOTO program.
 
 A dependence graph extends the class `grapht` with `dep_nodet` as the type of
 nodes (see `src/util/graph.h` for more details about
 [graph representation](../util/README.md)).
-The `dep_nodet` extends `graph_nodet<dep_edget>` by an iterator to a GOTO
+The `dep_nodet` extends `graph_nodet<dep_edget>` with an iterator to a GOTO
 program instruction. It means that each graph node corresponds to a particular
 program instruction. A labelled edge `(u, v)` of a dependence graph expresses
 a dependency of the program instruction corresponding to node `u` on the program
-instruction corresponding to node `v`. The label of the edge (i.e. data of the
+instruction corresponding to node `v`. The label of the edge (data of the
 type `dep_edget` attached to the edge) denotes the kind of dependency. It can be
 `control-dependency`, `data-dependency`, or both.  
 
@@ -124,11 +124,11 @@ Post-dominators analysis is implemented in `src/analyses/cfg_dominators.h(cpp)`.
 
 The instruction `j` corresponding to node `v` is data-dependent on the
 instruction `i` corresponding to node `u` if and only if `j` may read data from
-memory location defined (i.e. written) by `i`.
+the memory location defined (i.e. written) by `i`.
 
-Reaching definitions analysis together with read-write ranges analysis are used
-to check whether one instruction may read data writen by another instruction.
-For more details see `src/analyses/reaching_definitions.h(cpp)` and
+The reaching definitions analysis is used together with the read-write ranges
+analysis to check whether one instruction may read data writen by another
+instruction. For more details see `src/analyses/reaching_definitions.h(cpp)` and
 `src/analyses/goto_rw.h(cpp)`.
 
 #### Construction
@@ -137,8 +137,8 @@ The dependence graph extends the standard abstract interpreter class `ait`
 with post-dominators analysis and reaching definitions analysis. The domain of
 the abstract interpreter is defined in the class `dep_graph_domaint`.
 
-For each instruction `i` there is created an instance of `dep_graph_domaint`
-associated with `i`. The instance stores a set `control_deps` of program
+For each instruction `i` an instance of `dep_graph_domaint` associated with `i`
+is created. The instance stores a set `control_deps` of program
 instructions the instruction `i` depends on via control-dependency, and a set
 `data_deps` of program instructions the instruction `i` depends on via
 data-dependency. These sets are updated (increased) during the computation,

src/util/README.md

@@ -388,20 +388,22 @@ _not_ be extended - but it may be helpful to be aware of where this happens.
 \subsection Graph
 ### Graph
 
-Implemented in `src/util/graph.h` as `grapht` class. The class natively defines
-only a directional graph. However, an undirected graph can be emulated by
+Implemented in `src/util/graph.h` as `grapht` class. The `grapht` class
+represents a directed graph. However, an undirected graph can be emulated by
 inserting for each edge (u, v) also (v, u). A multi-graph is not supported
 though, because parallel edges are not allowed between vertices. 
 
 #### Data representation
 
-A graph is defined by a template class `grapht<N>`, where the type `N` defines
-a node of the graph. The class `grapht` stores the nodes in a vector. A user of
+A graph is defined by a template class `grapht<N>`, where `N` is the type of the
+nodes of the graph. The class `grapht` stores the nodes in a vector. A user of
 the graph is supposed to access the nodes via their indices in the vector. The
 node type `N` must meet these requirements:
 - It must be default constructible; the common way how to insert a node to the
   graph is to call method `add_node` which pushes a new default-constructed
   instance of `N` to the end of the vector and returns its index.
+  Then `operator[]` can be used to obtain a reference to the pushed instance and
+  set its content as desired.
 - It must define a type `edget`, representing type of data attached to any edge
   of the graph; in case edges should not have any data attached, then one can
   use a predefined class `empty_edget`. The type must be default-constructible.
@@ -417,7 +419,8 @@ node type `N` must meet these requirements:
 - It must define a method `pretty` converting the node to a "pretty" string. 
 
 One can use a predefined template class `graph_nodet<E>` as the template
-parameter `N` of the graph.
+parameter `N` of the graph. The template parameter `E` allows to define the type
+`edget`.
 
 #### Graph algorithms