Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r50369 - in trunk/libs/spirit/doc: . html html/spirit html/spirit/lex html/spirit/lex/abstracts html/spirit/lex/reference html/spirit/lex/tutorials html/spirit/notes html/spirit/qi_and_karma html/spirit/qi_and_karma/abstracts
From: joel_at_[hidden]
Date: 2008-12-23 04:39:12

Author: djowel
Date: 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
New Revision: 50369
URL: http://svn.boost.org/trac/boost/changeset/50369

Log:
doc updates
Text files modified:
   trunk/libs/spirit/doc/concepts_template.qbk | 92 ++++----
   trunk/libs/spirit/doc/html/index.html | 25 +-
   trunk/libs/spirit/doc/html/spirit/acknowledgments.html | 2
   trunk/libs/spirit/doc/html/spirit/introduction.html | 133 ++++++-------
   trunk/libs/spirit/doc/html/spirit/lex.html | 58 +++---
   trunk/libs/spirit/doc/html/spirit/lex/abstracts.html | 20 -
   trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_states.html | 6
   trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_static_model.html | 22 -
   trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_tokenizing.html | 4
   trunk/libs/spirit/doc/html/spirit/lex/reference/lexer_class.html | 8
   trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart1.html | 28 +-
   trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart2.html | 27 +-
   trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart3.html | 25 +-
   trunk/libs/spirit/doc/html/spirit/notes/style_guide.html | 12
   trunk/libs/spirit/doc/html/spirit/qi_and_karma.html | 373 ++++++++++++++-------------------------
   trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/mini_xml___error_handling.html | 30 +--
   trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing.html | 10
   trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing_and_generating.html | 10
   trunk/libs/spirit/doc/html/spirit/qi_and_karma/quick_reference.html | 2
   trunk/libs/spirit/doc/html/spirit/qi_and_karma/reference.html | 10
   trunk/libs/spirit/doc/html/spirit/what_s_new.html | 8
   trunk/libs/spirit/doc/introduction.qbk | 68 +++---
   trunk/libs/spirit/doc/reference_template.qbk | 112 ++++++------
   23 files changed, 466 insertions(+), 619 deletions(-)

Modified: trunk/libs/spirit/doc/concepts_template.qbk
==============================================================================
--- trunk/libs/spirit/doc/concepts_template.qbk (original)
+++ trunk/libs/spirit/doc/concepts_template.qbk 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -1,46 +1,46 @@
-[/==============================================================================
- Copyright (C) 2001-2008 Joel de Guzman
- Copyright (C) 2001-2008 Hartmut Kaiser
-
- Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-===============================================================================/]
-
-[section XXX]
-
-[heading Description]
-
-Description of XXX concept
-
-[variablelist Notation
- [[`xxx`] [An XXX]]
-]
-
-[heading Valid Expressions]
-
-(For any Forward Sequence the following expressions must be valid:)
-
-In addition to the requirements defined in _XXX-Basic_concept_, for any
-XXX the following must be met:
-
-[table
- [[Expression] [Semantics] [Return type] [Complexity]]
- [[`xxx`] [Semantics of `xxx`] [XXX] [Constant]]
-]
-
-[heading Type Requirements]
-
-[table
- [[Expression] [Requirements]]
- [[`xxx`] [Requirements for `xxx`]]
-]
-
-[heading Invariants]
-
-For any XXX xxx the following invariants always hold:
-
-[heading Models]
-
-Links to models of XXX concept
-
-[endsect]
+[/==============================================================================
+ Copyright (C) 2001-2008 Joel de Guzman
+ Copyright (C) 2001-2008 Hartmut Kaiser
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+===============================================================================/]
+
+[section XXX]
+
+[heading Description]
+
+Description of XXX concept
+
+[variablelist Notation
+ [[`xxx`] [An XXX]]
+]
+
+[heading Valid Expressions]
+
+(For any Forward Sequence the following expressions must be valid:)
+
+In addition to the requirements defined in _XXX-Basic_concept_, for any
+XXX the following must be met:
+
+[table
+ [[Expression] [Semantics] [Return type] [Complexity]]
+ [[`xxx`] [Semantics of `xxx`] [XXX] [Constant]]
+]
+
+[heading Type Requirements]
+
+[table
+ [[Expression] [Requirements]]
+ [[`xxx`] [Requirements for `xxx`]]
+]
+
+[heading Invariants]
+
+For any XXX xxx the following invariants always hold:
+
+[heading Models]
+
+Links to models of XXX concept
+
+[endsect]

Modified: trunk/libs/spirit/doc/html/index.html
==============================================================================
--- trunk/libs/spirit/doc/html/index.html (original)
+++ trunk/libs/spirit/doc/html/index.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -34,7 +34,7 @@
<div>Copyright © 2001-2008 Joel de Guzman,
 Hartmut Kaiser</div>
