[Boost-commit] svn:boost r43718 - trunk/libs/xpressive/doc

From: eric_at_[hidden]
Date: 2008-03-19 01:18:50

Author: eric_niebler
Date: 2008-03-19 01:18:50 EDT (Wed, 19 Mar 2008)
New Revision: 43718
URL: http://svn.boost.org/trac/boost/changeset/43718

Log:
correct minor doc inaccuracies
Text files modified: 
   trunk/libs/xpressive/doc/actions.qbk        |     5 ++++-                                   
   trunk/libs/xpressive/doc/history.qbk        |     2 +-                                      
   trunk/libs/xpressive/doc/installation.qbk   |     3 +++                                     
   trunk/libs/xpressive/doc/introduction.qbk   |    26 ++++++++++++++------------              
   trunk/libs/xpressive/doc/static_regexes.qbk |     2 +-                                      
   5 files changed, 23 insertions(+), 15 deletions(-)

Modified: trunk/libs/xpressive/doc/actions.qbk
==============================================================================
--- trunk/libs/xpressive/doc/actions.qbk	(original)
+++ trunk/libs/xpressive/doc/actions.qbk	2008-03-19 01:18:50 EDT (Wed, 19 Mar 2008)
@@ -66,6 +66,9 @@
 one and use it to index into the `results` map, and assign to it the result of
 converting sub-match 2 to an integer.
 
+[note To use semantic actions with your static regexes, you must
+`#include <boost/xpressive/regex_actions.hpp>`]
+
 How does this work? Just as the rest of the static regular expression, the part
 between brackets is an expression template. It encodes the action and executes
 it later. The expression `ref(result)` creates a lazy reference to the `result`
@@ -202,7 +205,7 @@
 
     // OK, use as first(s1) to get the begin iterator
     // of the sub-match referred to by s1.    
-    function<first_impl> const first = {{}};
+    function<first_impl>::type const first = {{}};
 
 [h3 Referring to Local Variables]
 

Modified: trunk/libs/xpressive/doc/history.qbk
==============================================================================
--- trunk/libs/xpressive/doc/history.qbk	(original)
+++ trunk/libs/xpressive/doc/history.qbk	2008-03-19 01:18:50 EDT (Wed, 19 Mar 2008)
@@ -7,7 +7,7 @@
 
 [section Appendix 1: History]
 
-[h2 Version 2.0.0, ????]
+[h2 Version 2.0.0, 10/12/2007]
 
 New Features:
 

Modified: trunk/libs/xpressive/doc/installation.qbk
==============================================================================
--- trunk/libs/xpressive/doc/installation.qbk	(original)
+++ trunk/libs/xpressive/doc/installation.qbk	2008-03-19 01:18:50 EDT (Wed, 19 Mar 2008)
@@ -35,6 +35,9 @@
 Likewise, you can include `xpressive_dynamic.hpp` if you only plan on using
 dynamic regexes.
 
+If you would also like to use semantic actions or custom assertions with your
+static regexes, you will need to additionally include `regex_actions.hpp`.
+
 [h2 Requirements]
 
 Xpressive requires Boost version 1.34.1 or higher.

Modified: trunk/libs/xpressive/doc/introduction.qbk
==============================================================================
--- trunk/libs/xpressive/doc/introduction.qbk	(original)
+++ trunk/libs/xpressive/doc/introduction.qbk	2008-03-19 01:18:50 EDT (Wed, 19 Mar 2008)
@@ -9,16 +9,18 @@
 
 [h2 What is xpressive?]
 
-xpressive is an object-oriented regular expression library. Regular expressions
+xpressive is a regular expression template library. Regular expressions
 (regexes) can be written as strings that are parsed dynamically at runtime
-(dynamic regexes), or as expression templates that are parsed at compile-time
-(static regexes). Dynamic regexes have the advantage that they can be accepted
-from the user as input at runtime or read from an initialization file. Static
-regexes have several advantages. Since they are C++ expressions instead of
-strings, they can be syntax-checked at compile-time. Also, they can refer to
-other regexes and to themselves, giving static regexes the power
-of context-free grammars. Finally, since they are statically bound,
-the compiler can generate faster code for static regexes.
+(dynamic regexes), or as ['expression templates][footnote See
+[@http://www.osl.iu.edu/~tveldhui/papers/Expression-Templates/exprtmpl.html
+Expression Templates]] that are parsed at compile-time (static regexes).
+Dynamic regexes have the advantage that they can be accepted from the user
+as input at runtime or read from an initialization file. Static regexes 
+have several advantages. Since they are C++ expressions instead of
+strings, they can be syntax-checked at compile-time. Also, they can naturally
+refer to code and data elsewhere in your program, giving you the ability to call
+back into your code from within a regex match. Finally, since they are statically
+bound, the compiler can generate faster code for static regexes.
 
 xpressive's dual nature is unique and powerful. Static xpressive is a bit
 like the _spirit_fx_. Like _spirit_, you can build grammars with
@@ -28,9 +30,9 @@
 xpressive's interface should be familiar to anyone who has used _regexpp_.
 xpressive's innovation comes from allowing you to mix and match static and
 dynamic regexes in the same program, and even in the same expression! You
-can embed a dynamic regex in a static regex, and the dynamic regex will
-participate fully in the search, back-tracking as needed to make the match
-succeed.
+can embed a dynamic regex in a static regex, or /vice versa/, and the embedded
+regex will participate fully in the search, back-tracking as needed to make
+the match succeed.
 
 [h2 Hello, world!]
 

Modified: trunk/libs/xpressive/doc/static_regexes.qbk
==============================================================================
--- trunk/libs/xpressive/doc/static_regexes.qbk	(original)
+++ trunk/libs/xpressive/doc/static_regexes.qbk	2008-03-19 01:18:50 EDT (Wed, 19 Mar 2008)
@@ -19,7 +19,7 @@
 * are syntax-checked at compile-time; they will never fail at run-time due to
   a syntax error.
 * can naturally refer to other C++ data and code, including other regexes,
-  making it possible to build grammars out of regular expressions and bind
+  making it simple to build grammars out of regular expressions and bind
   user-defined actions that execute when parts of your regex match.
 * are statically bound for better inlining and optimization. Static regexes
   require no state tables, virtual functions, byte-code or calls through