Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 1624)
+++ lemon/bfs.h	(revision 1631)
@@ -699,5 +699,5 @@
     ///if \c v is unreachable from the root(s) or \c v is a root. The
     ///shortest path tree used here is equal to the shortest path tree used in
-    ///\ref predNode(Node v).
+    ///\ref predNode().
     ///\pre Either \ref run() or \ref start() must be called before using
     ///this function.
@@ -714,5 +714,5 @@
     ///if \c v itself a root.
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred(Node v).
+    ///tree used in \ref pred().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
Index: lemon/concept/graph.h
===================================================================
--- lemon/concept/graph.h	(revision 1630)
+++ lemon/concept/graph.h	(revision 1631)
@@ -405,5 +405,5 @@
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const StaticGraph&) { }
+        EdgeIt(const StaticGraph& g) { }
         /// Edge -> EdgeIt conversion
 
Index: lemon/concept/graph_component.h
===================================================================
--- lemon/concept/graph_component.h	(revision 1627)
+++ lemon/concept/graph_component.h	(revision 1631)
@@ -764,5 +764,5 @@
 
     /// This class describes the common interface of the graph maps
-    /// (NodeMap, EdgeMap), that is \ref maps-pages "maps" which can be used to
+    /// (NodeMap, EdgeMap), that is \ref maps-page "maps" which can be used to
     /// associate data to graph descriptors (nodes or edges).
     template <typename Graph, typename Item, typename _Value>
Index: lemon/concept/undir_graph.h
===================================================================
--- lemon/concept/undir_graph.h	(revision 1630)
+++ lemon/concept/undir_graph.h	(revision 1631)
@@ -233,5 +233,5 @@
     ///
     /// In LEMON undirected graphs also fulfill the concept of directed
-    /// graphs (\ref lemon::concept::Graph "Graph Concept"). For
+    /// graphs (\ref lemon::concept::StaticGraph "Graph Concept"). For
     /// explanation of this and more see also the page \ref undir_graphs,
     /// a tutorial about undirected graphs.
@@ -558,5 +558,5 @@
         /// This constructor sets the iterator to the first edge of \c g.
         ///@param g the graph
-        EdgeIt(const UndirGraph&) { }
+        EdgeIt(const UndirGraph &g) { }
         /// Edge -> EdgeIt conversion
 
@@ -606,5 +606,5 @@
         ///@param n the node
         ///@param g the graph
-        OutEdgeIt(const UndirGraph&, const Node&) { }
+        OutEdgeIt(const UndirGraph& n, const Node& g) { }
         /// Edge -> OutEdgeIt conversion
 
@@ -655,5 +655,5 @@
         ///@param n the node
         ///@param g the graph
-        InEdgeIt(const UndirGraph&, const Node&) { }
+        InEdgeIt(const UndirGraph& g, const Node& n) { }
         /// Edge -> InEdgeIt conversion
 
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1540)
+++ lemon/dfs.h	(revision 1631)
@@ -709,5 +709,5 @@
     ///if \c v is unreachable from the root(s) or \c v is a root. The
     ///%DFS tree used here is equal to the %DFS tree used in
-    ///\ref predNode(Node v).
+    ///\ref predNode().
     ///\pre Either \ref run() or \ref start() must be called before using
     ///this function.
@@ -724,5 +724,5 @@
     ///if \c v itself a root.
     ///The %DFS tree used here is equal to the %DFS
-    ///tree used in \ref pred(Node v).
+    ///tree used in \ref pred().
     ///\pre Either \ref run() or \ref start() must be called before
     ///using this function.
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 1536)
+++ lemon/dijkstra.h	(revision 1631)
@@ -703,5 +703,5 @@
     ///if \c v is unreachable from the root or if \c v=s. The
     ///shortest path tree used here is equal to the shortest path tree used in
-    ///\ref predNode(Node v).  \pre \ref run() must be called before using
+    ///\ref predNode().  \pre \ref run() must be called before using
     ///this function.
     ///\todo predEdge could be a better name.
@@ -714,5 +714,5 @@
     ///root to \c /v. It is INVALID if \c v is unreachable from the root or if
     ///\c v=s. The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref pred(Node v).  \pre \ref run() must be called before