<div><div class="legalnotice">
-<a name="id616212"></a>
+<a name="id386666"></a>
 Distributed under the Boost Software License, Version 1.0. (See accompanying
 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -184,11 +184,11 @@
 
</blockquote></div>
<a name="spirit.preface.history"></a><h3>
-<a name="id616266"></a>
+<a name="id388764"></a>
 <a href="index.html#spirit.preface.history">History</a>
 </h3>
<a name="spirit.preface._emphasis_80s__emphasis_"></a><h3>
-<a name="id616279"></a>
+<a name="id386336"></a>
 <a href="index.html#spirit.preface._emphasis_80s__emphasis_">80s</a>
 </h3>

@@ -202,7 +202,7 @@
 recursive-descent parser. This worked very well.
 
<a name="spirit.preface._emphasis_90s__emphasis_"></a><h3>
-<a name="id616297"></a>
+<a name="id386375"></a>
 <a href="index.html#spirit.preface._emphasis_90s__emphasis_">90s</a>
 </h3>

@@ -238,8 +238,7 @@
 version was implemented with run-time polymorphic classes. A parser is generated
 at run time by feeding in production rule strings such as:
 
-<pre class="programlisting">
-"prod ::= {'A' | 'B'} 'C';"
+<pre class="programlisting">"prod ::= {'A' | 'B'} 'C';"
</pre>

 A compile function compiled the parser, dynamically creating a hierarchy of
@@ -247,7 +246,7 @@
 here: pre-Spirit.
 
<a name="spirit.preface._emphasis_2001_to_2006__emphasis_"></a><h3>
-<a name="id616340"></a>
+<a name="id388110"></a>
 <a href="index.html#spirit.preface._emphasis_2001_to_2006__emphasis_">2001
 to 2006</a>
 </h3>
@@ -277,7 +276,7 @@
 for design and implementation quality, robustness, and reusability.
 
<a name="spirit.preface._emphasis_2007__emphasis_"></a><h3>
-<a name="id616375"></a>
+<a name="id387263"></a>
 <a href="index.html#spirit.preface._emphasis_2007__emphasis_">2007</a>
 </h3>

@@ -307,7 +306,7 @@
 Templates</a> library called -Boost.Proto-.
 
<a name="spirit.preface.new_ideas__spirit_v2"></a><h3>
-<a name="id616441"></a>
+<a name="id387382"></a>
 <a href="index.html#spirit.preface.new_ideas__spirit_v2">New Ideas: Spirit V2</a>
 </h3>

@@ -345,7 +344,7 @@
 same underlying component library as for the parser and generator libraries.
 
<a name="spirit.preface.how_to_use_this_manual"></a><h3>
-<a name="id616491"></a>
+<a name="id387485"></a>
 <a href="index.html#spirit.preface.how_to_use_this_manual">How to use this manual</a>
 </h3>

@@ -376,7 +375,7 @@
 icons precede some text to indicate:
 
<div class="table">
-<a name="id616539"></a>Table 1. Icons
+<a name="id387571"></a>Table 1. Icons
<table class="table" summary="Icons">
<colgroup>
<col>
@@ -497,7 +496,7 @@
 Tools</a>.
 
<a name="spirit.preface.support"></a><h3>
-<a name="id616780"></a>
+<a name="id386631"></a>
 <a href="index.html#spirit.preface.support">Support</a>
 </h3>

@@ -513,7 +512,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left">Last revised: July 16, 2008 at 03:04:03 GMT</td>
+<td align="left">Last revised: December 23, 2008 at 09:37:55 GMT</td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>

Modified: trunk/libs/spirit/doc/html/spirit/acknowledgments.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/acknowledgments.html (original)
+++ trunk/libs/spirit/doc/html/spirit/acknowledgments.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -46,7 +46,7 @@
 FIXME: Add more people
 
<a name="spirit.acknowledgments.acknowledgements_from_the_spirit_v1__emphasis_classic__emphasis__documentation"></a><h3>
-<a name="id665442"></a>
+<a name="id506650"></a>
 <a href="acknowledgments.html#spirit.acknowledgments.acknowledgements_from_the_spirit_v1__emphasis_classic__emphasis__documentation">Acknowledgements
 from the Spirit V1 classic Documentation</a>
 </h3>

Modified: trunk/libs/spirit/doc/html/spirit/introduction.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/introduction.html (original)
+++ trunk/libs/spirit/doc/html/spirit/introduction.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -26,18 +26,18 @@
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="spirit.introduction"></a>Introduction</h2></div></div></div>

- Boost Spirit is an object oriented, recursive-descent parser and output generation
- library for C++. It allows to write grammars and format descriptions using
- a format very similar to EBNF (Extended Backus Naur Form, see [4]) directly
- in C++. These inline grammar specifications can mix freely with other C++ code
- and, thanks to the generative power of C++ templates, are immediately executable.
+ Boost Spirit is an object-oriented, recursive-descent parser and output generation
+ library for C++. It allows you to write grammars and format descriptions using
+ a format similar to EBNF (Extended Backus Naur Form, see [4]) directly in C++.
+ These inline grammar specifications can mix freely with other C++ code and,
+ thanks to the generative power of C++ templates, are immediately executable.
 In retrospect, conventional compiler-compilers or parser-generators have to
 perform an additional translation step from the source EBNF code to C or C++
 code.
 

- The syntax and semantics of the libraries API directly form domain specific
- embedded languages (DSEL). In fact, Spirit exposes 3 different DSEL's to the
+ The syntax and semantics of the libraries' API directly form domain-specific
+ embedded languages (DSEL). In fact, Spirit exposes 3 different DSELs to the
 user:
 
<div class="itemizedlist"><ul type="disc">
@@ -53,43 +53,43 @@
</ul></div>

 Since the target input grammars and output formats are written entirely in
- C++ we do not need any separate tools to compile, preprocess, or integrate
- those into the build process. Spirit
+ C++ we do not need any separate tools to compile, preprocess or integrate those
+ into the build process. Spirit
 allows seamless integration of the parsing and output generation process with
 other C++ code. Often this allows for simpler and more efficient code.
 

- Both, the created parsers and generators, are fully attributed which allows
+ Both the created parsers and generators are fully attributed which allows you
 to easily build and handle hierarchical data structures in memory. These data
 structures resemble the structure of the input data and can directly be used
- to generate arbitrarily formatted output.
+ to generate arbitrarily-formatted output.
 

 The figure below depicts the
- overall structure of the Boost Spirit library. The library consists out of
- 4 major parts:
+ overall structure of the Boost Spirit library. The library consists of 4 major
+ parts:
 
<div class="itemizedlist"><ul type="disc">
<li>
-Spirit.Classic: This is the almost unchanged code base
+Spirit.Classic: This is the almost-unchanged code base
 taken from the former Boost Spirit V1.8 distribution. It has been moved into
 the namespace boost::spirit::classic. A special compatibility layer has been
 added to ensure complete compatibility with existing code using Spirit V1.8.
 </li>
<li>
-Spirit.Qi: This is the parser library allowing to build
- recursive descent parsers. The exposed domain specific language can be used
- to describe the grammars to implement, and the rules for storing the parsed
- information.
+Spirit.Qi: This is the parser library allowing you to
+ build recursive descent parsers. The exposed domain-specific language can
+ be used to describe the grammars to implement, and the rules for storing
+ the parsed information.
 </li>
<li>
-Spirit.Lex: This is the library usable to create tokinizers
- (lexers). The domain specific language exposed by Spirit.Lex
+Spirit.Lex: This is the library usable to create tokenizers
+ (lexers). The domain-specific language exposed by Spirit.Lex
</li>
<li>
Spirit.Karma: This is the generator library allowing
- to create code for recursive descent, data type driven output formatting.
- The exposed domain specific language is almost equivalent to the parser description
+ you to create code for recursive descent, data type-driven output formatting.
+ The exposed domain-specific language is almost equivalent to the parser description
 language used in Spirit.Qi, except that it is used to
 describe the required output format to generate from a given data structure.
 </li>
@@ -117,9 +117,9 @@
 The <a href="introduction.html#spirit.spiritkarmaflow" title="Figure 2. The place of Spirit.Qi and Spirit.Karma
 in a data transformation flow of a typical application">figure</a> below shows the typical
 data flow of some input being converted to some internal representation. After
- some (optional) transformation this data is converted back into some different,
- external representation. The picture highlights Spirit's the place in this
- data transformation flow.
+ some (optional) transformation these data are converted back into some different,
+ external representation. The picture highlights Spirit's place in this data
+ transformation flow.
 

 
@@ -132,10 +132,10 @@
</div>

 
-<a name="spirit.introduction.a_quick_overview_about_parsing_with__emphasis_spirit_qi__emphasis_"></a><h3>
-<a name="id617238"></a>
- <a href="introduction.html#spirit.introduction.a_quick_overview_about_parsing_with__emphasis_spirit_qi__emphasis_">A
- quick overview about Parsing with Spirit.Qi</a>
+<a name="spirit.introduction.a_quick_overview_of_parsing_with__emphasis_spirit_qi__emphasis_"></a><h3>
+<a name="id457695"></a>
+ <a href="introduction.html#spirit.introduction.a_quick_overview_of_parsing_with__emphasis_spirit_qi__emphasis_">A
+ Quick Overview of Parsing with Spirit.Qi</a>
 </h3>

 Spirit.Qi is Spirit's sublibrary dealing with generating
@@ -145,8 +145,7 @@

 A simple EBNF grammar snippet:
 
-<pre class="programlisting">
-group ::= '(' expression ')'
+<pre class="programlisting">group ::= '(' expression ')'
factor ::= integer | group
term ::= factor (('*' factor) | ('/' factor))*
expression ::= term (('+' term) | ('-' term))*
@@ -155,8 +154,7 @@
 is approximated using facilities of Spirit's Qi sublibrary
 as seen in this code snippet:
 
-<pre class="programlisting">
-group = '(' >> expression >> ')';
+<pre class="programlisting">group = '(' >> expression >> ')';
factor = integer | group;
term = factor >> *(('*' >> factor) | ('/' >> factor));
expression = term >> *(('+' >> term) | ('-' >> term));
@@ -164,15 +162,16 @@

 Through the magic of expression templates, this is perfectly valid and executable
 C++ code. The production rule <tt class="computeroutput">expression</tt>
- is in fact an object that has a member function parse that does the work given
- a source code written in the grammar that we have just declared. Yes, it's
- a calculator. We shall simplify for now by skipping the type declarations and
- the definition of the rule integer invoked by factor. Now, the production rule
- <tt class="computeroutput">expression</tt> in our grammar specification,
- traditionally called the start symbol, can recognize inputs such as:
+ is, in fact, an object that has a member function <tt class="computeroutput">parse</tt>
+ that does the work given a source code written in the grammar that we have
+ just declared. Yes, it's a calculator. We shall simplify for now by skipping
+ the type declarations and the definition of the rule <tt class="computeroutput">integer</tt>
+ invoked by <tt class="computeroutput">factor</tt>. Now, the
+ production rule <tt class="computeroutput">expression</tt>
+ in our grammar specification, traditionally called the <tt class="computeroutput">start</tt>
+ symbol, can recognize inputs such as:
 
-<pre class="programlisting">
-12345
+<pre class="programlisting">12345
-12345
+12345
1 + 2
@@ -191,8 +190,7 @@
 shift >> operators. Since there are no 'empty' operators in C++, it is
 simply not possible to write something like:
 
-<pre class="programlisting">
-a b
+<pre class="programlisting">a b
</pre>

 as seen in math syntax, for example, to mean multiplication or, in our case,
@@ -202,8 +200,7 @@
 operator, with arrows pointing to the right, to mean "is followed by".
 Thus we write:
 
-<pre class="programlisting">
-a >> b
+<pre class="programlisting">a >> b
</pre>

 The alternative operator <tt class="computeroutput">|</tt> and
@@ -213,37 +210,34 @@
 not least, the Kleene star <tt class="computeroutput">*</tt> which
 used to be a postfix operator in EBNF becomes a prefix. Instead of:
 
-<pre class="programlisting">
-a* //... in EBNF syntax,
+<pre class="programlisting">a* //... in EBNF syntax,
</pre>

 we write:
 
-<pre class="programlisting">
-*a //... in Spirit.
+<pre class="programlisting">*a //... in Spirit.
</pre>

 since there are no postfix stars, <tt class="computeroutput">*</tt>,
 in C/C++. Finally, we terminate each rule with the ubiquitous semi-colon,
 <tt class="computeroutput">;</tt>.
 
-<a name="spirit.introduction.a_quick_overview_about_output_generation_with__emphasis_spirit_karma__emphasis_"></a><h3>
-<a name="id620086"></a>
- <a href="introduction.html#spirit.introduction.a_quick_overview_about_output_generation_with__emphasis_spirit_karma__emphasis_">A
- quick overview about Output Generation with Spirit.Karma</a>
+<a name="spirit.introduction.a_quick_overview_of_output_generation_with__emphasis_spirit_karma__emphasis_"></a><h3>
+<a name="id458990"></a>
+ <a href="introduction.html#spirit.introduction.a_quick_overview_of_output_generation_with__emphasis_spirit_karma__emphasis_">A
+ Quick Overview of Output Generation with Spirit.Karma</a>
 </h3>

- Spirit not only allows to describe the structure of the input. Starting with
- Version 2.0 it enables the specification of the output format for your data
- in a very similar way, and based on a single syntax and compatible semantics.
+ Spirit not only allows you to describe the structure of the input. Starting
+ with Version 2.0 it enables the specification of the output format for your
+ data in a similar way, and based on a single syntax and compatible semantics.
 

 Let's assume we need to generate a textual representation from a simple data
- structure as a <tt class="computeroutput">std::vector<int></tt>. Conventional
+ structure such as a <tt class="computeroutput">std::vector<int></tt>. Conventional
 code probably would look like:
 
-<pre class="programlisting">
-std::vector<int> v (initialize_and_fill());
+<pre class="programlisting">std::vector<int> v (initialize_and_fill());
std::vector<int>::iterator end = v.end();
for (std::vector<int>::iterator it = v.begin(); it != end; ++it)
 std::cout << *it << std::endl;
@@ -251,19 +245,18 @@

 which is not very flexible and quite difficult to maintain when it comes to
 changing the required output format. Spirit's sublibrary Karma
- allows to specify output formats for arbitrary data structures in a very flexible
- way. following snippet is the Karma format description
- used to create the very The same output as the traditional code above:
+ allows you to specify output formats for arbitrary data structures in a very
+ flexible way. The following snippet is the Karma format
+ description used to create the same output as the traditional code above:
 
-<pre class="programlisting">
-*(int_ << eol)
+<pre class="programlisting">*(int_ << eol)
</pre>

 Here are some more examples of format descriptions for different output representations
 of the same <tt class="computeroutput">std::vector<int></tt>:
 
<div class="table">
-<a name="id620430"></a>Table 2. Different output formats for `std::vector<int>`
+<a name="id459465"></a>Table 2. Different output formats for `std::vector<int>`
<table class="table" summary="Different output formats for `std::vector<int>`">
<colgroup>
<col>
@@ -366,19 +359,19 @@
</table>
</div>

- The syntax is very similar to Qi with the exception that
- we use the <tt class="computeroutput"><<</tt> operator for
+ The syntax is similar to Qi with the exception that we
+ use the <tt class="computeroutput"><<</tt> operator for
 output concatenation. This should be easy to understand as it follows the conventions
 used in the Standard's I/O streams.
 

- Another important feature of karma is to allow to fully
+ Another important feature of karma allows you to fully
 decouple the data type from the output format. You can use the same output
- format with different data types as long as these conforma conceptually. The
+ format with different data types as long as these conform conceptually. The
 next table gives some related examples.
 
<div class="table">
-<a name="id620803"></a>Table 3. Different data types usable with the output format
+<a name="id459935"></a>Table 3. Different data types usable with the output format
 `(*int_ << eol)`
<table class="table" summary="Different data types usable with the output format
 `(*int_ << eol)`">

Modified: trunk/libs/spirit/doc/html/spirit/lex.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -96,23 +96,23 @@
 is not perfect.
 </li>
</ul></div>
-<a name="spirit.lex.lexer_introduction.why_using_a_separate_lexer"></a><h4>
-<a name="id648365"></a>
- <a href="lex.html#spirit.lex.lexer_introduction.why_using_a_separate_lexer">Why
- Using a Separate Lexer</a>
+<a name="spirit.lex.lexer_introduction.why_use_a_separate_lexer_"></a><h4>
+<a name="id488039"></a>
+ <a href="lex.html#spirit.lex.lexer_introduction.why_use_a_separate_lexer_">Why
+ Use a Separate Lexer?</a>
 </h4>

 Typically, lexical scanning is done in a separate module from the parser,
- feeding the parser with a stream of input tokens only. Now, theoretically
- it is not necessary to do this separation. In the end there is only one set
+ feeding the parser with a stream of input tokens only. Theoretically it is
+ not necessary implement this separation as in the end there is only one set
 of syntactical rules defining the language, so in theory we could write the
 whole parser in one module. In fact, Spirit.Qi allows
- to write parsers without using a lexer, parsing the input character stream
+ you to write parsers without using a lexer, parsing the input character stream
 directly, and for the most part this is the way Spirit
 has been used since its invention.
 

- However, the separation has both practical and theoretical bases and proves
+ However, this separation has both practical and theoretical bases and proves
 to be very useful in practical applications. In 1956, Noam Chomsky defined
 the "Chomsky Hierarchy" of grammars:
 
@@ -147,25 +147,24 @@
 handled as regular expressions tend to be the lower-level parts, such as
 the definition of an identifier or of an integer value:
 
-<pre class="programlisting">
-letter := [a-zA-Z]
+<pre class="programlisting">letter := [a-zA-Z]
digit := [0-9]

identifier := letter [ letter | digit ]*
-integer := digit*
+integer := digit+
</pre>

 Higher level parts of practical grammars tend to be more complex and can't
- be implemented using plain regular expressions anymore. We need to store
- information on the built-in hardware stack while recursing the grammar hierarchy,
- and that in fact this is the preferred approach used for top-down parsing.
- Since it takes a different kind of abstract machine to parse the two types
- of grammars, it proved to be efficient to separate the lexical scanner into
- a separate module which is built around the idea of a state machine. The
- goal here is to use the simplest parsing technique needed for the job.
+ be implemented using plain regular expressions. We need to store information
+ on the built-in hardware stack while recursing the grammar hierarchy, and
+ that in fact this is the preferred approach used for top-down parsing. Since
+ it takes a different kind of abstract machine to parse the two types of grammars,
+ it proved to be efficient to separate the lexical scanner into a separate
+ module which is built around the idea of a state machine. The goal here is
+ to use the simplest parsing technique needed for the job.
 

- Another, more practical reason for separating the scanner from the parser
+ Another, more practical, reason for separating the scanner from the parser
 is the need for backtracking during parsing. The input data is a stream of
 characters, which is often thought to be processed left to right without
 any backtracking. Unfortunately, in practice most of the time that isn't
@@ -197,7 +196,7 @@
 grammar recognizers.
 
<a name="spirit.lex.lexer_introduction.advantages_of_using__emphasis_spirit_lex__emphasis_"></a><h4>
-<a name="id648579"></a>
+<a name="id488369"></a>
 <a href="lex.html#spirit.lex.lexer_introduction.advantages_of_using__emphasis_spirit_lex__emphasis_">Advantages
 of using Spirit.Lex</a>
 </h4>
@@ -210,22 +209,22 @@
 making it possible to freely access any context information and data structure.
 Since the C++ compiler sees all the code it will generate optimal code nomatter
 what configuration options have been chosen by the user. Spirit.Lex
- gives you all the features you could get from a similar Flex
- program without the need to leave C++ as a host language:
+ gives you the vast majority of features you could get from a similar Flex program without the need
+ to leave C++ as a host language:
 
<div class="itemizedlist"><ul type="disc">
<li>
- the definition of tokens is done using regular expressions (patterns)
+ The definition of tokens is done using regular expressions (patterns)
 </li>
<li>
- the token definitions can refer to special substitution string (pattern
+ The token definitions can refer to special substitution strings (pattern
 macros) simplifying pattern definitions
 </li>
<li>
- the generated lexical scanner may have multiple start states
+ The generated lexical scanner may have multiple start states
 </li>
<li>
- it is possible to attach code to any of the token definitions; this code
+ It is possible to attach code to any of the token definitions; this code
 gets executed whenever the corresponding token pattern has been matched
 </li>
</ul></div>
@@ -238,14 +237,15 @@
 Model</a>) - a model very similar to the way Flex
 operates - we will mainly focus on the opposite, the dynamic
 model. You can directly integrate the token definitions into your C++ program,
- building the lexical analyzer dynamicly at runtime. The dynamic model is
+ building the lexical analyzer dynamically at runtime. The dynamic model is
 something not supported by Flex
 or other lexical scanner generators (such as re2c,
 <a href="http://www.cs.queensu.ca/~thurston/ragel/" target="_top">Ragel</a>, etc.).
- But it is very flexible and allows to speed up the development of your application.
+ But it is very flexible and allows you to speed up the development of your
+ application.
 
<a name="spirit.lex.lexer_introduction.the_library_structure_of__emphasis_spirit_lex__emphasis_"></a><h4>
-<a name="id648682"></a>
+<a name="id488543"></a>
 <a href="lex.html#spirit.lex.lexer_introduction.the_library_structure_of__emphasis_spirit_lex__emphasis_">The
 Library Structure of Spirit.Lex</a>
 </h4>

Modified: trunk/libs/spirit/doc/html/spirit/lex/abstracts.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/abstracts.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/abstracts.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -84,7 +84,7 @@
 of the Spirit.Lex library.
 
<a name="spirit.lex.abstracts.lexer_primitives.lexer_token_values.the_anatomy_of_a_token"></a><h6>
-<a name="id658935"></a>
+<a name="id499645"></a>
 <a href="abstracts.html#spirit.lex.abstracts.lexer_primitives.lexer_token_values.the_anatomy_of_a_token">The
 Anatomy of a Token</a>
 </h6>
@@ -134,7 +134,7 @@
 
<div class="figure">
<a name="spirit.lex.tokenstructure"></a>Figure 5. The structure of a token
-<img src="../.././images/TokenStructure.png" alt="The
+<img src="../.././images/tokenstructure.png" alt="The
 structure of a token">
</div>

@@ -178,8 +178,7 @@
 Here is the template prototype of the lexertl_token<>
 template:
 
-<pre class="programlisting">
-template <
+<pre class="programlisting">template <
 typename Iterator = char const*,
 typename AttributeTypes = mpl::vector0<>,
 typename HasState = mpl::true_
@@ -222,7 +221,7 @@
 when it is requested for the first time.
 
<a name="spirit.lex.abstracts.lexer_primitives.lexer_token_values.the_physiognomy_of_a_token_definition"></a><h6>
-<a name="id659461"></a>
+<a name="id500459"></a>
 <a href="abstracts.html#spirit.lex.abstracts.lexer_primitives.lexer_token_values.the_physiognomy_of_a_token_definition">The
 Physiognomy of a Token Definition</a>
 </h6>
@@ -235,8 +234,7 @@

 The template prototype of this class is shown here:
 
-<pre class="programlisting">
-template<
+<pre class="programlisting">template<
 typename Attribute = unused_type,
 typename Char = char
>
@@ -296,7 +294,7 @@
</td></tr>
</table></div>
<a name="spirit.lex.abstracts.lexer_primitives.lexer_token_values.examples_of_using__link_linkend__spirit_lex_reference_token_class___code__phrase_role__identifier__lexertl_token__phrase__phrase_role__special___lt__gt___phrase___code___link_"></a><h6>
-<a name="id659718"></a>
+<a name="id500867"></a>
 <a href="abstracts.html#spirit.lex.abstracts.lexer_primitives.lexer_token_values.examples_of_using__link_linkend__spirit_lex_reference_token_class___code__phrase_role__identifier__lexertl_token__phrase__phrase_role__special___lt__gt___phrase___code___link_">Examples
 of using lexertl_token<></a>
 </h6>
@@ -320,8 +318,7 @@



-<pre class="programlisting">
-// these tokens expose the iterator_range of the matched input sequence
+<pre class="programlisting">// these tokens expose the iterator_range of the matched input sequence
token_def<> if_, else_, while_;

// The following two tokens have an associated value type, 'identifier'
@@ -361,8 +358,7 @@



-<pre class="programlisting">
-// This is the lexer token type to use. The second template parameter lists
+<pre class="programlisting">// This is the lexer token type to use. The second template parameter lists
// all attribute types used for token_def's during token definition (see
// calculator_tokens<> above). Here we use the predefined lexertl token
// type, but any compatible token type may be used instead.

Modified: trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_states.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_states.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_states.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -26,17 +26,17 @@
<div class="titlepage"><div><div><h4 class="title">
<a name="spirit.lex.abstracts.lexer_states"></a> Lexer States</h4></div></div></div>
<a name="spirit.lex.abstracts.lexer_states.controlling_the_lexer_state_from_lexer_semantic_actions"></a><h5>
-<a name="id664594"></a>
+<a name="id505296"></a>
 <a href="lexer_states.html#spirit.lex.abstracts.lexer_states.controlling_the_lexer_state_from_lexer_semantic_actions">Controlling
 the Lexer State from Lexer Semantic Actions</a>
 </h5>
<a name="spirit.lex.abstracts.lexer_states.controlling_the_lexer_state_from_parser_semantic_actions"></a><h5>
-<a name="id664607"></a>
+<a name="id505327"></a>
 <a href="lexer_states.html#spirit.lex.abstracts.lexer_states.controlling_the_lexer_state_from_parser_semantic_actions">Controlling
 the Lexer State from Parser Semantic Actions</a>
 </h5>
<a name="spirit.lex.abstracts.lexer_states.using_a_lexer_state_for_the_skip_parser"></a><h5>
-<a name="id664620"></a>
+<a name="id505358"></a>
 <a href="lexer_states.html#spirit.lex.abstracts.lexer_states.using_a_lexer_state_for_the_skip_parser">Using
 a Lexer State for the Skip Parser</a>
 </h5>

Modified: trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_static_model.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_static_model.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_static_model.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -82,8 +82,7 @@



-<pre class="programlisting">
-enum tokenids
+<pre class="programlisting">enum tokenids
{
 IDANY = boost::spirit::lex::min_token_id + 1,
};
@@ -104,8 +103,7 @@



-<pre class="programlisting">
-// This token definition class can be used without any change for all three
+<pre class="programlisting">// This token definition class can be used without any change for all three
// possible use cases: a dynamic lexical analyzer, a code generator, and a
// static lexical analyzer.
template <typename BaseLexer>
@@ -147,8 +145,7 @@



-<pre class="programlisting">
-// This is an ordinary grammar definition following the rules defined by
+<pre class="programlisting">// This is an ordinary grammar definition following the rules defined by
// Spirit.Qi. There is nothing specific about it, except it gets the token
// definition class instance passed to the constructor to allow accessing the
// embedded token_def<> instances.
@@ -181,7 +178,7 @@

 
<a name="spirit.lex.abstracts.lexer_static_model.generating_the_static_analyzer"></a><h5>
-<a name="id662050"></a>
+<a name="id503276"></a>
 <a href="lexer_static_model.html#spirit.lex.abstracts.lexer_static_model.generating_the_static_analyzer">Generating
 the Static Analyzer</a>
 </h5>
@@ -202,8 +199,7 @@



-<pre class="programlisting">
-int main(int argc, char* argv[])
+<pre class="programlisting">int main(int argc, char* argv[])
{
 // create the lexer object instance needed to invoke the generator
 word_count_tokens<lexertl_lexer<> > word_count; // the token definition
@@ -228,7 +224,7 @@
 the next topic (the full generated code can be viewed here).
 
<a name="spirit.lex.abstracts.lexer_static_model.modifying_the_dynamic_analyzer"></a><h5>
-<a name="id662419"></a>
+<a name="id503799"></a>
 <a href="lexer_static_model.html#spirit.lex.abstracts.lexer_static_model.modifying_the_dynamic_analyzer">Modifying
 the Dynamic Analyzer</a>
 </h5>
@@ -248,8 +244,7 @@



-<pre class="programlisting">
-#include <boost/spirit/include/lex_lexer_static_lexertl.hpp>
+<pre class="programlisting">#include <boost/spirit/include/lex_lexer_static_lexertl.hpp>
</pre>

 
@@ -269,8 +264,7 @@



-<pre class="programlisting">
-int main(int argc, char* argv[])
+<pre class="programlisting">int main(int argc, char* argv[])
{
 // Define the token type to be used: 'std::string' is available as the type
 // of the token value.

Modified: trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_tokenizing.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_tokenizing.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/abstracts/lexer_tokenizing.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -30,12 +30,12 @@
 Input Data"> Tokenizing
 Input Data</a></h4></div></div></div>
<a name="spirit.lex.abstracts.lexer_tokenizing.the_tokenize___function"></a><h5>
-<a name="id660244"></a>
+<a name="id501672"></a>
 <a href="lexer_tokenizing.html#spirit.lex.abstracts.lexer_tokenizing.the_tokenize___function">The
 tokenize() function</a>
 </h5>
<a name="spirit.lex.abstracts.lexer_tokenizing.the_generate_static___function"></a><h5>
-<a name="id660261"></a>
+<a name="id501700"></a>
 <a href="lexer_tokenizing.html#spirit.lex.abstracts.lexer_tokenizing.the_generate_static___function">The
 generate_static() function</a>
 </h5>

Modified: trunk/libs/spirit/doc/html/spirit/lex/reference/lexer_class.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/reference/lexer_class.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/reference/lexer_class.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -26,22 +26,22 @@
<div class="titlepage"><div><div><h4 class="title">
<a name="spirit.lex.reference.lexer_class"></a>Lexer Class</h4></div></div></div>
<a name="spirit.lex.reference.lexer_class.the_lexertl_lexer_class_implementing_the_dynamic_model"></a><h5>
-<a name="id664720"></a>
+<a name="id505548"></a>
 <a href="lexer_class.html#spirit.lex.reference.lexer_class.the_lexertl_lexer_class_implementing_the_dynamic_model">The
 lexertl_lexer Class Implementing the Dynamic Model</a>
 </h5>
<a name="spirit.lex.reference.lexer_class.the_lexertl_actor_lexer_class_implementing_the_dynamic_model"></a><h5>
-<a name="id664733"></a>
+<a name="id505576"></a>
 <a href="lexer_class.html#spirit.lex.reference.lexer_class.the_lexertl_actor_lexer_class_implementing_the_dynamic_model">The
 lexertl_actor_lexer Class Implementing the Dynamic Model</a>
 </h5>
<a name="spirit.lex.reference.lexer_class.the_lexertl_static_lexer_class_implementing_the_static_model"></a><h5>
-<a name="id664746"></a>
+<a name="id505606"></a>
 <a href="lexer_class.html#spirit.lex.reference.lexer_class.the_lexertl_static_lexer_class_implementing_the_static_model">The
 lexertl_static_lexer Class Implementing the Static Model</a>
 </h5>
<a name="spirit.lex.reference.lexer_class.the_lexertl_static_actor_lexer_class_implementing_the_static_model"></a><h5>
-<a name="id664759"></a>
+<a name="id505637"></a>
 <a href="lexer_class.html#spirit.lex.reference.lexer_class.the_lexertl_static_actor_lexer_class_implementing_the_static_model">The
 lexertl_static_actor_lexer Class Implementing the Static Model</a>
 </h5>

Modified: trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart1.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart1.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart1.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -43,7 +43,7 @@
 (for the full example code see here: word_count_functor.cpp).
 
<a name="spirit.lex.tutorials.lexer_quickstart1.prerequisites"></a><h5>
-<a name="id648951"></a>
+<a name="id488986"></a>
 <a href="lexer_quickstart1.html#spirit.lex.tutorials.lexer_quickstart1.prerequisites">Prerequisites</a>
 </h5>

@@ -59,8 +59,7 @@



-<pre class="programlisting">
-#include <boost/spirit/include/lex_lexer_lexertl.hpp>
+<pre class="programlisting">#include <boost/spirit/include/lex_lexer_lexertl.hpp>
#include <boost/bind.hpp>
#include <boost/ref.hpp>
</pre>
@@ -76,8 +75,7 @@



-<pre class="programlisting">
-using namespace boost::spirit;
+<pre class="programlisting">using namespace boost::spirit;
using namespace boost::spirit::lex;
</pre>

@@ -85,7 +83,7 @@

 
<a name="spirit.lex.tutorials.lexer_quickstart1.defining_tokens"></a><h5>
-<a name="id649646"></a>
+<a name="id489371"></a>
 <a href="lexer_quickstart1.html#spirit.lex.tutorials.lexer_quickstart1.defining_tokens">Defining
 Tokens</a>
 </h5>
@@ -120,8 +118,7 @@



-<pre class="programlisting">
-template <typename Lexer>
+<pre class="programlisting">template <typename Lexer>
struct word_count_tokens : lexer_def<Lexer>
{
 template <typename Self>
@@ -142,7 +139,7 @@

 
<a name="spirit.lex.tutorials.lexer_quickstart1.doing_the_useful_work"></a><h5>
-<a name="id649992"></a>
+<a name="id489877"></a>
 <a href="lexer_quickstart1.html#spirit.lex.tutorials.lexer_quickstart1.doing_the_useful_work">Doing
 the Useful Work</a>
 </h5>
@@ -168,8 +165,7 @@



-<pre class="programlisting">
-struct counter
+<pre class="programlisting">struct counter
{
 // the function operator gets called for each of the matched tokens
 // c, l, w are references to the counters used to keep track of the numbers
@@ -208,7 +204,7 @@
 as well.
 
<a name="spirit.lex.tutorials.lexer_quickstart1.pulling_everything_together"></a><h5>
-<a name="id650494"></a>
+<a name="id490577"></a>
 <a href="lexer_quickstart1.html#spirit.lex.tutorials.lexer_quickstart1.pulling_everything_together">Pulling
 Everything Together</a>
 </h5>
@@ -227,8 +223,7 @@



-<pre class="programlisting">
-int main(int argc, char* argv[])
+<pre class="programlisting">int main(int argc, char* argv[])
{
 // these variables are used to count characters, words and lines
 std::size_t c = 0, w = 0, l = 0;
@@ -264,7 +259,7 @@

 
<a name="spirit.lex.tutorials.lexer_quickstart1.comparing__emphasis_spirit_lex__emphasis__with__ulink_url__http___flex_sourceforge_net___flex__ulink_"></a><h5>
-<a name="id651326"></a>
+<a name="id491716"></a>
 <a href="lexer_quickstart1.html#spirit.lex.tutorials.lexer_quickstart1.comparing__emphasis_spirit_lex__emphasis__with__ulink_url__http___flex_sourceforge_net___flex__ulink_">Comparing
 Spirit.Lex with Flex</a>
 </h5>
@@ -306,8 +301,7 @@



-<pre class="programlisting">
-%{
+<pre class="programlisting">%{
 #define ID_WORD 1000
 #define ID_EOL 1001
 #define ID_CHAR 1002

Modified: trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart2.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart2.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart2.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -45,7 +45,7 @@
 options along the lines (for the full example code see here: word_count_lexer.cpp).
 
<a name="spirit.lex.tutorials.lexer_quickstart2.prerequisites"></a><h5>
-<a name="id652117"></a>
+<a name="id492776"></a>
 <a href="lexer_quickstart2.html#spirit.lex.tutorials.lexer_quickstart2.prerequisites">Prerequisites</a>
 </h5>

@@ -65,8 +65,7 @@



-<pre class="programlisting">
-#include <boost/spirit/include/support_argument.hpp>
+<pre class="programlisting">#include <boost/spirit/include/support_argument.hpp>
#include <boost/spirit/include/lex_lexer_lexertl.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
@@ -85,8 +84,7 @@



-<pre class="programlisting">
-using namespace boost::spirit;
+<pre class="programlisting">using namespace boost::spirit;
using namespace boost::spirit::lex;
</pre>

@@ -103,8 +101,7 @@



-<pre class="programlisting">
-%{
+<pre class="programlisting">%{
 int c = 0, w = 0, l = 0;
%}
%%
@@ -123,7 +120,7 @@

 
<a name="spirit.lex.tutorials.lexer_quickstart2.semantic_actions_in__emphasis_spirit_lex__emphasis_"></a><h5>
-<a name="id652815"></a>
+<a name="id493728"></a>
 <a href="lexer_quickstart2.html#spirit.lex.tutorials.lexer_quickstart2.semantic_actions_in__emphasis_spirit_lex__emphasis_">Semantic
 Actions in Spirit.Lex</a>
 </h5>
@@ -140,8 +137,7 @@



-<pre class="programlisting">
-template <typename Lexer>
+<pre class="programlisting">template <typename Lexer>
struct word_count_tokens : lexer_def<Lexer>
{
 word_count_tokens()
@@ -181,8 +177,7 @@
 but it is possible to insert any C++ function or function object as long
 as it exposes the interface:
 
-<pre class="programlisting">
-void f (Range r, Idtype id, bool& matched, Context& ctx);
+<pre class="programlisting">void f (Range r, Idtype id, bool& matched, Context& ctx);
</pre>
<div class="variablelist">
where:
@@ -221,8 +216,7 @@
 When using a C++ function as the semantic action the following prototypes
 are allowed as well:
 
-<pre class="programlisting">
-void f (Range r, Idtype id, bool& matched);
+<pre class="programlisting">void f (Range r, Idtype id, bool& matched);
void f (Range r, Idtype id);
void f (Range r);
</pre>
@@ -240,7 +234,7 @@
 to the internal lexer context.
 
<a name="spirit.lex.tutorials.lexer_quickstart2.associating_token_definitions_with_the_lexer"></a><h5>
-<a name="id653861"></a>
+<a name="id495186"></a>
 <a href="lexer_quickstart2.html#spirit.lex.tutorials.lexer_quickstart2.associating_token_definitions_with_the_lexer">Associating
 Token Definitions with the Lexer</a>
 </h5>
@@ -255,8 +249,7 @@
 combining the different token definitions using the <tt class="computeroutput">|</tt>
 operator. Here is the code snippet again:
 
-<pre class="programlisting">
-self = word [++ref(w), ref(c) += distance(_1)]
+<pre class="programlisting">self = word [++ref(w), ref(c) += distance(_1)]
 | eol [++ref(c), ++ref(l)]
 | any [++ref(c)]
 ;

Modified: trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart3.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart3.html (original)
+++ trunk/libs/spirit/doc/html/spirit/lex/tutorials/lexer_quickstart3.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -52,7 +52,7 @@
<div class="figure">
<a name="spirit.lex.flowcontrol"></a>Figure 4. The common flow control implemented while parsing
 combined with lexical analysis
-<img src="../../.././images/FlowOfControl.png" alt="The common flow
+<img src="../../.././images/flowofcontrol.png" alt="The common flow
 control implemented while parsing combined with lexical analysis">
</div>

@@ -70,7 +70,7 @@
 code see here: word_count.cpp).
 
<a name="spirit.lex.tutorials.lexer_quickstart3.prerequisites"></a><h5>
-<a name="id655484"></a>
+<a name="id495762"></a>
 <a href="lexer_quickstart3.html#spirit.lex.tutorials.lexer_quickstart3.prerequisites">Prerequisites</a>
 </h5>

@@ -92,8 +92,7 @@



-<pre class="programlisting">
-#include <boost/spirit/include/qi.hpp>
+<pre class="programlisting">#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/lex_lexer_lexertl.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_statement.hpp>
@@ -111,8 +110,7 @@



-<pre class="programlisting">
-using namespace boost::spirit;
+<pre class="programlisting">using namespace boost::spirit;
using namespace boost::spirit::qi;
using namespace boost::spirit::lex;
</pre>
@@ -121,7 +119,7 @@

 
<a name="spirit.lex.tutorials.lexer_quickstart3.defining_tokens"></a><h5>
-<a name="id655884"></a>
+<a name="id496323"></a>
 <a href="lexer_quickstart3.html#spirit.lex.tutorials.lexer_quickstart3.defining_tokens">Defining
 Tokens</a>
 </h5>
@@ -144,8 +142,7 @@



-<pre class="programlisting">
-template <typename Lexer>
+<pre class="programlisting">template <typename Lexer>
struct word_count_tokens : lexer_def<Lexer>
{
 template <typename Self>
@@ -177,7 +174,7 @@

 
<a name="spirit.lex.tutorials.lexer_quickstart3.using_token_definition_instances_as_parsers"></a><h5>
-<a name="id656242"></a>
+<a name="id496819"></a>
 <a href="lexer_quickstart3.html#spirit.lex.tutorials.lexer_quickstart3.using_token_definition_instances_as_parsers">Using
 Token Definition Instances as Parsers</a>
 </h5>
@@ -285,8 +282,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct word_count_grammar : grammar<Iterator>
{
 template <typename TokenDef>
@@ -355,7 +351,7 @@
 </td></tr>
</table></div>
<a name="spirit.lex.tutorials.lexer_quickstart3.pulling_everything_together"></a><h5>
-<a name="id657239"></a>
+<a name="id498236"></a>
 <a href="lexer_quickstart3.html#spirit.lex.tutorials.lexer_quickstart3.pulling_everything_together">Pulling
 Everything Together</a>
 </h5>
@@ -373,8 +369,7 @@



-<pre class="programlisting">
-int main(int argc, char* argv[])
+<pre class="programlisting">int main(int argc, char* argv[])
{
<a name="spirit4co" href="lexer_quickstart3.html#spirit4"><img src="../../../images/callouts/1.png" alt="1" border="0"></a> typedef lexertl_token<
 char const*, boost::mpl::vector<std::string>

Modified: trunk/libs/spirit/doc/html/spirit/notes/style_guide.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/notes/style_guide.html (original)
+++ trunk/libs/spirit/doc/html/spirit/notes/style_guide.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -58,8 +58,7 @@
 all, what belongs to one level, at one indentation level.
 </li>
</ul></div>
-<pre class="programlisting">
-program
+<pre class="programlisting">program
 = program_heading [heading_action]
 >> block [block_action]
 >> '.'
@@ -85,8 +84,7 @@
 separate them from the rules.
 </li>
</ul></div>
-<pre class="programlisting">
-program_heading
+<pre class="programlisting">program_heading
 = no_case["program"]
 >> identifier
 >> '('
@@ -102,8 +100,7 @@
 of directives, semantic expressions (using Phoenix or LL lambda expressions)
 or parsers should be placed as follows.
 </li></ul></div>
-<pre class="programlisting">
-identifier
+<pre class="programlisting">identifier
 = no_case
 [
 lexeme
@@ -122,8 +119,7 @@
 'body' at the same indentation level as the rule itself, highlighting the
 unary operator.
 </li></ul></div>
-<pre class="programlisting">
-block
+<pre class="programlisting">block
 = *( label_declaration_part
 | constant_definition_part
 | type_definition_part

Modified: trunk/libs/spirit/doc/html/spirit/qi_and_karma.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/qi_and_karma.html (original)
+++ trunk/libs/spirit/doc/html/spirit/qi_and_karma.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -120,7 +120,7 @@
<div class="titlepage"><div><div><h4 class="title">
<a name="spirit.qi_and_karma.tutorials.quick_start"></a>Quick Start</h4></div></div></div>
<a name="spirit.qi_and_karma.tutorials.quick_start.why_would_you_want_to_use_spirit_qi_"></a><h5>
-<a name="id621042"></a>
+<a name="id460252"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.quick_start.why_would_you_want_to_use_spirit_qi_">Why
 would you want to use Spirit.Qi?</a>
 </h5>
@@ -167,15 +167,14 @@
 on how to build parsers from the simplest parser, building up as we go.
 
<a name="spirit.qi_and_karma.tutorials.warming_up.trivial_example__1_parsing_a_number"></a><h5>
-<a name="id621087"></a>
+<a name="id460361"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.warming_up.trivial_example__1_parsing_a_number">Trivial
 Example #1 Parsing a number</a>
 </h5>

 Create a parser that will parse a floating-point number.
 
-<pre class="programlisting">
-double_
+<pre class="programlisting">double_
</pre>

 (You've got to admit, that's trivial!) The above code actually generates
@@ -183,7 +182,7 @@
 parsers and consistent naming conventions help you keep from going insane!
 
<a name="spirit.qi_and_karma.tutorials.warming_up.trivial_example__2_parsing_two_numbers"></a><h5>
-<a name="id621117"></a>
+<a name="id460416"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.warming_up.trivial_example__2_parsing_two_numbers">Trivial
 Example #2 Parsing two numbers</a>
 </h5>
@@ -191,8 +190,7 @@
 Create a parser that will accept a line consisting of two floating-point
 numbers.
 
-<pre class="programlisting">
-double_ >> double_
+<pre class="programlisting">double_ >> double_
</pre>

 Here you see the familiar floating-point numeric parser <tt class="computeroutput">double_</tt>
@@ -217,15 +215,14 @@
 </td></tr>
</table></div>
<a name="spirit.qi_and_karma.tutorials.warming_up.trivial_example__3_parsing_one_or_more_numbers"></a><h5>
-<a name="id621180"></a>
+<a name="id460526"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.warming_up.trivial_example__3_parsing_one_or_more_numbers">Trivial
 Example #3 Parsing one or more numbers</a>
 </h5>

 Create a parser that will accept one or more floating-point numbers.
 
-<pre class="programlisting">
-*double_
+<pre class="programlisting">*double_
</pre>

 This is like a regular-expression Kleene Star, though the syntax might
@@ -242,7 +239,7 @@
 in most places.
 
<a name="spirit.qi_and_karma.tutorials.warming_up.trivial_example__4_parsing_a_comma_delimited_list_of_numbers"></a><h5>
-<a name="id621225"></a>
+<a name="id460609"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.warming_up.trivial_example__4_parsing_a_comma_delimited_list_of_numbers">Trivial
 Example #4 Parsing a comma-delimited list of numbers</a>
 </h5>
@@ -250,8 +247,7 @@
 This example will create a parser that accepts a comma-delimited list of
 numbers.
 
-<pre class="programlisting">
-double_ >> *(char_(',') >> double_)
+<pre class="programlisting">double_ >> *(char_(',') >> double_)
</pre>

 Notice <tt class="computeroutput">char_(',')</tt>. It is
@@ -259,15 +255,14 @@
 In this case, the Kleene Star is modifying a more complex parser, namely,
 the one generated by the expression:
 
-<pre class="programlisting">
-(char_(',') >> double_)
+<pre class="programlisting">(char_(',') >> double_)
</pre>

 Note that this is a case where the parentheses are necessary. The Kleene
 star encloses the complete expression above.
 
<a name="spirit.qi_and_karma.tutorials.warming_up.let_s_parse_"></a><h5>
-<a name="id621358"></a>
+<a name="id460803"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.warming_up.let_s_parse_">Let's
 Parse!</a>
 </h5>
@@ -308,8 +303,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
bool parse_numbers(Iterator first, Iterator last)
{
 bool r = phrase_parse(
@@ -442,8 +436,7 @@
 can make the parser call <tt class="computeroutput">F</tt>
 whenever it matches an input by attaching <tt class="computeroutput">F</tt>:
 
-<pre class="programlisting">
-P[F]
+<pre class="programlisting">P[F]
</pre>

 The expression above links <tt class="computeroutput">F</tt>
@@ -456,8 +449,7 @@
 we need <tt class="computeroutput">F</tt> to be declared
 as:
 
-<pre class="programlisting">
-void F(double n);
+<pre class="programlisting">void F(double n);
</pre>

 There are actually 2 more arguments being passed (the parser context and
@@ -496,8 +488,7 @@



-<pre class="programlisting">
-// A plain function
+<pre class="programlisting">// A plain function
void write(int const& i)
{
 std::cout << i << std::endl;
@@ -536,8 +527,7 @@

 All examples parse inputs of the form:
 
-<pre class="programlisting">
-"{integer}"
+<pre class="programlisting">"{integer}"
</pre>

 An integer inside the curly braces.
@@ -550,8 +540,7 @@



-<pre class="programlisting">
-qi::parse(first, last, '{' >> int_[&write] >> '}');
+<pre class="programlisting">qi::parse(first, last, '{' >> int_[&write] >> '}');
</pre>

 
@@ -570,8 +559,7 @@



-<pre class="programlisting">
-qi::parse(first, last, '{' >> int_[write_action()] >> '}');
+<pre class="programlisting">qi::parse(first, last, '{' >> int_[write_action()] >> '}');
</pre>

 
@@ -586,8 +574,7 @@



-<pre class="programlisting">
-writer w;
+<pre class="programlisting">writer w;
qi::parse(first, last, '{' >> int_[boost::bind(&writer::print, &w, _1)] >> '}');
</pre>

@@ -603,8 +590,7 @@



-<pre class="programlisting">
-qi::parse(first, last, '{' >> int_[boost::bind(&write, _1)] >> '}');
+<pre class="programlisting">qi::parse(first, last, '{' >> int_[boost::bind(&write, _1)] >> '}');
</pre>

 
@@ -618,8 +604,7 @@



-<pre class="programlisting">
-qi::parse(first, last, '{' >> int_[std::cout << _1 << '\n'] >> '}');
+<pre class="programlisting">qi::parse(first, last, '{' >> int_[std::cout << _1 << '\n'] >> '}');
</pre>

 
@@ -637,7 +622,7 @@
 The examples above can be found here: ../../example/qi/actions.cpp
 
<a name="spirit.qi_and_karma.tutorials.semantic_actions.phoenix"></a><h5>
-<a name="id623150"></a>
+<a name="id463328"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.semantic_actions.phoenix">Phoenix</a>
 </h5>

@@ -663,8 +648,7 @@

 Here's a simple parser expression for complex numbers:
 
-<pre class="programlisting">
- '(' >> double_ >> -(',' >> double_) >> ')'
+<pre class="programlisting"> '(' >> double_ >> -(',' >> double_) >> ')'
| double_
</pre>

@@ -695,8 +679,7 @@

 This parser can parse complex numbers of the form:
 
-<pre class="programlisting">
-(123.45, 987.65)
+<pre class="programlisting">(123.45, 987.65)
(123.45)
123.45
</pre>
@@ -708,8 +691,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
bool parse_complex(Iterator first, Iterator last, std::complex<double>& c)
{
 double rN = 0.0;
@@ -743,8 +725,7 @@
 The <tt class="computeroutput">double_</tt> parser attaches
 this action:
 
-<pre class="programlisting">
-ref(n) = _1
+<pre class="programlisting">ref(n) = _1
</pre>

 This assigns the parsed result (actually, the attribute of <tt class="computeroutput">double_</tt>) to n. <tt class="computeroutput">ref(n)</tt>
@@ -770,8 +751,7 @@



-<pre class="programlisting">
-#include <boost/spirit/include/qi.hpp>
+<pre class="programlisting">#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <iostream>
@@ -789,8 +769,7 @@



-<pre class="programlisting">
-using namespace boost::phoenix;
+<pre class="programlisting">using namespace boost::phoenix;
using namespace boost::spirit;
using namespace boost::spirit::qi;
using namespace boost::spirit::ascii;
@@ -905,8 +884,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
bool adder(Iterator first, Iterator last, double& n)
{
 bool r = phrase_parse(first, last,
@@ -943,8 +921,7 @@
 The first <tt class="computeroutput">double_</tt> parser
 attaches this action:
 
-<pre class="programlisting">
-ref(n) = _1
+<pre class="programlisting">ref(n) = _1
</pre>

 This assigns the parsed result (actually, the attribute of <tt class="computeroutput">double_</tt>) to <tt class="computeroutput">n</tt>.
@@ -956,8 +933,7 @@
 The second <tt class="computeroutput">double_</tt> parser
 attaches this action:
 
-<pre class="programlisting">
-ref(n) += _1
+<pre class="programlisting">ref(n) += _1
</pre>

 So, subsequent numbers add into <tt class="computeroutput">n</tt>.
@@ -980,8 +956,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
{
 bool r = phrase_parse(first, last,
@@ -1014,8 +989,7 @@
 <tt class="computeroutput">push_back</tt> is supplied by
 <a href="../../../phoenix/doc/html/index.html" target="_top">Phoenix</a>. The expression:
 
-<pre class="programlisting">
-push_back(ref(v), _1)
+<pre class="programlisting">push_back(ref(v), _1)
</pre>

 appends the parsed number. Like before, <tt class="computeroutput">_1</tt>
@@ -1034,16 +1008,14 @@

 So far, we've been using the syntax:
 
-<pre class="programlisting">
-double_ >> *(',' >> double_)
+<pre class="programlisting">double_ >> *(',' >> double_)
</pre>

 to parse a comma-delimited list of numbers. Such lists are common in parsing
 and Spirit provides a simpler shortcut for them. The expression above can
 be simplified to:
 
-<pre class="programlisting">
-double_ % ','
+<pre class="programlisting">double_ % ','
</pre>

 read as: a list of doubles separated by <tt class="computeroutput">','</tt>.
@@ -1057,8 +1029,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
{
 bool r = phrase_parse(first, last,
@@ -1097,20 +1068,17 @@
 from primitives using operators, like the list parser, also have an attribute.
 It so happens that the the attribute of a list parser:
 
-<pre class="programlisting">
-p % d
+<pre class="programlisting">p % d
</pre>

 is a <tt class="computeroutput">std::vector</tt> of the attribute of <tt class="computeroutput">p</tt>. So, for our parser:
 
-<pre class="programlisting">
-double_ % ','
+<pre class="programlisting">double_ % ','
</pre>

 we'll have an attribute of:
 
-<pre class="programlisting">
-std::vector<double>
+<pre class="programlisting">std::vector<double>
</pre>

 So, what does this give us? Well, we can simply pass in a <tt class="computeroutput">std::vector<double></tt>
@@ -1143,8 +1111,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
bool parse_numbers(Iterator first, Iterator last, std::vector<double>& v)
{
 bool r = phrase_parse(first, last,
@@ -1195,7 +1162,7 @@
 </li>
</ul></div>
<a name="spirit.qi_and_karma.tutorials.roman_numerals.symbol_table"></a><h5>
-<a name="id627428"></a>
+<a name="id467678"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.roman_numerals.symbol_table">Symbol
 Table</a>
 </h5>
@@ -1236,8 +1203,7 @@



-<pre class="programlisting">
-struct hundreds_ : symbols<char, unsigned>
+<pre class="programlisting">struct hundreds_ : symbols<char, unsigned>
{
 hundreds_()
 {
@@ -1268,8 +1234,7 @@



-<pre class="programlisting">
-struct tens_ : symbols<char, unsigned>
+<pre class="programlisting">struct tens_ : symbols<char, unsigned>
{
 tens_()
 {
@@ -1300,8 +1265,7 @@



-<pre class="programlisting">
-struct ones_ : symbols<char, unsigned>
+<pre class="programlisting">struct ones_ : symbols<char, unsigned>
{
 ones_()
 {
@@ -1330,7 +1294,7 @@
 They are all parsers.
 
<a name="spirit.qi_and_karma.tutorials.roman_numerals.rules"></a><h5>
-<a name="id628936"></a>
+<a name="id468962"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.roman_numerals.rules">Rules</a>
 </h5>

@@ -1347,8 +1311,7 @@
 A parser expression can be assigned to, what is called, a "rule".
 There are various ways to declare rules. The simplest form is:
 
-<pre class="programlisting">
-rule<Iterator> r;
+<pre class="programlisting">rule<Iterator> r;
</pre>

 At the very least, the rule needs to know the iterator type it will be
@@ -1358,14 +1321,12 @@
 the skipper argument). If you want to have it skip white spaces, you need
 to pass in the type skip parser, as in the next form:
 
-<pre class="programlisting">
-rule<Iterator, Skipper> r;
+<pre class="programlisting">rule<Iterator, Skipper> r;
</pre>

 Example:
 
-<pre class="programlisting">
-rule<std::string::iterator, space_type> r;
+<pre class="programlisting">rule<std::string::iterator, space_type> r;
</pre>

 This type of rule can be used for both <tt class="computeroutput">phrase_parse</tt>
@@ -1374,14 +1335,12 @@

 For our next example, there's one more rule form you should know about:
 
-<pre class="programlisting">
-rule<Iterator, Signature> r;
+<pre class="programlisting">rule<Iterator, Signature> r;
</pre>

 or
 
-<pre class="programlisting">
-rule<Iterator, Signature, Skipper> r;
+<pre class="programlisting">rule<Iterator, Signature, Skipper> r;
</pre>
<div class="tip"><table border="0" summary="Tip">
<tr>
@@ -1406,18 +1365,16 @@
 You can think of them as function arguments. And, rightly so, the rule
 signature is a function signature of the form:
 
-<pre class="programlisting">
-result(argN, argN,..., argN)
+<pre class="programlisting">result(argN, argN,..., argN)
</pre>

 After having declared a rule, you can now assign any parser expression
 to it. Example:
 
-<pre class="programlisting">
-r = double_ >> *(',' >> double_);
+<pre class="programlisting">r = double_ >> *(',' >> double_);
</pre>
<a name="spirit.qi_and_karma.tutorials.roman_numerals.grammars"></a><h5>
-<a name="id629337"></a>
+<a name="id469547"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.roman_numerals.grammars">Grammars</a>
 </h5>

@@ -1448,8 +1405,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct roman : grammar<Iterator, unsigned()>
{
 roman() : roman::base_type(start)
@@ -1517,7 +1473,7 @@
 </li>
</ul></div>
<a name="spirit.qi_and_karma.tutorials.roman_numerals.let_s_parse_"></a><h5>
-<a name="id629952"></a>
+<a name="id470410"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.roman_numerals.let_s_parse_">Let's
 Parse!</a>
 </h5>
@@ -1526,8 +1482,7 @@



-<pre class="programlisting">
-bool r = parse(iter, end, roman_parser, result);
+<pre class="programlisting">bool r = parse(iter, end, roman_parser, result);

if (r && iter == end)
{
@@ -1597,8 +1552,7 @@



-<pre class="programlisting">
-struct employee
+<pre class="programlisting">struct employee
{
 int age;
 std::string surname;
@@ -1626,8 +1580,7 @@



-<pre class="programlisting">
-BOOST_FUSION_ADAPT_STRUCT(
+<pre class="programlisting">BOOST_FUSION_ADAPT_STRUCT(
 employee,
 (int, age)
 (std::string, surname)
@@ -1642,8 +1595,7 @@

 Now we'll write a parser for our employee. Inputs will be of the form:
 
-<pre class="programlisting">
-employee{ age, "surname", "forename", salary }
+<pre class="programlisting">employee{ age, "surname", "forename", salary }
</pre>

 Here goes:
@@ -1653,8 +1605,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct employee_parser : grammar<Iterator, employee(), space_type>
{
 employee_parser() : employee_parser::base_type(start)
@@ -1687,8 +1638,7 @@
 Let's walk through this one step at a time (not necessarily from top to
 bottom).
 
-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct employee_parser : grammar<Iterator, employee(), space_type>
</pre>

@@ -1696,22 +1646,19 @@
 Like before, we make it a template so that we can reuse it for different
 iterator types. The grammar's signature is:
 
-<pre class="programlisting">
-employee()
+<pre class="programlisting">employee()
</pre>

 meaning, the parser generates employee structs. <tt class="computeroutput">employee_parser</tt>
 skips white spaces using <tt class="computeroutput">space_type</tt>
 as its skip parser.
 
-<pre class="programlisting">
-employee_parser() : employee_parser::base_type(start)
+<pre class="programlisting">employee_parser() : employee_parser::base_type(start)
</pre>

 Initializes the base class.
 
-<pre class="programlisting">
-rule<Iterator, std::string(), space_type> quoted_string;
+<pre class="programlisting">rule<Iterator, std::string(), space_type> quoted_string;
rule<Iterator, employee(), space_type> start;
</pre>

@@ -1721,51 +1668,46 @@
 has a <tt class="computeroutput">std::string</tt> attribute.
 
<a name="spirit.qi_and_karma.tutorials.employee___parsing_into_structs.lexeme"></a><h5>
-<a name="id632030"></a>
+<a name="id472484"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.employee___parsing_into_structs.lexeme">Lexeme</a>
 </h5>
-<pre class="programlisting">
-lexeme['"' >> +(char_ - '"') >> '"'];
+<pre class="programlisting">lexeme['"' >> +(char_ - '"') >> '"'];
</pre>

 <tt class="computeroutput">lexeme</tt> inhibits space skipping
 from the open brace to the closing brace. The expression parses quoted
 strings.
 
-<pre class="programlisting">
-+(char_ - '"')
+<pre class="programlisting">+(char_ - '"')
</pre>

 parses one or more chars, except the double quote. It stops when it sees
 a double quote.
 
<a name="spirit.qi_and_karma.tutorials.employee___parsing_into_structs.difference"></a><h5>
-<a name="id632141"></a>
+<a name="id472645"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.employee___parsing_into_structs.difference">Difference</a>
 </h5>

 The expression:
 
-<pre class="programlisting">
-a - b
+<pre class="programlisting">a - b
</pre>

 parses <tt class="computeroutput">a</tt> but not <tt class="computeroutput">b</tt>. Its attribute is just <tt class="computeroutput">A</tt>, the attribute of <tt class="computeroutput">a</tt>.
 <tt class="computeroutput">b</tt>'s attribute is ignored.
 Hence, the attribute of:
 
-<pre class="programlisting">
-char_ - '"'
+<pre class="programlisting">char_ - '"'
</pre>

 is just <tt class="computeroutput">char</tt>.
 
<a name="spirit.qi_and_karma.tutorials.employee___parsing_into_structs.plus"></a><h5>
-<a name="id632246"></a>
+<a name="id472806"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.employee___parsing_into_structs.plus">Plus</a>
 </h5>
-<pre class="programlisting">
-+a
+<pre class="programlisting">+a
</pre>

 is the close kin of the kleene star we got so used to in our tutorial.
@@ -1773,25 +1715,22 @@
 is the attribute of <tt class="computeroutput">a</tt>.
 So, putting all these together, the attribute of
 
-<pre class="programlisting">
-+(char_ - '"')
+<pre class="programlisting">+(char_ - '"')
</pre>

 is then:
 
-<pre class="programlisting">
-std::vector<char>
+<pre class="programlisting">std::vector<char>
</pre>
<a name="spirit.qi_and_karma.tutorials.employee___parsing_into_structs.sequence_attribute"></a><h5>
-<a name="id632373"></a>
+<a name="id472994"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.employee___parsing_into_structs.sequence_attribute">Sequence
 Attribute</a>
 </h5>

 Now what's the attribute of
 
-<pre class="programlisting">
-'"' >> +(char_ - '"') >> '"'
+<pre class="programlisting">'"' >> +(char_ - '"') >> '"'
</pre>

 ?
@@ -1799,14 +1738,12 @@

 Well, typically, the attribute of:
 
-<pre class="programlisting">
-a >> b >> c
+<pre class="programlisting">a >> b >> c
</pre>

 is:
 
-<pre class="programlisting">
-fusion::vector<A, B, C>
+<pre class="programlisting">fusion::vector<A, B, C>
</pre>

 where <tt class="computeroutput">A</tt> is the attribute
@@ -1827,7 +1764,7 @@
 </td></tr>
</table></div>
<a name="spirit.qi_and_karma.tutorials.employee___parsing_into_structs.attribute_collapsing"></a><h5>
-<a name="id632599"></a>
+<a name="id473317"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.employee___parsing_into_structs.attribute_collapsing">Attribute
 Collapsing</a>
 </h5>
@@ -1843,8 +1780,7 @@
 - '"')</tt> has a <tt class="computeroutput">std::vector<char></tt> attribute, the whole expression's attribute
 should have been:
 
-<pre class="programlisting">
-fusion::vector<std::vector<char> >
+<pre class="programlisting">fusion::vector<std::vector<char> >
</pre>

 But wait, there's one more collapsing rule: If after the attribute is a
@@ -1852,33 +1788,29 @@
 from its container. So, to make a long story short, the attribute of the
 expression:
 
-<pre class="programlisting">
-'"' >> +(char_ - '"') >> '"'
+<pre class="programlisting">'"' >> +(char_ - '"') >> '"'
</pre>

 is:
 
-<pre class="programlisting">
-std::vector<char>
+<pre class="programlisting">std::vector<char>
</pre>
<a name="spirit.qi_and_karma.tutorials.employee___parsing_into_structs.auto_rules"></a><h5>
-<a name="id632839"></a>
+<a name="id473668"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.employee___parsing_into_structs.auto_rules">Auto
 Rules</a>
 </h5>

 It is typical to see rules like:
 
-<pre class="programlisting">
-r = p[_val = _1];
+<pre class="programlisting">r = p[_val = _1];
</pre>

 If you have a rule definition like above where the attribute of the RHS
 (right hand side) of the rule is compatibe with the attribute of the LHS
 (left hand side), then you can rewrite it as:
 
-<pre class="programlisting">
-r %= p;
+<pre class="programlisting">r %= p;
</pre>

 The attribute of <tt class="computeroutput">p</tt> automatically
@@ -1888,14 +1820,12 @@
 So, going back to our <tt class="computeroutput">quoted_string</tt>
 rule:
 
-<pre class="programlisting">
-quoted_string %= lexeme['"' >> +(char_ - '"') >> '"'];
+<pre class="programlisting">quoted_string %= lexeme['"' >> +(char_ - '"') >> '"'];
</pre>

 is a simplified version of:
 
-<pre class="programlisting">
-quoted_string = lexeme['"' >> +(char_ - '"') >> '"'][val_ = _1];
+<pre class="programlisting">quoted_string = lexeme['"' >> +(char_ - '"') >> '"'][val_ = _1];
</pre>

 The attribute of the <tt class="computeroutput">quoted_string</tt>
@@ -1904,14 +1834,13 @@
 directly into the rule's attribute, in-situ.
 
<a name="spirit.qi_and_karma.tutorials.employee___parsing_into_structs.finally"></a><h5>
-<a name="id634319"></a>
+<a name="id474119"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.employee___parsing_into_structs.finally">Finally</a>
 </h5>

 We're down to one rule, the start rule:
 
-<pre class="programlisting">
-start %=
+<pre class="programlisting">start %=
 lit("employee")
 >> '{'
 >> int_ >> ','
@@ -1924,8 +1853,7 @@

 Applying our collapsing rules above, the RHS has an attribute of:
 
-<pre class="programlisting">
-fusion::vector<int, std::string, std::string, double>
+<pre class="programlisting">fusion::vector<int, std::string, std::string, double>
</pre>

 These nodes do not have an attribute:
@@ -1958,8 +1886,7 @@



-<pre class="programlisting">
-struct employee
+<pre class="programlisting">struct employee
{
 int age;
 std::string surname;
@@ -2028,7 +1955,7 @@
 for testing purposes. "4.toyxml" has an error in it.
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.first_cut"></a><h5>
-<a name="id634972"></a>
+<a name="id475029"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.first_cut">First
 Cut</a>
 </h5>
@@ -2040,8 +1967,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct mini_xml_grammar : grammar<Iterator, mini_xml(), space_type>
{
 mini_xml_grammar() : mini_xml_grammar::base_type(xml)
@@ -2084,14 +2010,12 @@
 Going bottom up, let's examine the <tt class="computeroutput">text</tt>
 rule:
 
-<pre class="programlisting">
-rule<Iterator, std::string(), space_type> text;
+<pre class="programlisting">rule<Iterator, std::string(), space_type> text;
</pre>

 and its definition:
 
-<pre class="programlisting">
-text = lexeme[+(char_ - '<') [_val += _1]];
+<pre class="programlisting">text = lexeme[+(char_ - '<') [_val += _1]];
</pre>

 The semantic action collects the chars and appends them (via +=) to the
@@ -2099,17 +2023,15 @@
 by the placeholder <tt class="computeroutput">_val</tt>).
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.alternates"></a><h5>
-<a name="id635930"></a>
+<a name="id476318"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.alternates">Alternates</a>
 </h5>
-<pre class="programlisting">
-rule<Iterator, mini_xml_node(), space_type> node;
+<pre class="programlisting">rule<Iterator, mini_xml_node(), space_type> node;
</pre>

 and its definition:
 
-<pre class="programlisting">
-node = (xml | text) [_val = _1];
+<pre class="programlisting">node = (xml | text) [_val = _1];
</pre>

 We'll see what a <tt class="computeroutput">mini_xml_node</tt>
@@ -2117,15 +2039,13 @@
 goiing on here. An xml <tt class="computeroutput">node</tt>
 is either an <tt class="computeroutput">xml</tt> OR <tt class="computeroutput">text</tt>. Hmmm... hold on to that thought...
 
-<pre class="programlisting">
-rule<Iterator, std::string(), space_type> start_tag;
+<pre class="programlisting">rule<Iterator, std::string(), space_type> start_tag;
</pre>

 Again, with an attribute of <tt class="computeroutput">std::string</tt>.
 Then, it's definition:
 
-<pre class="programlisting">
-start_tag =
+<pre class="programlisting">start_tag =
 '<'
 >> !char_('/')
 >> lexeme[+(char_ - '>') [_val += _1]]
@@ -2133,7 +2053,7 @@
;
</pre>
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.not_predicate"></a><h5>
-<a name="id636269"></a>
+<a name="id476781"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.not_predicate">Not
 Predicate</a>
 </h5>
@@ -2143,8 +2063,7 @@
 the added <tt class="computeroutput">'<'</tt> and <tt class="computeroutput">'>'</tt>. But wait, to make sure that the <tt class="computeroutput">start_tag</tt> does not parse <tt class="computeroutput">end_tag</tt>s too, we add: <tt class="computeroutput">!char_('/')</tt>. This
 is a "Not Predicate":
 
-<pre class="programlisting">
-!p
+<pre class="programlisting">!p
</pre>

 It will try the parser, <tt class="computeroutput">p</tt>.
@@ -2154,31 +2073,28 @@
 any input though. It will always rewind the iterator position to where
 it was upon entry. So, the expression:
 
-<pre class="programlisting">
-!char_('/')
+<pre class="programlisting">!char_('/')
</pre>

 basically says: we should not have a <tt class="computeroutput">'/'</tt>
 at this point.
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.inherited_attribute"></a><h5>
-<a name="id637111"></a>
+<a name="id477026"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.inherited_attribute">Inherited
 Attribute</a>
 </h5>

 The <tt class="computeroutput">end_tag</tt>:
 
-<pre class="programlisting">
-rule<Iterator, void(std::string), space_type> end_tag;
+<pre class="programlisting">rule<Iterator, void(std::string), space_type> end_tag;
</pre>

 Ohh! Now we see an inherited attribute there: <tt class="computeroutput">std::string</tt>.
 The <tt class="computeroutput">end_tag</tt> does not have
 a synthesized attribute. Let's see its definition:
 
-<pre class="programlisting">
-end_tag =
+<pre class="programlisting">end_tag =
 "</"
 >> lit(_r1)
 >> '>'
@@ -2190,7 +2106,7 @@
 <tt class="computeroutput">_r3</tt>, etc. if you have more).
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.a_lazy_lit"></a><h5>
-<a name="id637309"></a>
+<a name="id477308"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.a_lazy_lit">A
 Lazy Lit</a>
 </h5>
@@ -2203,15 +2119,13 @@

 Finally, our <tt class="computeroutput">xml</tt> rule:
 
-<pre class="programlisting">
-rule<Iterator, mini_xml(), space_type> xml;
+<pre class="programlisting">rule<Iterator, mini_xml(), space_type> xml;
</pre>

 <tt class="computeroutput">mini_xml</tt> is our attribute
 here. We'll see later what it is. Let's see its definition:
 
-<pre class="programlisting">
-xml =
+<pre class="programlisting">xml =
 start_tag [at_c<0>(_val) = _1]
 >> *node [push_back(at_c<1>(_val), _1)]
 >> end_tag(at_c<0>(_val))
@@ -2226,7 +2140,7 @@
 accessors, provided by Phoenix.
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.how_it_all_works"></a><h5>
-<a name="id637650"></a>
+<a name="id477789"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.how_it_all_works">How
 it all works</a>
 </h5>
@@ -2256,14 +2170,12 @@

 To give the last item some more light, what happens is this:
 
-<pre class="programlisting">
-end_tag(at_c<0>(_val))
+<pre class="programlisting">end_tag(at_c<0>(_val))
</pre>

 calls:
 
-<pre class="programlisting">
-end_tag =
+<pre class="programlisting">end_tag =
 "</"
 >> lit(_r1)
 >> '>'
@@ -2275,7 +2187,7 @@
 as <tt class="computeroutput">_r1</tt>.
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.the_structures"></a><h5>
-<a name="id637956"></a>
+<a name="id478235"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.the_structures">The
 Structures</a>
 </h5>
@@ -2288,8 +2200,7 @@



-<pre class="programlisting">
-struct mini_xml;
+<pre class="programlisting">struct mini_xml;

typedef
 boost::variant<
@@ -2309,7 +2220,7 @@

 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.of_alternates_and_variants"></a><h5>
-<a name="id638154"></a>
+<a name="id478508"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.of_alternates_and_variants">Of
 Alternates and Variants</a>
 </h5>
@@ -2324,21 +2235,19 @@

 Yep, you got that right: the attribute of an alternate:
 
-<pre class="programlisting">
-a | b
+<pre class="programlisting">a | b
</pre>

 is a
 
-<pre class="programlisting">
-boost::variant<A, B>
+<pre class="programlisting">boost::variant<A, B>
</pre>

 where <tt class="computeroutput">A</tt> is the attribute
 of <tt class="computeroutput">a</tt> and <tt class="computeroutput">B</tt> is the attribute of <tt class="computeroutput">b</tt>.
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.adapting_structs_again"></a><h5>
-<a name="id638331"></a>
+<a name="id478778"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.adapting_structs_again">Adapting
 structs again</a>
 </h5>
@@ -2353,8 +2262,7 @@



-<pre class="programlisting">
-BOOST_FUSION_ADAPT_STRUCT(
+<pre class="programlisting">BOOST_FUSION_ADAPT_STRUCT(
 mini_xml,
 (std::string, name)
 (std::vector<mini_xml_node>, children)
@@ -2365,7 +2273,7 @@

 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.one_more_take"></a><h5>
-<a name="id638460"></a>
+<a name="id478959"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.one_more_take">One
 More Take</a>
 </h5>
@@ -2379,8 +2287,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct mini_xml_grammar
 : grammar<Iterator, mini_xml(), locals<std::string>, space_type>
{
@@ -2429,12 +2336,11 @@
 in the <tt class="computeroutput">xml</tt> rule:
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___asts_.local_variables"></a><h5>
-<a name="id639176"></a>
+<a name="id479925"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___asts_.local_variables">Local
 Variables</a>
 </h5>
-<pre class="programlisting">
-rule<Iterator, mini_xml(), locals<std::string>, space_type> xml;
+<pre class="programlisting">rule<Iterator, mini_xml(), locals<std::string>, space_type> xml;
</pre>

 Wow, we have four template parameters now. What's that <tt class="computeroutput">locals</tt>
@@ -2442,8 +2348,7 @@
 will have one local variable: a <tt class="computeroutput">string</tt>.
 Let's see how this is used in action:
 
-<pre class="programlisting">
-xml %=
+<pre class="programlisting">xml %=
 start_tag[_a = _1]
 >> *node
 >> end_tag(_a)
@@ -2494,8 +2399,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct mini_xml_grammar
 : grammar<Iterator, mini_xml(), locals<std::string>, space_type>
{
@@ -2558,28 +2462,26 @@
 What's new?
 
<a name="spirit.qi_and_karma.tutorials.mini_xml___error_handling.readable_names"></a><h5>
-<a name="id641568"></a>
+<a name="id481710"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___error_handling.readable_names">Readable
 Names</a>
 </h5>

 First, when we call the base class, we give the grammar a name:
 
-<pre class="programlisting">
-: mini_xml_grammar::base_type(xml, "xml")
+<pre class="programlisting">: mini_xml_grammar::base_type(xml, "xml")
</pre>

 Then, we name all our rules:
 
-<pre class="programlisting">
-xml.name("xml");
+<pre class="programlisting">xml.name("xml");
node.name("node");
text.name("text");
start_tag.name("start_tag");
end_tag.name("end_tag");
</pre>
<a name="spirit.qi_and_karma.tutorials.mini_xml___error_handling.on_error"></a><h5>
-<a name="id641748"></a>
+<a name="id481964"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___error_handling.on_error">On
 Error</a>
 </h5>
@@ -2587,15 +2489,13 @@
 <tt class="computeroutput">on_error</tt> declares our error
 handler:
 
-<pre class="programlisting">
-on_error<Action>(rule, handler)
+<pre class="programlisting">on_error<Action>(rule, handler)
</pre>

 This will specify what we will do when we get an error. We will print out
 an error message using phoenix:
 
-<pre class="programlisting">
-on_error<fail>
+<pre class="programlisting">on_error<fail>
(
 xml
 , std::cout
@@ -2759,7 +2659,7 @@
</tbody>
</table></div>
<a name="spirit.qi_and_karma.tutorials.mini_xml___error_handling.expectation_points"></a><h5>
-<a name="id642260"></a>
+<a name="id482635"></a>
 <a href="qi_and_karma.html#spirit.qi_and_karma.tutorials.mini_xml___error_handling.expectation_points">Expectation
 Points</a>
 </h5>
@@ -2767,8 +2667,7 @@
 You might not have noticed it, but some of our expressions changed from
 using the <tt class="computeroutput">>></tt> to <tt class="computeroutput">></tt>. Look, for example:
 
-<pre class="programlisting">
-end_tag =
+<pre class="programlisting">end_tag =
 "</"
 > lit(_r1)
 > '>'
@@ -2791,14 +2690,12 @@
 You can find some examples in: ../../example/qi/mini_xml_samples
 for testing purposes. "4.toyxml" has an error in it:
 
-<pre class="programlisting">
-<foo><bar></foo></bar>
+<pre class="programlisting"><foo><bar></foo></bar>
</pre>

 Running the example with this gives you:
 
-<pre class="programlisting">
-Error! Expecting "bar" here: "foo></bar>"
+<pre class="programlisting">Error! Expecting "bar" here: "foo></bar>"
Error! Expecting end_tag here: "<bar></foo></bar>"
-------------------------
Parsing failed

Modified: trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/mini_xml___error_handling.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/mini_xml___error_handling.html (original)
+++ trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/mini_xml___error_handling.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -47,8 +47,7 @@



-<pre class="programlisting">
-template <typename Iterator>
+<pre class="programlisting">template <typename Iterator>
struct mini_xml_grammar
 : grammar<Iterator, mini_xml(), locals<std::string>, space_type>
{
@@ -111,28 +110,26 @@
 What's new?
 
<a name="spirit.qi_and_karma.abstracts.mini_xml___error_handling.readable_names"></a><h5>
-<a name="id644389"></a>
+<a name="id484998"></a>
 <a href="mini_xml___error_handling.html#spirit.qi_and_karma.abstracts.mini_xml___error_handling.readable_names">Readable
 Names</a>
 </h5>

 First, when we call the base class, we give the grammar a name:
 
-<pre class="programlisting">
-: mini_xml_grammar::base_type(xml, "xml")
+<pre class="programlisting">: mini_xml_grammar::base_type(xml, "xml")
</pre>

 Then, we name all our rules:
 
-<pre class="programlisting">
-xml.name("xml");
+<pre class="programlisting">xml.name("xml");
node.name("node");
text.name("text");
start_tag.name("start_tag");
end_tag.name("end_tag");
</pre>
<a name="spirit.qi_and_karma.abstracts.mini_xml___error_handling.on_error"></a><h5>
-<a name="id644569"></a>
+<a name="id485249"></a>
 <a href="mini_xml___error_handling.html#spirit.qi_and_karma.abstracts.mini_xml___error_handling.on_error">On
 Error</a>
 </h5>
@@ -140,15 +137,13 @@
 <tt class="computeroutput">on_error</tt> declares our error
 handler:
 
-<pre class="programlisting">
-on_error<Action>(rule, handler)
+<pre class="programlisting">on_error<Action>(rule, handler)
</pre>

 This will specify what we will do when we get an error. We will print out
 an error message using phoenix:
 
-<pre class="programlisting">
-on_error<fail>
+<pre class="programlisting">on_error<fail>
(
 xml
 , std::cout
@@ -312,7 +307,7 @@
</tbody>
</table></div>
<a name="spirit.qi_and_karma.abstracts.mini_xml___error_handling.expectation_points"></a><h5>
-<a name="id645080"></a>
+<a name="id485914"></a>
 <a href="mini_xml___error_handling.html#spirit.qi_and_karma.abstracts.mini_xml___error_handling.expectation_points">Expectation
 Points</a>
 </h5>
@@ -320,8 +315,7 @@
 You might not have noticed it, but some of our expressions changed from
 using the <tt class="computeroutput">>></tt> to <tt class="computeroutput">></tt>. Look, for example:
 
-<pre class="programlisting">
-end_tag =
+<pre class="programlisting">end_tag =
 "</"
 > lit(_r1)
 > '>'
@@ -344,14 +338,12 @@
 You can find some examples in: ../../example/qi/mini_xml_samples
 for testing purposes. "4.toyxml" has an error in it:
 
-<pre class="programlisting">
-<foo><bar></foo></bar>
+<pre class="programlisting"><foo><bar></foo></bar>
</pre>

 Running the example with this gives you:
 
-<pre class="programlisting">
-Error! Expecting "bar" here: "foo></bar>"
+<pre class="programlisting">Error! Expecting "bar" here: "foo></bar>"
Error! Expecting end_tag here: "<bar></foo></bar>"
-------------------------
Parsing failed

Modified: trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing.html (original)
+++ trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -56,27 +56,27 @@
 main reason for Spirit's extensibility.
 
<a name="spirit.qi_and_karma.abstracts.parsing.the_api_functions_exposed_by__emphasis_spirit_qi__emphasis__"></a><h5>
-<a name="id643120"></a>
+<a name="id483114"></a>
 <a href="parsing.html#spirit.qi_and_karma.abstracts.parsing.the_api_functions_exposed_by__emphasis_spirit_qi__emphasis__">The
 API functions exposed by Spirit.Qi </a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing.the_parse___function"></a><h5>
-<a name="id643140"></a>
+<a name="id483146"></a>
 <a href="parsing.html#spirit.qi_and_karma.abstracts.parsing.the_parse___function">The
 parse() function</a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing.the_phrase_parse___function"></a><h5>
-<a name="id643157"></a>
+<a name="id483175"></a>
 <a href="parsing.html#spirit.qi_and_karma.abstracts.parsing.the_phrase_parse___function">The
 phrase_parse() function</a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing.the_tokenize_and_parse___function"></a><h5>
-<a name="id643170"></a>
+<a name="id483202"></a>
 <a href="parsing.html#spirit.qi_and_karma.abstracts.parsing.the_tokenize_and_parse___function">The
 tokenize_and_parse() function</a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing.the_tokenize_and_phrase_parse___function"></a><h5>
-<a name="id643183"></a>
+<a name="id483232"></a>
 <a href="parsing.html#spirit.qi_and_karma.abstracts.parsing.the_tokenize_and_phrase_parse___function">The
 tokenize_and_phrase_parse() function</a>
 </h5>

Modified: trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing_and_generating.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing_and_generating.html (original)
+++ trunk/libs/spirit/doc/html/spirit/qi_and_karma/abstracts/parsing_and_generating.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -29,27 +29,27 @@
 and Generating">Parsing
 and Generating</a></h4></div></div></div>
<a name="spirit.qi_and_karma.abstracts.parsing_and_generating.the_api_functions_exposed_by__emphasis_spirit_qi__emphasis__"></a><h5>
-<a name="id643207"></a>
+<a name="id483289"></a>
 <a href="parsing_and_generating.html#spirit.qi_and_karma.abstracts.parsing_and_generating.the_api_functions_exposed_by__emphasis_spirit_qi__emphasis__">The
 API functions exposed by Spirit.Qi </a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing_and_generating.the_parse___function"></a><h5>
-<a name="id643224"></a>
+<a name="id483324"></a>
 <a href="parsing_and_generating.html#spirit.qi_and_karma.abstracts.parsing_and_generating.the_parse___function">The
 parse() function</a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing_and_generating.the_phrase_parse___function"></a><h5>
-<a name="id643237"></a>
+<a name="id483355"></a>
 <a href="parsing_and_generating.html#spirit.qi_and_karma.abstracts.parsing_and_generating.the_phrase_parse___function">The
 phrase_parse() function</a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing_and_generating.the_tokenize_and_parse___function"></a><h5>
-<a name="id643250"></a>
+<a name="id483384"></a>
 <a href="parsing_and_generating.html#spirit.qi_and_karma.abstracts.parsing_and_generating.the_tokenize_and_parse___function">The
 tokenize_and_parse() function</a>
 </h5>
<a name="spirit.qi_and_karma.abstracts.parsing_and_generating.the_tokenize_and_phrase_parse___function"></a><h5>
-<a name="id643264"></a>
+<a name="id483415"></a>
 <a href="parsing_and_generating.html#spirit.qi_and_karma.abstracts.parsing_and_generating.the_tokenize_and_phrase_parse___function">The
 tokenize_and_phrase_parse() function</a>
 </h5>

Modified: trunk/libs/spirit/doc/html/spirit/qi_and_karma/quick_reference.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/qi_and_karma/quick_reference.html (original)
+++ trunk/libs/spirit/doc/html/spirit/qi_and_karma/quick_reference.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -46,7 +46,7 @@
</dl>
</div>
<div class="table">
-<a name="id647160"></a>Table 4. Character Parsers
+<a name="id486409"></a>Table 4. Character Parsers
<table class="table" summary="Character Parsers">
<colgroup>
<col>

Modified: trunk/libs/spirit/doc/html/spirit/qi_and_karma/reference.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/qi_and_karma/reference.html (original)
+++ trunk/libs/spirit/doc/html/spirit/qi_and_karma/reference.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -50,7 +50,7 @@
<div class="titlepage"><div><div><h5 class="title">
<a name="spirit.qi_and_karma.reference.concepts.parser"></a>Parser</h5></div></div></div>
<a name="spirit.qi_and_karma.reference.concepts.parser.description"></a><h6>
-<a name="id647891"></a>
+<a name="id487325"></a>
 <a href="reference.html#spirit.qi_and_karma.reference.concepts.parser.description">Description</a>
 </h6>

@@ -66,7 +66,7 @@
</dl>
</div>
<a name="spirit.qi_and_karma.reference.concepts.parser.valid_expressions"></a><h6>
-<a name="id647940"></a>
+<a name="id487386"></a>
 <a href="reference.html#spirit.qi_and_karma.reference.concepts.parser.valid_expressions">Valid
 Expressions</a>
 </h6>
@@ -126,7 +126,7 @@
</tr></tbody>
</table></div>
<a name="spirit.qi_and_karma.reference.concepts.parser.type_requirements"></a><h6>
-<a name="id648053"></a>
+<a name="id487523"></a>
 <a href="reference.html#spirit.qi_and_karma.reference.concepts.parser.type_requirements">Type
 Requirements</a>
 </h6>
@@ -161,14 +161,14 @@
</tr></tbody>
</table></div>
<a name="spirit.qi_and_karma.reference.concepts.parser.invariants"></a><h6>
-<a name="id648138"></a>
+<a name="id487627"></a>
 <a href="reference.html#spirit.qi_and_karma.reference.concepts.parser.invariants">Invariants</a>
 </h6>

 For any Parser xxx the following invariants always hold:
 
<a name="spirit.qi_and_karma.reference.concepts.parser.models"></a><h6>
-<a name="id648159"></a>
+<a name="id487659"></a>
 <a href="reference.html#spirit.qi_and_karma.reference.concepts.parser.models">Models</a>
 </h6>

Modified: trunk/libs/spirit/doc/html/spirit/what_s_new.html
==============================================================================
--- trunk/libs/spirit/doc/html/spirit/what_s_new.html (original)
+++ trunk/libs/spirit/doc/html/spirit/what_s_new.html 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -26,7 +26,7 @@
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="spirit.what_s_new"></a>What's New</h2></div></div></div>
<a name="spirit.what_s_new.spirit_classic"></a><h3>
-<a name="id616833"></a>
+<a name="id457100"></a>
 <a href="what_s_new.html#spirit.what_s_new.spirit_classic">Spirit Classic</a>
 </h3>

@@ -43,14 +43,12 @@
 from the directory $BOOST_ROOT/boost/spirit/include. All files of Spirit Classic in this directory have a 'classic_'
 prefixed to their name. For example the include
 
-<pre class="programlisting">
-#include <boost/spirit/core/core.hpp>
+<pre class="programlisting">#include <boost/spirit/core/core.hpp>
</pre>

 now should be written as:
 
-<pre class="programlisting">
-#include <boost/spirit/include/classic_core.hpp>
+<pre class="programlisting">#include <boost/spirit/include/classic_core.hpp>
</pre>

 To avoid namespace conflicts with the new Spirit V2 library we moved Spirit

Modified: trunk/libs/spirit/doc/introduction.qbk
==============================================================================
--- trunk/libs/spirit/doc/introduction.qbk (original)
+++ trunk/libs/spirit/doc/introduction.qbk 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -8,17 +8,17 @@

[section Introduction]

-Boost Spirit is an object oriented, recursive-descent parser and output generation
-library for C++. It allows to write grammars and format descriptions using a
-format very similar to EBNF (Extended Backus Naur Form, see [4]) directly in
+Boost Spirit is an object-oriented, recursive-descent parser and output generation
+library for C++. It allows you to write grammars and format descriptions using a
+format similar to EBNF (Extended Backus Naur Form, see [4]) directly in
C++. These inline grammar specifications can mix freely with other C++ code and,
thanks to the generative power of C++ templates, are immediately executable.
In retrospect, conventional compiler-compilers or parser-generators have to
perform an additional translation step from the source EBNF code to C or C++
code.

-The syntax and semantics of the libraries API directly form domain specific
-embedded languages (DSEL). In fact, Spirit exposes 3 different DSEL's to the
+The syntax and semantics of the libraries' API directly form domain-specific
+embedded languages (DSEL). In fact, Spirit exposes 3 different DSELs to the
user:

* one for creating parser grammars,
@@ -26,31 +26,31 @@
* and one for the description of the required output formats.

Since the target input grammars and output formats are written entirely in C++
-we do not need any separate tools to compile, preprocess, or integrate those
+we do not need any separate tools to compile, preprocess or integrate those
into the build process. __spirit__ allows seamless integration of the parsing
and output generation process with other C++ code. Often this allows for
simpler and more efficient code.

-Both, the created parsers and generators, are fully attributed which allows to
+Both the created parsers and generators are fully attributed which allows you to
easily build and handle hierarchical data structures in memory. These data
structures resemble the structure of the input data and can directly be used to
-generate arbitrarily formatted output.
+generate arbitrarily-formatted output.

The [link spirit.spiritstructure figure] below depicts the overall structure
-of the Boost Spirit library. The library consists out of 4 major parts:
+of the Boost Spirit library. The library consists of 4 major parts:

-* __classic__: This is the almost unchanged code base taken from the
+* __classic__: This is the almost-unchanged code base taken from the
 former Boost Spirit V1.8 distribution. It has been moved into the namespace
 boost::spirit::classic. A special compatibility layer has been added to
 ensure complete compatibility with existing code using Spirit V1.8.
-* __qi__: This is the parser library allowing to build recursive
- descent parsers. The exposed domain specific language can be used to describe
+* __qi__: This is the parser library allowing you to build recursive
+ descent parsers. The exposed domain-specific language can be used to describe
 the grammars to implement, and the rules for storing the parsed information.
-* __lex__: This is the library usable to create tokinizers (lexers). The domain
- specific language exposed by __lex__
-* __karma__: This is the generator library allowing to create code for
- recursive descent, data type driven output formatting. The exposed domain
- specific language is almost equivalent to the parser description language
+* __lex__: This is the library usable to create tokenizers (lexers). The
+ domain-specific language exposed by __lex__
+* __karma__: This is the generator library allowing you to create code for
+ recursive descent, data type-driven output formatting. The exposed
+ domain-specific language is almost equivalent to the parser description language
 used in __qi__, except that it is used to describe the required output
 format to generate from a given data structure.

@@ -67,13 +67,13 @@

The [link spirit.spiritkarmaflow figure] below shows the typical data flow of
some input being converted to some internal representation. After some
-(optional) transformation this data is converted back into some different,
-external representation. The picture highlights Spirit's the place in this data
+(optional) transformation these data are converted back into some different,
+external representation. The picture highlights Spirit's place in this data
transformation flow.

[fig ./images/spiritkarmaflow.png..The place of __qi__ and __karma__ in a data transformation flow of a typical application..spirit.spiritkarmaflow]

-[heading A quick overview about Parsing with __qi__]
+[heading A Quick Overview of Parsing with __qi__]

__qi__ is Spirit's sublibrary dealing with generating parsers based on a given
target grammar (essentially a format description of the input data to read).
@@ -94,12 +94,12 @@
 expression = term >> *(('+' >> term) | ('-' >> term));

Through the magic of expression templates, this is perfectly valid and
-executable C++ code. The production rule `expression` is in fact an object that
-has a member function parse that does the work given a source code written in
+executable C++ code. The production rule `expression` is, in fact, an object that
+has a member function `parse` that does the work given a source code written in
the grammar that we have just declared. Yes, it's a calculator. We shall
simplify for now by skipping the type declarations and the definition of the
-rule integer invoked by factor. Now, the production rule `expression` in our
-grammar specification, traditionally called the start symbol, can recognize
+rule `integer` invoked by `factor`. Now, the production rule `expression` in our
+grammar specification, traditionally called the `start` symbol, can recognize
inputs such as:

 12345
@@ -144,14 +144,14 @@
rule with the ubiquitous semi-colon, `;`.

-[heading A quick overview about Output Generation with __karma__]
+[heading A Quick Overview of Output Generation with __karma__]

-Spirit not only allows to describe the structure of the input. Starting with
+Spirit not only allows you to describe the structure of the input. Starting with
Version 2.0 it enables the specification of the output format for your data
-in a very similar way, and based on a single syntax and compatible semantics.
+in a similar way, and based on a single syntax and compatible semantics.

Let's assume we need to generate a textual representation from a simple data
-structure as a `std::vector<int>`. Conventional code probably would look like:
+structure such as a `std::vector<int>`. Conventional code probably would look like:

 std::vector<int> v (initialize_and_fill());
 std::vector<int>::iterator end = v.end();
@@ -159,10 +159,10 @@
 std::cout << *it << std::endl;

which is not very flexible and quite difficult to maintain when it comes to
-changing the required output format. Spirit's sublibrary /Karma/ allows to
+changing the required output format. Spirit's sublibrary /Karma/ allows you to
specify output formats for arbitrary data structures in a very flexible way.
-following snippet is the /Karma/ format description used to create the very
-The same output as the traditional code above:
+The following snippet is the /Karma/ format description used to create the
+same output as the traditional code above:

 *(int_ << eol)

@@ -177,13 +177,13 @@
 [ [`*(double_ << ',')`] [`1.0,8.0,10.0,`] [A list of floating point numbers] ]
]

-The syntax is very similar to /Qi/ with the exception that we use the `<<`
+The syntax is similar to /Qi/ with the exception that we use the `<<`
operator for output concatenation. This should be easy to understand as it
follows the conventions used in the Standard's I/O streams.

-Another important feature of /karma/ is to allow to fully decouple the data
+Another important feature of /karma/ allows you to fully decouple the data
type from the output format. You can use the same output format with different
-data types as long as these conforma conceptually. The next table gives some
+data types as long as these conform conceptually. The next table gives some
related examples.

[table Different data types usable with the output format `(*int_ << eol)`

Modified: trunk/libs/spirit/doc/reference_template.qbk
==============================================================================
--- trunk/libs/spirit/doc/reference_template.qbk (original)
+++ trunk/libs/spirit/doc/reference_template.qbk 2008-12-23 04:39:09 EST (Tue, 23 Dec 2008)
@@ -1,56 +1,56 @@
-[/==============================================================================
- Copyright (C) 2001-2008 Joel de Guzman
- Copyright (C) 2001-2008 Hartmut Kaiser
-
- Distributed under the Boost Software License, Version 1.0. (See accompanying
- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-===============================================================================/]
-
-[section XXX]
-
-[heading Description]
-
-Description of XXX
-
-[heading Header]
-
- #include <boost/spirit/xxx.hpp>
-
-[heading Synopsis]
-
- template <typename T>
- struct XXX;
-
-[heading Template parameters]
-
-[table
- [[Parameter] [Description] [Default]]
- [[`T`] [What is T] []]
-]
-
-[heading Model of]
-
-Link to concept
-
-[heading Objects]
-
-Objects provided by the library
-
-[variablelist Notation
- [[`xxx`] [An XXX]]
-]
-
-Semantics of an expression is defined only where it differs from, or is not
-defined in _concept-of_XXX_.
-
-[table
- [[Expression] [Semantics] [Return type] [Complexity]]
- [[`xxx`] [Semantics of `xxx`] [XXX] [Constant]]
-]
-
-[heading Example]
-
-Real example code. Use Quickbook import mechanism to link to actual
-working code snippets here.
-
-[endsect]
+[/==============================================================================
+ Copyright (C) 2001-2008 Joel de Guzman
+ Copyright (C) 2001-2008 Hartmut Kaiser
+
+ Distributed under the Boost Software License, Version 1.0. (See accompanying
+ file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+===============================================================================/]
+
+[section XXX]
+
+[heading Description]
+
+Description of XXX
+
+[heading Header]
+
+ #include <boost/spirit/xxx.hpp>
+
+[heading Synopsis]
+
+ template <typename T>
+ struct XXX;
+
+[heading Template parameters]
+
+[table
+ [[Parameter] [Description] [Default]]
+ [[`T`] [What is T] []]
+]
+
+[heading Model of]
+
+Link to concept
+
+[heading Objects]
+
+Objects provided by the library
+
+[variablelist Notation
+ [[`xxx`] [An XXX]]
+]
+
+Semantics of an expression is defined only where it differs from, or is not
+defined in _concept-of_XXX_.
+
+[table
+ [[Expression] [Semantics] [Return type] [Complexity]]
+ [[`xxx`] [Semantics of `xxx`] [XXX] [Constant]]
+]
+
+[heading Example]
+
+Real example code. Use Quickbook import mechanism to link to actual
+working code snippets here.
+
+[endsect]

Date view	Thread view	Subject view	Author view

Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk