Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 1516)
+++ lemon/bfs.h	(revision 1536)
@@ -85,7 +85,11 @@
  
     ///This function instantiates a \ref ProcessedMap. 
-    ///\param G is the graph, to which
+    ///\param g is the graph, to which
     ///we would like to define the \ref ProcessedMap
+#ifdef DOXYGEN
+    static ProcessedMap *createProcessedMap(const GR &g)
+#else
     static ProcessedMap *createProcessedMap(const GR &)
+#endif
     {
       return new ProcessedMap();
@@ -660,5 +664,5 @@
     
     ///This function copies the shortest path to \c t into \c p.
-    ///If it \c \t is a source itself or unreachable, then it does not
+    ///If \c t is a source itself or unreachable, then it does not
     ///alter \c p.
     ///\todo Is it the right way to handle unreachable nodes?
@@ -771,7 +775,11 @@
  
     ///This function instantiates a \ref PredMap. 
-    ///\param G is the graph, to which we would like to define the PredMap.
+    ///\param g is the graph, to which we would like to define the PredMap.
     ///\todo The graph alone may be insufficient to initialize
+#ifdef DOXYGEN
+    static PredMap *createPredMap(const GR &g) 
+#else
     static PredMap *createPredMap(const GR &) 
+#endif
     {
       return new PredMap();
@@ -804,7 +812,11 @@
  
     ///This function instantiates a \ref ProcessedMap. 
-    ///\param G is the graph, to which
+    ///\param g is the graph, to which
     ///we would like to define the \ref ProcessedMap
+#ifdef DOXYGEN
+    static ProcessedMap *createProcessedMap(const GR &g)
+#else
     static ProcessedMap *createProcessedMap(const GR &)
+#endif
     {
       return new ProcessedMap();
@@ -834,6 +846,10 @@
  
     ///This function instantiates a \ref DistMap. 
-    ///\param G is the graph, to which we would like to define the \ref DistMap
+    ///\param g is the graph, to which we would like to define the \ref DistMap
+#ifdef DOXYGEN
+    static DistMap *createDistMap(const GR &g)
+#else
     static DistMap *createDistMap(const GR &)
+#endif
     {
       return new DistMap();
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1529)
+++ lemon/dfs.h	(revision 1536)
@@ -85,7 +85,11 @@
  
     ///This function instantiates a \ref ProcessedMap. 
-    ///\param G is the graph, to which
+    ///\param g is the graph, to which
     ///we would like to define the \ref ProcessedMap
+#ifdef DOXYGEN
+    static ProcessedMap *createProcessedMap(const GR &g)
+#else
     static ProcessedMap *createProcessedMap(const GR &)
+#endif
     {
       return new ProcessedMap();
@@ -780,7 +784,11 @@
  
     ///This function instantiates a \ref PredMap. 
-    ///\param G is the graph, to which we would like to define the PredMap.
+    ///\param g is the graph, to which we would like to define the PredMap.
     ///\todo The graph alone may be insufficient to initialize
+#ifdef DOXYGEN
+    static PredMap *createPredMap(const GR &g) 
+#else
     static PredMap *createPredMap(const GR &) 
+#endif
     {
       return new PredMap();
@@ -813,7 +821,11 @@
  
     ///This function instantiates a \ref ProcessedMap. 
-    ///\param G is the graph, to which
+    ///\param g is the graph, to which
     ///we would like to define the \ref ProcessedMap
+#ifdef DOXYGEN
+    static ProcessedMap *createProcessedMap(const GR &g)
+#else
     static ProcessedMap *createProcessedMap(const GR &)
+#endif
     {
       return new ProcessedMap();
@@ -843,6 +855,10 @@
  
     ///This function instantiates a \ref DistMap. 
-    ///\param G is the graph, to which we would like to define the \ref DistMap
+    ///\param g is the graph, to which we would like to define the \ref DistMap
+#ifdef DOXYGEN
+    static DistMap *createDistMap(const GR &g)
+#else
     static DistMap *createDistMap(const GR &)
+#endif
     {
       return new DistMap();
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 1516)
+++ lemon/dijkstra.h	(revision 1536)
@@ -109,7 +109,11 @@
  
     ///This function instantiates a \ref ProcessedMap. 
-    ///\param G is the graph, to which
+    ///\param g is the graph, to which
     ///we would like to define the \ref ProcessedMap
+#ifdef DOXYGEN
+    static ProcessedMap *createProcessedMap(const GR &g)
+#else
     static ProcessedMap *createProcessedMap(const GR &)
+#endif
     {
       return new ProcessedMap();
@@ -664,5 +668,5 @@
     
     ///This function copies the shortest path to \c t into \c p.
-    ///If it \c \t is a source itself or unreachable, then it does not
+    ///If it \c t is a source itself or unreachable, then it does not
     ///alter \c p.
     ///\todo Is it the right way to handle unreachable nodes?
@@ -789,7 +793,11 @@
  
     ///This function instantiates a \ref PredMap. 
-    ///\param G is the graph, to which we would like to define the PredMap.
+    ///\param g is the graph, to which we would like to define the PredMap.
     ///\todo The graph alone may be insufficient for the initialization
+#ifdef DOXYGEN
+    static PredMap *createPredMap(const GR &g) 
+#else
     static PredMap *createPredMap(const GR &) 
+#endif
     {
       return new PredMap();
@@ -807,7 +815,11 @@
  
     ///This function instantiates a \ref ProcessedMap. 
-    ///\param G is the graph, to which
+    ///\param g is the graph, to which
     ///we would like to define the \ref ProcessedMap
+#ifdef DOXYGEN
+    static ProcessedMap *createProcessedMap(const GR &g)
+#else
     static ProcessedMap *createProcessedMap(const GR &)
+#endif
     {
       return new ProcessedMap();
@@ -822,6 +834,10 @@
  
     ///This function instantiates a \ref DistMap. 
-    ///\param G is the graph, to which we would like to define the \ref DistMap
+    ///\param g is the graph, to which we would like to define the \ref DistMap
+#ifdef DOXYGEN
+    static DistMap *createDistMap(const GR &g)
+#else
     static DistMap *createDistMap(const GR &)
+#endif
     {
       return new DistMap();
Index: lemon/error.h
===================================================================
--- lemon/error.h	(revision 1435)
+++ lemon/error.h	(revision 1536)
@@ -101,5 +101,7 @@
   protected:
     ///\e 
-    ///\todo The good solution is boost:shared_ptr...
+
+    ///\todo The good solution is boost::shared_ptr...
+    ///
     mutable
     std::auto_ptr<std::ostringstream> buf;
Index: lemon/graph_adaptor.h
===================================================================
--- lemon/graph_adaptor.h	(revision 1472)
+++ lemon/graph_adaptor.h	(revision 1536)
@@ -452,5 +452,5 @@
   of edge-disjoint paths between \c s and \c t in the graph which has edge-set 
   all the tight edges. The computation will be demonstrated on the following 
-  graph, which is read from the dimacs file \ref sub_graph_adaptor_demo.dim. 
+  graph, which is read from the dimacs file \c sub_graph_adaptor_demo.dim. 
   The full source code is available in \ref sub_graph_adaptor_demo.cc. 
   If you are interested in more demo programs, you can use 
Index: lemon/graph_utils.h
===================================================================
--- lemon/graph_utils.h	(revision 1531)
+++ lemon/graph_utils.h	(revision 1536)
@@ -178,5 +178,5 @@
   /// }
   /// \endcode
-  /// \todo We may want to use the \ref concept::GraphBase "GraphBase"
+  /// \todo We may want to use the "GraphBase"
   /// interface here...
   /// \bug Untested ...
@@ -860,8 +860,8 @@
     ///
     /// The subscript operator.
-    /// \param edge The edge 
+    /// \param e The edge 
     /// \return The target of the edge 
-    Value operator[](const Key& key) {
-      return graph.target(key);
+    Value operator[](const Key& e) {
+      return graph.target(e);
     }
 
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 1508)
+++ lemon/lp_base.h	(revision 1536)
@@ -400,6 +400,6 @@
 
       ///\return
-      ///- -\ref INF: the constraint is lower unbounded.
-      ///- -\ref NaN: lower bound has not been set.
+      ///- \ref INF "INF": the constraint is lower unbounded.
+      ///- \ref NaN "NaN": lower bound has not been set.
       ///- finite number: the lower bound
       Value &lowerBound() { return _lb; }
@@ -409,6 +409,6 @@
 
       ///\return
-      ///- -\ref INF: the constraint is upper unbounded.
-      ///- -\ref NaN: upper bound has not been set.
+      ///- \ref INF "INF": the constraint is upper unbounded.
+      ///- \ref NaN "NaN": upper bound has not been set.
       ///- finite number: the upper bound
       Value &upperBound() { return _ub; }
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 1531)
+++ lemon/maps.h	(revision 1536)
@@ -228,13 +228,4 @@
   ///Its \c Value is inherited from \c M.
   ///
-  ///Actually,
-  ///\code
-  ///  ConvertMap<X> sh(x,v);
-  ///\endcode
-  ///it is equivalent with
-  ///\code
-  ///  ConstMap<X::Key, X::Value> c_tmp(v);
-  ///  AddMap<X, ConstMap<X::Key, X::Value> > sh(x,v);
-  ///\endcode
   ///\bug wrong documentation
   template<class M, class T> 
@@ -253,6 +244,5 @@
 
     ///Constructor
-    ///\param _m is the undelying map
-    ///\param _v is the convert value
+    ///\param _m is the underlying map
     ConvertMap(const M &_m) : m(_m) {};
 
@@ -260,5 +250,5 @@
     ///
     /// The subscript operator.
-    /// \param edge The edge 
+    /// \param k The key
     /// \return The target of the edge 
     Value operator[](Key k) const {return m[k];}
@@ -298,7 +288,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     AddMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     Value operator[](Key k) const {return m1[k]+m2[k];}
@@ -387,7 +374,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     SubMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     Value operator[](Key k) const {return m1[k]-m2[k];}
@@ -427,7 +411,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     MulMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     Value operator[](Key k) const {return m1[k]*m2[k];}
@@ -513,7 +494,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     DivMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     Value operator[](Key k) const {return m1[k]/m2[k];}
@@ -561,7 +539,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     ComposeMap(const M1 &_m1,const M2 &_m2) : m1(_m1), m2(_m2) {};
     Value operator[](Key k) const {return m1[m2[k]];}
@@ -616,7 +591,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     CombineMap(const M1 &_m1,const M2 &_m2,const F &_f)
       : m1(_m1), m2(_m2), f(_f) {};
@@ -667,7 +639,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     NegMap(const M &_m) : m(_m) {};
     Value operator[](Key k) const {return -m[k];}
@@ -721,7 +690,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     AbsMap(const M &_m) : m(_m) {};
     Value operator[](Key k) const {Value tmp=m[k]; return tmp>=0?tmp:-tmp;}
@@ -764,7 +730,4 @@
 
     ///Constructor
-
-    ///\e
-    ///
     FunctorMap(const F &_f) : f(_f) {};
     Value operator[](Key k) const {return f(k);}
