* In libs/wave/doc/class_reference_contextpolicy.html:
  
  * Under heading, "Introduction":
  
    The word, "provides" is misspelled as "proviedes".

  * Under heading, "expanding_function_like_macro":
  
    * There are several sentences with commas before words like
      "whenever" and "where" and "which".  I don't think these are
      needed.  For example:
    
        The function expanding_function_like_macro is called, whenever a
        function-like macro is to be expanded
      
      should be:

        The function expanding_function_like_macro is called whenever a
        function-like macro is to be expanded
      
    * In paragraph for "macrocall":
    
      The phrase:
      
        position, where this macro invoked.
        
      should be:
      
        position where this macro is invoked.
        
      Also, maybe:
      
        It contains the token, which identifies the macro call
        
      could be shortened to:
      
        It contains the token of the macro call
      
  * Under heading, "interpret_pragma":
  
    "instantiation" is mispelled as "instatiation".

* In libs/wave/doc/class_reference_lexer.html:

  * Under heading, "Introduction":
  
    The phrase:
    
      The lexer type should expose an interface, which conforms at
      least to a forward_iterator 
      
    seems inconsistent with the code which follows because there's no
    deref or increment operators defined in the code following the
    heading, "Wave lexer synopsis".  OOPS, I see there's a comment in
    the code saying the interface is "not shown here".  I missed this
    at first and it would help if this comment were tacked onto the
    end of the above phrase also to make sure the reader saw it.
    
    Also, "forward_iterator for Token Type" would make explicit that
    the tokens are returned by the operator*.  This may seen redundant
    due to the earlier sentence:
    
      Every lexer ... has to return tokens formed from the input
      stream.
      
    but this more specific description leaves no doubt.
    
    
  * Under heading, "Wave lexer synopsis":
  
    lex_iterator in this synopsis is not a templete; yet, the only
    .hpp file containing lex_iterator is in boost /wave /cpplexer
    /cpp_lex_iterator.hpp where it is a template taking a single
    parameter, TokenT.  Also, in that file token_type is typedef'ed to
    TokenT, which is unlike the synopsis.
    
  * Under heading, "Public Typedefs"
  
    * In the table, in column 2:
    
      the phrase:
      
        This is type is used
        
      should be:
      
        This type is used
        


* In libs/wave/doc/class_reference_tokentype.html:

  * Under heading, "Introduction":
  
    The sentences:
    
      The token type in Wave is the main carrier of information. It is
      returned by dereferencing the main iterator. 
      
    makes me wonder what the "main iterator" is.  I'm guessing this
    means the lex_iterator since it's documentation says it "returns
    tokens", but it's clearer if the term, "lex_iterator" were used
    instead of "main iterator".
    
    OOPS.  Further reading in class_reference_lexer.html shows:
    
      This is type is used as the return value of the main iterators
      
    which means "main iterator" is not lex_iterator.