+    ///tree used in \ref pred().  \pre \ref run() must be called before
     ///using this function.
     Node predNode(Node v) const { return (*_pred)[v]==INVALID ? INVALID:
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 1627)
+++ lemon/graph_adaptor.h	(revision 1631)
@@ -1421,9 +1421,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref skeleton::StaticGraph
+  /// this class. Its interface must conform to the \ref concept::StaticGraph
   /// "StaticGraph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
   template <typename _Graph>
   class NewEdgeSetAdaptor :
@@ -1513,9 +1513,9 @@
   ///
   /// \param _Graph The type of the graph which shares its node set with 
-  /// this class. Its interface must conform to the \ref skeleton::StaticGraph
+  /// this class. Its interface must conform to the \ref concept::StaticGraph
   /// "StaticGraph" concept.
   ///
   /// In the edge extension and removing it conforms to the 
-  /// \ref skeleton::ExtendableGraph "ExtendableGraph" concept.
+  /// \ref concept::ExtendableGraph "ExtendableGraph" concept.
   template <typename _Graph>
   class NewUndirEdgeSetAdaptor :
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 1603)
+++ lemon/kruskal.h	(revision 1631)
@@ -52,5 +52,5 @@
   /// \param g The graph the algorithm runs on.
   /// It can be either \ref concept::StaticGraph "directed" or 
-  /// \ref concept::UndirStaticGraph "undirected".
+  /// \ref concept::UndirGraph "undirected".
   /// If the graph is directed, the algorithm consider it to be 
   /// undirected by disregarding the direction of the edges.
@@ -89,5 +89,6 @@
   /// \return The cost of the found tree.
   ///
-  /// \warning If kruskal is run on an \ref undirected graph, be sure that the
+  /// \warning If kruskal is run on an
+  /// \ref lemon::concept::UndirGraph "undirected graph", be sure that the
   /// map storing the tree is also undirected
   /// (e.g. UndirListGraph::UndirEdgeMap<bool>, otherwise the values of the
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 1435)
+++ lemon/preflow.h	(revision 1631)
@@ -284,6 +284,7 @@
 
     ///The preflow algorithm consists of two phases, this method runs
-    ///the second phase. After calling \ref phase1 and then \ref
-    ///phase2, \ref flow contains a maximum flow, \ref flowValue
+    ///the second phase. After calling \ref phase1() and then
+    ///\ref phase2(),
+    /// \ref flowMap() return a maximum flow, \ref flowValue
     ///returns the value of a maximum flow, \ref minCut returns a
     ///minimum cut, while the methods \ref minMinCut and \ref
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 1537)
+++ lemon/smart_graph.h	(revision 1631)
@@ -90,10 +90,10 @@
     /// Maximum node ID.
     ///\sa id(Node)
-    int maxId(Node = INVALID) const { return nodes.size()-1; }
+    int maxId(Node) const { return nodes.size()-1; }
     /// Maximum edge ID.
     
     /// Maximum edge ID.
     ///\sa id(Edge)
-    int maxId(Edge = INVALID) const { return edges.size()-1; }
+    int maxId(Edge) const { return edges.size()-1; }
 
     Node source(Edge e) const { return edges[e.n].source; }
@@ -103,6 +103,6 @@
     
     /// The ID of a valid Node is a nonnegative integer not greater than
-    /// \ref maxNodeId(). The range of the ID's is not surely continuous
-    /// and the greatest node ID can be actually less then \ref maxNodeId().
+    /// \ref maxId(Node). The range of the ID's is not surely continuous
+    /// and the greatest node ID can be actually less then \ref maxId(Node).
     ///
     /// The ID of the \ref INVALID node is -1.
@@ -112,6 +112,6 @@
     
     /// The ID of a valid Edge is a nonnegative integer not greater than
-    /// \ref maxEdgeId(). The range of the ID's is not surely continuous
-    /// and the greatest edge ID can be actually less then \ref maxEdgeId().
+    /// \ref maxId(Edge). The range of the ID's is not surely continuous
+    /// and the greatest edge ID can be actually less then \ref maxId(Edge).
     ///
     /// The ID of the \ref INVALID edge is -1.
