Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r76644 - branches/quickbook-dev/tools/quickbook/src
From: dnljms_at_[hidden]
Date: 2012-01-22 18:06:59


Author: danieljames
Date: 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
New Revision: 76644
URL: http://svn.boost.org/trac/boost/changeset/76644

Log:
Quickbook: Rename `actions` to `state`.
Added:
   branches/quickbook-dev/tools/quickbook/src/state.cpp (contents, props changed)
      - copied, changed from r76643, /branches/quickbook-dev/tools/quickbook/src/actions_class.cpp
   branches/quickbook-dev/tools/quickbook/src/state.hpp (contents, props changed)
      - copied, changed from r76643, /branches/quickbook-dev/tools/quickbook/src/actions_class.hpp
   branches/quickbook-dev/tools/quickbook/src/state_save.hpp (contents, props changed)
      - copied, changed from r76643, /branches/quickbook-dev/tools/quickbook/src/actions_state.hpp
Removed:
   branches/quickbook-dev/tools/quickbook/src/actions_class.cpp
   branches/quickbook-dev/tools/quickbook/src/actions_class.hpp
   branches/quickbook-dev/tools/quickbook/src/actions_state.hpp
Text files modified:
   branches/quickbook-dev/tools/quickbook/src/Jamfile.v2 | 2
   branches/quickbook-dev/tools/quickbook/src/actions.cpp | 794 ++++++++++++++++++++--------------------
   branches/quickbook-dev/tools/quickbook/src/actions.hpp | 94 ++--
   branches/quickbook-dev/tools/quickbook/src/block_element_grammar.cpp | 34
   branches/quickbook-dev/tools/quickbook/src/code_snippet.cpp | 2
   branches/quickbook-dev/tools/quickbook/src/doc_info_actions.cpp | 106 ++--
   branches/quickbook-dev/tools/quickbook/src/doc_info_grammar.cpp | 36
   branches/quickbook-dev/tools/quickbook/src/fwd.hpp | 2
   branches/quickbook-dev/tools/quickbook/src/grammar.cpp | 8
   branches/quickbook-dev/tools/quickbook/src/grammar.hpp | 2
   branches/quickbook-dev/tools/quickbook/src/grammar_impl.hpp | 4
   branches/quickbook-dev/tools/quickbook/src/main_grammar.cpp | 150 +++---
   branches/quickbook-dev/tools/quickbook/src/phrase_element_grammar.cpp | 30
   branches/quickbook-dev/tools/quickbook/src/quickbook.cpp | 46 +-
   branches/quickbook-dev/tools/quickbook/src/quickbook.hpp | 2
   branches/quickbook-dev/tools/quickbook/src/state.cpp | 68 +-
   branches/quickbook-dev/tools/quickbook/src/state.hpp | 7
   branches/quickbook-dev/tools/quickbook/src/state_save.hpp | 10
   branches/quickbook-dev/tools/quickbook/src/syntax_highlight.cpp | 57 +-
   19 files changed, 724 insertions(+), 730 deletions(-)

Modified: branches/quickbook-dev/tools/quickbook/src/Jamfile.v2
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/Jamfile.v2 (original)
+++ branches/quickbook-dev/tools/quickbook/src/Jamfile.v2 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -24,7 +24,7 @@
     quickbook.cpp
     actions.cpp
     doc_info_actions.cpp
- actions_class.cpp
+ state.cpp
     utils.cpp
     files.cpp
     string_ref.cpp

Modified: branches/quickbook-dev/tools/quickbook/src/actions.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/actions.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -26,8 +26,8 @@
 #include "utils.hpp"
 #include "files.hpp"
 #include "markups.hpp"
-#include "actions_class.hpp"
-#include "actions_state.hpp"
+#include "state.hpp"
+#include "state_save.hpp"
 #include "grammar.hpp"
 #include "input_path.hpp"
 #include "block_tags.hpp"
@@ -38,21 +38,21 @@
 namespace quickbook
 {
     namespace {
- void write_anchors(quickbook::actions& actions, collector& tgt)
+ void write_anchors(quickbook::state& state, collector& tgt)
         {
             // TODO: This works but is a bit of an odd place to put it.
             // Might need to redefine the purpose of this function.
- if (!actions.source_mode_next.empty()) {
- detail::outwarn(actions.source_mode_next.get_file(),
- actions.source_mode_next.get_position())
+ if (!state.source_mode_next.empty()) {
+ detail::outwarn(state.source_mode_next.get_file(),
+ state.source_mode_next.get_position())
                     << "Temporary source mode unsupported here."
                     << std::endl;
- actions.source_mode_next = value();
+ state.source_mode_next = value();
             }
 
- for(quickbook::actions::string_list::iterator
- it = actions.anchors.begin(),
- end = actions.anchors.end();
+ for(quickbook::state::string_list::iterator
+ it = state.anchors.begin(),
+ end = state.anchors.end();
                 it != end; ++it)
             {
                 tgt << "<anchor id=\"";
@@ -60,16 +60,16 @@
                 tgt << "\"/>";
             }
             
- actions.anchors.clear();
+ state.anchors.clear();
         }
         
- std::string add_anchor(quickbook::actions& actions,
+ std::string add_anchor(quickbook::state& state,
                 std::string const& id,
                 id_category::categories category =
                     id_category::explicit_anchor_id)
         {
- std::string placeholder = actions.ids.add_anchor(id, category);
- actions.anchors.push_back(placeholder);
+ std::string placeholder = state.ids.add_anchor(id, category);
+ state.anchors.push_back(placeholder);
             return placeholder;
         }
     }
@@ -78,34 +78,34 @@
         return qbk_version_n >= min_ && qbk_version_n < max_;
     }
 
- void explicit_list_action(quickbook::actions&, value);
- void header_action(quickbook::actions&, value);
- void begin_section_action(quickbook::actions&, value);
- void end_section_action(quickbook::actions&, value, string_iterator);
- void block_action(quickbook::actions&, value);
- void block_empty_action(quickbook::actions&, value);
- void macro_definition_action(quickbook::actions&, value);
- void template_body_action(quickbook::actions&, value);
- void variable_list_action(quickbook::actions&, value);
- void table_action(quickbook::actions&, value);
- void xinclude_action(quickbook::actions&, value);
- void include_action(quickbook::actions&, value, string_iterator);
- void image_action(quickbook::actions&, value);
- void anchor_action(quickbook::actions&, value);
- void link_action(quickbook::actions&, value);
- void phrase_action(quickbook::actions&, value);
- void role_action(quickbook::actions&, value);
- void footnote_action(quickbook::actions&, value);
- void raw_phrase_action(quickbook::actions&, value);
- void source_mode_action(quickbook::actions&, value);
- void next_source_mode_action(quickbook::actions&, value);
- void code_action(quickbook::actions&, value);
- void do_template_action(quickbook::actions&, value, string_iterator);
+ void explicit_list_action(quickbook::state&, value);
+ void header_action(quickbook::state&, value);
+ void begin_section_action(quickbook::state&, value);
+ void end_section_action(quickbook::state&, value, string_iterator);
+ void block_action(quickbook::state&, value);
+ void block_empty_action(quickbook::state&, value);
+ void macro_definition_action(quickbook::state&, value);
+ void template_body_action(quickbook::state&, value);
+ void variable_list_action(quickbook::state&, value);
+ void table_action(quickbook::state&, value);
+ void xinclude_action(quickbook::state&, value);
+ void include_action(quickbook::state&, value, string_iterator);
+ void image_action(quickbook::state&, value);
+ void anchor_action(quickbook::state&, value);
+ void link_action(quickbook::state&, value);
+ void phrase_action(quickbook::state&, value);
+ void role_action(quickbook::state&, value);
+ void footnote_action(quickbook::state&, value);
+ void raw_phrase_action(quickbook::state&, value);
+ void source_mode_action(quickbook::state&, value);
+ void next_source_mode_action(quickbook::state&, value);
+ void code_action(quickbook::state&, value);
+ void do_template_action(quickbook::state&, value, string_iterator);
     
     void element_action::operator()(parse_iterator first, parse_iterator) const
     {
- value_consumer values = actions.values.release();
- if(!values.check() || !actions.conditional) return;
+ value_consumer values = state.values.release();
+ if(!values.check() || !state.conditional) return;
         value v = values.consume();
         values.finish();
         
@@ -113,7 +113,7 @@
         {
         case block_tags::ordered_list:
         case block_tags::itemized_list:
- return explicit_list_action(actions, v);
+ return explicit_list_action(state, v);
         case block_tags::generic_heading:
         case block_tags::heading1:
         case block_tags::heading2:
@@ -121,11 +121,11 @@
         case block_tags::heading4:
         case block_tags::heading5:
         case block_tags::heading6:
- return header_action(actions, v);
+ return header_action(state, v);
         case block_tags::begin_section:
- return begin_section_action(actions, v);
+ return begin_section_action(state, v);
         case block_tags::end_section:
- return end_section_action(actions, v, first.base());
+ return end_section_action(state, v, first.base());
         case block_tags::blurb:
         case block_tags::preformatted:
         case block_tags::blockquote:
@@ -135,26 +135,26 @@
         case block_tags::note:
         case block_tags::tip:
         case block_tags::block:
- return block_action(actions,v);
+ return block_action(state,v);
         case block_tags::hr:
- return block_empty_action(actions,v);
+ return block_empty_action(state,v);
         case block_tags::macro_definition:
- return macro_definition_action(actions,v);
+ return macro_definition_action(state,v);
         case block_tags::template_definition:
- return template_body_action(actions,v);
+ return template_body_action(state,v);
         case block_tags::variable_list:
- return variable_list_action(actions, v);
+ return variable_list_action(state, v);
         case block_tags::table:
- return table_action(actions, v);
+ return table_action(state, v);
         case block_tags::xinclude:
- return xinclude_action(actions, v);
+ return xinclude_action(state, v);
         case block_tags::import:
         case block_tags::include:
- return include_action(actions, v, first.base());
+ return include_action(state, v, first.base());
         case phrase_tags::image:
- return image_action(actions, v);
+ return image_action(state, v);
         case phrase_tags::anchor:
- return anchor_action(actions, v);
+ return anchor_action(state, v);
         case phrase_tags::url:
         case phrase_tags::link:
         case phrase_tags::funcref:
@@ -165,7 +165,7 @@
         case phrase_tags::headerref:
         case phrase_tags::conceptref:
         case phrase_tags::globalref:
- return link_action(actions, v);
+ return link_action(state, v);
         case phrase_tags::bold:
         case phrase_tags::italic:
         case phrase_tags::underline:
@@ -173,25 +173,25 @@
         case phrase_tags::strikethrough:
         case phrase_tags::quote:
         case phrase_tags::replaceable:
- return phrase_action(actions, v);
+ return phrase_action(state, v);
         case phrase_tags::footnote:
- return footnote_action(actions, v);
+ return footnote_action(state, v);
         case phrase_tags::escape:
- return raw_phrase_action(actions, v);
+ return raw_phrase_action(state, v);
         case phrase_tags::role:
- return role_action(actions, v);
+ return role_action(state, v);
         case source_mode_tags::cpp:
         case source_mode_tags::python:
         case source_mode_tags::teletype:
- return source_mode_action(actions, v);
+ return source_mode_action(state, v);
         case code_tags::next_source_mode:
- return next_source_mode_action(actions, v);
+ return next_source_mode_action(state, v);
         case code_tags::code_block:
         case code_tags::inline_code_block:
         case code_tags::inline_code:
- return code_action(actions, v);
+ return code_action(state, v);
         case template_tags::template_:
- return do_template_action(actions, v, first.base());
+ return do_template_action(state, v, first.base());
         default:
             break;
         }
@@ -199,22 +199,22 @@
 
     void break_action::operator()(parse_iterator first, parse_iterator) const
     {
- write_anchors(actions, phrase);
+ write_anchors(state, phrase);
 
         if(*first == '\\')
         {
- detail::outwarn(actions.current_file, first.base())
+ detail::outwarn(state.current_file, first.base())
                 //<< "in column:" << pos.column << ", "
                 << "'\\n' is deprecated, pleases use '[br]' instead" << ".\n";
         }
 
- if(!actions.warned_about_breaks)
+ if(!state.warned_about_breaks)
         {
- detail::outwarn(actions.current_file, first.base())
+ detail::outwarn(state.current_file, first.base())
                 << "line breaks generate invalid boostbook "
                    "(will only note first occurrence).\n";
 
- actions.warned_about_breaks = true;
+ state.warned_about_breaks = true;
         }
             
         phrase << detail::get_markup(phrase_tags::break_mark).pre;
@@ -222,7 +222,7 @@
 
     void error_message_action::operator()(parse_iterator first, parse_iterator last) const
     {
- file_position const pos = actions.current_file->position_of(first.base());
+ file_position const pos = state.current_file->position_of(first.base());
 
         std::string value(first, last);
         std::string formatted_message = message;
@@ -230,91 +230,91 @@
         boost::replace_all(formatted_message, "%c",
             boost::lexical_cast<std::string>(pos.column));
 
- detail::outerr(actions.current_file->path, pos.line)
+ detail::outerr(state.current_file->path, pos.line)
             << detail::utf8(formatted_message) << std::endl;
- ++actions.error_count;
+ ++state.error_count;
     }
 
     void error_action::operator()(parse_iterator first, parse_iterator /*last*/) const
     {
- file_position const pos = actions.current_file->position_of(first.base());
+ file_position const pos = state.current_file->position_of(first.base());
 
- detail::outerr(actions.current_file->path, pos.line)
+ detail::outerr(state.current_file->path, pos.line)
             << "Syntax Error near column " << pos.column << ".\n";
- ++actions.error_count;
+ ++state.error_count;
     }
 
- void block_action(quickbook::actions& actions, value block)
+ void block_action(quickbook::state& state, value block)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         detail::markup markup = detail::get_markup(block.get_tag());
 
         value_consumer values = block;
- actions.out << markup.pre << values.consume().get_encoded() << markup.post;
+ state.out << markup.pre << values.consume().get_encoded() << markup.post;
         values.finish();
     }
 
- void block_empty_action(quickbook::actions& actions, value block)
+ void block_empty_action(quickbook::state& state, value block)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         detail::markup markup = detail::get_markup(block.get_tag());
- actions.out << markup.pre;
+ state.out << markup.pre;
     }
 
- void phrase_action(quickbook::actions& actions, value phrase)
+ void phrase_action(quickbook::state& state, value phrase)
     {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
 
         detail::markup markup = detail::get_markup(phrase.get_tag());
 
         value_consumer values = phrase;
- actions.phrase << markup.pre << values.consume().get_encoded() << markup.post;
+ state.phrase << markup.pre << values.consume().get_encoded() << markup.post;
         values.finish();
     }
 
- void role_action(quickbook::actions& actions, value role)
+ void role_action(quickbook::state& state, value role)
     {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
 
         value_consumer values = role;
- actions.phrase
+ state.phrase
             << "<phrase role=\"";
- detail::print_string(values.consume().get_quickbook(), actions.phrase.get());
- actions.phrase
+ detail::print_string(values.consume().get_quickbook(), state.phrase.get());
+ state.phrase
             << "\">"
             << values.consume().get_encoded()
             << "</phrase>";
         values.finish();
     }
 
- void footnote_action(quickbook::actions& actions, value phrase)
+ void footnote_action(quickbook::state& state, value phrase)
     {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
 
         value_consumer values = phrase;
- actions.phrase
+ state.phrase
             << "<footnote id=\""
- << actions.ids.add_id("f", id_category::numbered)
+ << state.ids.add_id("f", id_category::numbered)
             << "\"><para>"
             << values.consume().get_encoded()
             << "</para></footnote>";
         values.finish();
     }
 
- void raw_phrase_action(quickbook::actions& actions, value phrase)
+ void raw_phrase_action(quickbook::state& state, value phrase)
     {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
 
         detail::markup markup = detail::get_markup(phrase.get_tag());
- actions.phrase << markup.pre << phrase.get_quickbook() << markup.post;
+ state.phrase << markup.pre << phrase.get_quickbook() << markup.post;
     }
 
     void paragraph_action::operator()() const
     {
         std::string str;
- actions.phrase.swap(str);
+ state.phrase.swap(str);
 
         std::string::const_iterator
             pos = str.begin(),
@@ -324,53 +324,53 @@
 
         if(pos != end) {
             detail::markup markup = detail::get_markup(block_tags::paragraph);
- actions.out << markup.pre << str;
- write_anchors(actions, actions.out);
- actions.out << markup.post;
+ state.out << markup.pre << str;
+ write_anchors(state, state.out);
+ state.out << markup.post;
         }
     }
 
     void list_item_action::operator()() const
     {
         std::string str;
- actions.phrase.swap(str);
- actions.out << str;
- write_anchors(actions, actions.out);
+ state.phrase.swap(str);
+ state.out << str;
+ write_anchors(state, state.out);
     }
 
     void phrase_end_action::operator()() const
     {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
     }
     
     namespace {
- void write_bridgehead(quickbook::actions& actions, int level,
+ void write_bridgehead(quickbook::state& state, int level,
             std::string const& str, std::string const& id, bool self_link)
         {
             if (self_link && !id.empty())
             {
- actions.out << "<bridgehead renderas=\"sect" << level << "\"";
- actions.out << " id=\"";
- actions.out << actions.ids.add_id("h", id_category::numbered);
- actions.out << "\">";
- actions.out << "<phrase id=\"" << id << "\"/>";
- actions.out << "<link linkend=\"" << id << "\">";
- actions.out << str;
- actions.out << "</link>";
- actions.out << "</bridgehead>";
+ state.out << "<bridgehead renderas=\"sect" << level << "\"";
+ state.out << " id=\"";
+ state.out << state.ids.add_id("h", id_category::numbered);
+ state.out << "\">";
+ state.out << "<phrase id=\"" << id << "\"/>";
+ state.out << "<link linkend=\"" << id << "\">";
+ state.out << str;
+ state.out << "</link>";
+ state.out << "</bridgehead>";
             }
             else
             {
- actions.out << "<bridgehead renderas=\"sect" << level << "\"";
- if(!id.empty()) actions.out << " id=\"" << id << "\"";
- actions.out << ">";
- actions.out << str;
- actions.out << "</bridgehead>";
+ state.out << "<bridgehead renderas=\"sect" << level << "\"";
+ if(!id.empty()) state.out << " id=\"" << id << "\"";
+ state.out << ">";
+ state.out << str;
+ state.out << "</bridgehead>";
             }
         }
     }
 
- void header_action(quickbook::actions& actions, value heading_list)
+ void header_action(quickbook::state& state, value heading_list)
     {
         value_consumer values = heading_list;
 
@@ -383,7 +383,7 @@
 
         if (generic)
         {
- level = actions.ids.section_level() + 1;
+ level = state.ids.section_level() + 1;
                                             // We need to use a heading which is one greater
                                             // than the current.
             if (level > 6 ) // The max is h6, clip it if it goes
@@ -394,51 +394,51 @@
             level = heading_list.get_tag() - block_tags::heading1 + 1;
         }
 
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         if (!element_id.empty())
         {
- std::string anchor = actions.ids.add_id(
+ std::string anchor = state.ids.add_id(
                 element_id.get_quickbook(),
                 id_category::explicit_id);
 
- write_bridgehead(actions, level,
+ write_bridgehead(state, level,
                 content.get_encoded(), anchor, self_linked_headers);
         }
- else if (!generic && actions.ids.compatibility_version() < 103) // version 1.2 and below
+ else if (!generic && state.ids.compatibility_version() < 103) // version 1.2 and below
         {
             // This generates the old id style if both the interpreting
             // version and the generation version are less then 103u.
 
- std::string anchor = actions.ids.old_style_id(
+ std::string anchor = state.ids.old_style_id(
                 detail::make_identifier(
- actions.ids.replace_placeholders_with_unresolved_ids(
+ state.ids.replace_placeholders_with_unresolved_ids(
                         content.get_encoded())),
                 id_category::generated_heading);
 
- write_bridgehead(actions, level,
+ write_bridgehead(state, level,
                 content.get_encoded(), anchor, false);
 
         }
         else
         {
- std::string anchor = actions.ids.add_id(
+ std::string anchor = state.ids.add_id(
                 detail::make_identifier(
- actions.ids.compatibility_version() >= 106 ?
+ state.ids.compatibility_version() >= 106 ?
                         content.get_quickbook() :
- actions.ids.replace_placeholders_with_unresolved_ids(
+ state.ids.replace_placeholders_with_unresolved_ids(
                             content.get_encoded())
                 ),
                 id_category::generated_heading);
 
- write_bridgehead(actions, level,
+ write_bridgehead(state, level,
                 content.get_encoded(), anchor, self_linked_headers);
         }
     }
 
     void simple_phrase_action::operator()(char mark) const
     {
- write_anchors(actions, out);
+ write_anchors(state, out);
 
         int tag =
             mark == '*' ? phrase_tags::bold :
@@ -450,7 +450,7 @@
         assert(tag != 0);
         detail::markup markup = detail::get_markup(tag);
 
- value_consumer values = actions.values.release();
+ value_consumer values = state.values.release();
         value content = values.consume();
         values.finish();
 
@@ -461,21 +461,21 @@
 
     bool cond_phrase_push::start()
     {
- value_consumer values = actions.values.release();
+ value_consumer values = state.values.release();
 
- saved_conditional = actions.conditional;
+ saved_conditional = state.conditional;
 
         if (saved_conditional)
         {
             string_ref macro1 = values.consume().get_quickbook();
             std::string macro(macro1.begin(), macro1.end());
 
- actions.conditional = find(actions.macro, macro.c_str());
+ state.conditional = find(state.macro, macro.c_str());
 
- if (!actions.conditional) {
- actions.phrase.push();
- actions.out.push();
- actions.anchors.swap(anchors);
+ if (!state.conditional) {
+ state.phrase.push();
+ state.out.push();
+ state.anchors.swap(anchors);
             }
         }
 
@@ -484,14 +484,14 @@
     
     void cond_phrase_push::cleanup()
     {
- if (saved_conditional && !actions.conditional)
+ if (saved_conditional && !state.conditional)
         {
- actions.phrase.pop();
- actions.out.pop();
- actions.anchors.swap(anchors);
+ state.phrase.pop();
+ state.out.pop();
+ state.anchors.swap(anchors);
         }
 
- actions.conditional = saved_conditional;
+ state.conditional = saved_conditional;
     }
 
     namespace {
@@ -513,27 +513,27 @@
         }
     }
 
- void actions::start_list(char mark)
+ void state::start_list(char mark)
     {
         write_anchors(*this, out);
         assert(mark == '*' || mark == '#');
         out << ((mark == '#') ? "<orderedlist>\n" : "<itemizedlist>\n");
     }
 
- void actions::end_list(char mark)
+ void state::end_list(char mark)
     {
         write_anchors(*this, out);
         assert(mark == '*' || mark == '#');
         out << ((mark == '#') ? "\n</orderedlist>" : "\n</itemizedlist>");
     }
 
- void actions::start_list_item()
+ void state::start_list_item()
     {
         out << "<listitem><simpara>";
         write_anchors(*this, out);
     }
 
- void actions::end_list_item()
+ void state::end_list_item()
     {
         write_anchors(*this, out);
         out << "</simpara></listitem>";
@@ -541,15 +541,15 @@
 
     namespace
     {
- bool parse_template(value const&, quickbook::actions& actions);
+ bool parse_template(value const&, quickbook::state& state);
     }
 
- void actions::start_callouts()
+ void state::start_callouts()
     {
         ++callout_depth;
     }
 
- std::string actions::add_callout(value v)
+ std::string state::add_callout(value v)
     {
         std::string callout_id1 = ids.add_id("c", id_category::numbered);
         std::string callout_id2 = ids.add_id("c", id_category::numbered);
@@ -565,7 +565,7 @@
         return code;
     }
 
- std::string actions::end_callouts()
+ std::string state::end_callouts()
     {
         assert(callout_depth > 0);
         std::string block;
@@ -616,38 +616,38 @@
         return block;
     }
 
- void explicit_list_action(quickbook::actions& actions, value list)
+ void explicit_list_action(quickbook::state& state, value list)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         detail::markup markup = detail::get_markup(list.get_tag());
 
- actions.out << markup.pre;
+ state.out << markup.pre;
 
         BOOST_FOREACH(value item, list)
         {
- actions.out << "<listitem>";
- actions.out << item.get_encoded();
- actions.out << "</listitem>";
+ state.out << "<listitem>";
+ state.out << item.get_encoded();
+ state.out << "</listitem>";
         }
 
- actions.out << markup.post;
+ state.out << markup.post;
     }
 
- void anchor_action(quickbook::actions& actions, value anchor)
+ void anchor_action(quickbook::state& state, value anchor)
     {
         value_consumer values = anchor;
         value anchor_id = values.consume();
         // Note: anchor_id is never encoded as boostbook. If it
         // is encoded, it's just things like escapes.
- add_anchor(actions, anchor_id.is_encoded() ?
+ add_anchor(state, anchor_id.is_encoded() ?
             anchor_id.get_encoded() : anchor_id.get_quickbook());
         values.finish();
     }
 
     void do_macro_action::operator()(std::string const& str) const
     {
- write_anchors(actions, phrase);
+ write_anchors(state, phrase);
 
         if (str == quickbook_get_date)
         {
@@ -678,19 +678,19 @@
             out << *first++;
     }
 
- void source_mode_action(quickbook::actions& actions, value source_mode)
+ void source_mode_action(quickbook::state& state, value source_mode)
     {
- actions.source_mode = source_mode_tags::name(source_mode.get_tag());
+ state.source_mode = source_mode_tags::name(source_mode.get_tag());
     }
 
- void next_source_mode_action(quickbook::actions& actions, value source_mode)
+ void next_source_mode_action(quickbook::state& state, value source_mode)
     {
         value_consumer values = source_mode;
- actions.source_mode_next = values.consume();
+ state.source_mode_next = values.consume();
         values.finish();
     }
 
- void code_action(quickbook::actions& actions, value code_block)
+ void code_action(quickbook::state& state, value code_block)
     {
         int code_tag = code_block.get_tag();
 
@@ -702,23 +702,23 @@
             (code_tag == code_tags::inline_code_block && qbk_version_n < 106u);
         bool block = code_tag != code_tags::inline_code;
 
- std::string source_mode = actions.source_mode_next.empty() ?
- actions.source_mode : actions.source_mode_next.get_quickbook();
- actions.source_mode_next = value();
+ std::string source_mode = state.source_mode_next.empty() ?
+ state.source_mode : state.source_mode_next.get_quickbook();
+ state.source_mode_next = value();
 
         if (inline_code) {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
         }
         else {
- paragraph_action para(actions);
+ paragraph_action para(state);
             para();
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
         }
 
         if (block) {
             // preprocess the code section to remove the initial indentation
             mapped_file_builder mapped;
- mapped.start(actions.current_file);
+ mapped.start(state.current_file);
             mapped.unindent_and_add(code_value.begin(), code_value.end());
 
             file_ptr f = mapped.release();
@@ -726,21 +726,21 @@
             if (f->source.empty())
                 return; // Nothing left to do here. The program is empty.
 
- if (qbk_version_n >= 107u) actions.start_callouts();
+ if (qbk_version_n >= 107u) state.start_callouts();
 
             parse_iterator first_(f->source.begin());
             parse_iterator last_(f->source.end());
 
             file_ptr saved_file = f;
- boost::swap(actions.current_file, saved_file);
+ boost::swap(state.current_file, saved_file);
 
             // print the code with syntax coloring
- std::string str = syntax_highlight(first_, last_, actions,
+ std::string str = syntax_highlight(first_, last_, state,
                 source_mode, block);
 
- boost::swap(actions.current_file, saved_file);
+ boost::swap(state.current_file, saved_file);
 
- collector& output = inline_code ? actions.phrase : actions.out;
+ collector& output = inline_code ? state.phrase : state.out;
 
             // We must not place a \n after the <programlisting> tag
             // otherwise PDF output starts code blocks with a blank line:
@@ -749,30 +749,30 @@
             output << str;
             output << "</programlisting>\n";
 
- if (qbk_version_n >= 107u) output << actions.end_callouts();
+ if (qbk_version_n >= 107u) output << state.end_callouts();
         }
         else {
             parse_iterator first_(code_value.begin());
             parse_iterator last_(code_value.end());
- std::string str = syntax_highlight(first_, last_, actions,
+ std::string str = syntax_highlight(first_, last_, state,
                 source_mode, block);
 
- actions.phrase << "<code>";
- actions.phrase << str;
- actions.phrase << "</code>";
+ state.phrase << "<code>";
+ state.phrase << str;
+ state.phrase << "</code>";
         }
     }
 
     void plain_char_action::operator()(char ch) const
     {
- write_anchors(actions, phrase);
+ write_anchors(state, phrase);
 
         detail::print_char(ch, phrase.get());
     }
 
     void plain_char_action::operator()(parse_iterator first, parse_iterator last) const
     {
- write_anchors(actions, phrase);
+ write_anchors(state, phrase);
 
         while (first != last)
             detail::print_char(*first++, phrase.get());
@@ -780,7 +780,7 @@
 
     void escape_unicode_action::operator()(parse_iterator first, parse_iterator last) const
     {
- write_anchors(actions, phrase);
+ write_anchors(state, phrase);
 
         while(first != last && *first == '0') ++first;
 
@@ -817,9 +817,9 @@
         }
     }
 
- void image_action(quickbook::actions& actions, value image)
+ void image_action(quickbook::state& state, value image)
     {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
 
         // Note: attributes are never encoded as boostbook, if they're
         // encoded, it's just things like escapes.
@@ -867,7 +867,7 @@
                 << detail::utf8(fileref)
                 << "'"
                 << std::endl;
- if (qbk_version_n >= 106u) ++actions.error_count;
+ if (qbk_version_n >= 106u) ++state.error_count;
         }
 
         boost::replace(fileref, '\\', '/');
@@ -969,31 +969,31 @@
            }
         }
 
- actions.phrase << "<inlinemediaobject>";
+ state.phrase << "<inlinemediaobject>";
 
- actions.phrase << "<imageobject><imagedata";
+ state.phrase << "<imageobject><imagedata";
         
         BOOST_FOREACH(attribute_map::value_type const& attr, attributes)
         {
- actions.phrase << " " << attr.first << "=\"";
- write_plain_text(actions.phrase.get(), attr.second);
- actions.phrase << "\"";
+ state.phrase << " " << attr.first << "=\"";
+ write_plain_text(state.phrase.get(), attr.second);
+ state.phrase << "\"";
         }
 
- actions.phrase << "></imagedata></imageobject>";
+ state.phrase << "></imagedata></imageobject>";
 
         // Add a textobject containing the alt tag from earlier.
         // This will be used for the alt tag in html.
         if (alt_text.check()) {
- actions.phrase << "<textobject><phrase>";
- write_plain_text(actions.phrase.get(), alt_text);
- actions.phrase << "</phrase></textobject>";
+ state.phrase << "<textobject><phrase>";
+ write_plain_text(state.phrase.get(), alt_text);
+ state.phrase << "</phrase></textobject>";
         }
 
- actions.phrase << "</inlinemediaobject>";
+ state.phrase << "</inlinemediaobject>";
     }
 
- void macro_definition_action(quickbook::actions& actions, quickbook::value macro_definition)
+ void macro_definition_action(quickbook::state& state, quickbook::value macro_definition)
     {
         value_consumer values = macro_definition;
         std::string macro_id = values.consume().get_quickbook();
@@ -1003,7 +1003,7 @@
         values.finish();
 
         std::string* existing_macro =
- boost::spirit::classic::find(actions.macro, macro_id.c_str());
+ boost::spirit::classic::find(state.macro, macro_id.c_str());
         quickbook::ignore_variable(&existing_macro);
 
         if (existing_macro)
@@ -1016,13 +1016,13 @@
             // return;
         }
 
- actions.macro.add(
+ state.macro.add(
             macro_id.begin()
           , macro_id.end()
           , phrase);
     }
 
- void template_body_action(quickbook::actions& actions, quickbook::value template_definition)
+ void template_body_action(quickbook::state& state, quickbook::value template_definition)
     {
         value_consumer values = template_definition;
         std::string identifier = values.consume().get_quickbook();
@@ -1036,16 +1036,16 @@
         value body = values.consume();
         BOOST_ASSERT(!values.check());
     
- if (!actions.templates.add(
+ if (!state.templates.add(
             template_symbol(
                 identifier,
                 template_values,
                 body,
- &actions.templates.top_scope())))
+ &state.templates.top_scope())))
         {
             detail::outwarn(body.get_file(), body.get_position())
                 << "Template Redefinition: " << detail::utf8(identifier) << std::endl;
- ++actions.error_count;
+ ++state.error_count;
         }
     }
 
@@ -1166,7 +1166,7 @@
           , std::vector<std::string> const& params
           , template_scope const& scope
           , string_iterator first
- , quickbook::actions& actions
+ , quickbook::state& state
         )
         {
             std::vector<value>::const_iterator arg = args.begin();
@@ -1176,12 +1176,12 @@
             // Store each of the argument passed in as local templates:
             while (arg != args.end())
             {
- if (!actions.templates.add(
+ if (!state.templates.add(
                         template_symbol(*tpl, empty_params, *arg, &scope)))
                 {
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                         << "Duplicate Symbol Found" << std::endl;
- ++actions.error_count;
+ ++state.error_count;
                     return std::make_pair(false, tpl);
                 }
                 ++arg; ++tpl;
@@ -1191,12 +1191,12 @@
         
         bool parse_template(
             value const& content
- , quickbook::actions& actions
+ , quickbook::state& state
         )
         {
- file_ptr saved_current_file = actions.current_file;
+ file_ptr saved_current_file = state.current_file;
 
- actions.current_file = content.get_file();
+ state.current_file = content.get_file();
             string_ref source = content.get_quickbook();
 
             parse_iterator first(source.begin());
@@ -1204,17 +1204,17 @@
 
             bool r = cl::parse(first, last,
                     content.get_tag() == template_tags::phrase ?
- actions.grammar().inline_phrase :
- actions.grammar().block
+ state.grammar().inline_phrase :
+ state.grammar().block
                 ).full;
 
- boost::swap(actions.current_file, saved_current_file);
+ boost::swap(state.current_file, saved_current_file);
 
             return r;
         }
     }
 
- void call_template(quickbook::actions& actions,
+ void call_template(quickbook::state& state,
             template_symbol const* symbol,
             std::vector<value> const& args,
             string_iterator first)
@@ -1228,13 +1228,13 @@
         {
             if (is_block)
             {
- paragraph_action para(actions);
+ paragraph_action para(state);
                 para();
- actions.out << symbol->content.get_encoded();
+ state.out << symbol->content.get_encoded();
             }
             else
             {
- actions.phrase << symbol->content.get_encoded();
+ state.phrase << symbol->content.get_encoded();
             }
 
             return;
@@ -1245,36 +1245,36 @@
         //
         // Note that for quickbook 1.4- this value is just ignored when the
         // arguments are expanded.
- template_scope const& call_scope = actions.templates.top_scope();
+ template_scope const& call_scope = state.templates.top_scope();
 
         std::string block;
         std::string phrase;
 
         {
- template_state state(actions);
- actions.templates.start_template(symbol);
+ template_state save(state);
+ state.templates.start_template(symbol);
 
             qbk_version_n = symbol->content.get_file()->version();
 
- ++actions.template_depth;
- if (actions.template_depth > actions.max_template_depth)
+ ++state.template_depth;
+ if (state.template_depth > state.max_template_depth)
             {
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                     << "Infinite loop detected" << std::endl;
- ++actions.error_count;
+ ++state.error_count;
                 return;
             }
 
             // Store the current section level so that we can ensure that
             // [section] and [endsect] tags in the template are balanced.
- actions.min_section_level = actions.ids.section_level();
+ state.min_section_level = state.ids.section_level();
 
             ///////////////////////////////////
             // Prepare the arguments as local templates
             bool get_arg_result;
             std::vector<std::string>::const_iterator tpl;
             boost::tie(get_arg_result, tpl) =
- get_arguments(args, symbol->params, call_scope, first, actions);
+ get_arguments(args, symbol->params, call_scope, first, state);
 
             if (!get_arg_result)
             {
@@ -1284,9 +1284,9 @@
             ///////////////////////////////////
             // parse the template body:
 
- if (!parse_template(symbol->content, actions))
+ if (!parse_template(symbol->content, state))
             {
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                     << "Expanding "
                     << (is_block ? "block" : "phrase")
                     << " template: " << detail::utf8(symbol->identifier) << std::endl
@@ -1295,37 +1295,37 @@
                     << detail::utf8(symbol->content.get_quickbook())
                     << "------------------end--------------------" << std::endl
                     << std::endl;
- ++actions.error_count;
+ ++state.error_count;
                 return;
             }
 
- if (actions.ids.section_level() != actions.min_section_level)
+ if (state.ids.section_level() != state.min_section_level)
             {
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                     << "Mismatched sections in template "
                     << detail::utf8(symbol->identifier)
                     << std::endl;
- ++actions.error_count;
+ ++state.error_count;
                 return;
             }
 
- actions.out.swap(block);
- actions.phrase.swap(phrase);
+ state.out.swap(block);
+ state.phrase.swap(phrase);
         }
 
         if(is_block || !block.empty()) {
- paragraph_action para(actions);
+ paragraph_action para(state);
             para(); // For paragraphs before the template call.
- actions.out << block;
- actions.phrase << phrase;
+ state.out << block;
+ state.phrase << phrase;
             para();
         }
         else {
- actions.phrase << phrase;
+ state.phrase << phrase;
         }
     }
 
- void call_code_snippet(quickbook::actions& actions,
+ void call_code_snippet(quickbook::state& state,
             template_symbol const* symbol,
             string_iterator first)
     {
@@ -1339,12 +1339,12 @@
             symbol->content,
             symbol->lexical_parent);
 
- actions.start_callouts();
- call_template(actions, &t, args, first);
- actions.out << actions.end_callouts();
+ state.start_callouts();
+ call_template(state, &t, args, first);
+ state.out << state.end_callouts();
     }
 
- void do_template_action(quickbook::actions& actions, value template_list,
+ void do_template_action(quickbook::state& state, value template_list,
             string_iterator first)
     {
         // Get the arguments
@@ -1364,7 +1364,7 @@
         
         values.finish();
 
- template_symbol const* symbol = actions.templates.find(identifier);
+ template_symbol const* symbol = state.templates.find(identifier);
         BOOST_ASSERT(symbol);
 
         // Deal with escaped templates.
@@ -1373,19 +1373,19 @@
         {
             if (!args.empty())
             {
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                     << "Arguments for escaped template."
                     <<std::endl;
- ++actions.error_count;
+ ++state.error_count;
             }
 
             if (symbol->content.is_encoded())
             {
- actions.phrase << symbol->content.get_encoded();
+ state.phrase << symbol->content.get_encoded();
             }
             else
             {
- actions.phrase << symbol->content.get_quickbook();
+ state.phrase << symbol->content.get_quickbook();
 
                 /*
 
@@ -1397,7 +1397,7 @@
                 quickbook::detail::markup escape_markup
                     = detail::get_markup(phrase_tags::escape);
 
- actions.phrase
+ state.phrase
                     << escape_markup.pre
                     << symbol->content.get_quickbook()
                     << escape_markup.post
@@ -1417,11 +1417,11 @@
         case template_tags::phrase:
             // Break the arguments for a template
 
- break_arguments(args, symbol->params, actions.current_file->path);
+ break_arguments(args, symbol->params, state.current_file->path);
 
             if (args.size() != symbol->params.size())
             {
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                     << "Invalid number of arguments passed. Expecting: "
                     << symbol->params.size()
                     << " argument(s), got: "
@@ -1429,26 +1429,26 @@
                     << " argument(s) instead."
                     << std::endl;
 
- ++actions.error_count;
+ ++state.error_count;
                 return;
             }
 
- call_template(actions, symbol, args, first);
+ call_template(state, symbol, args, first);
             break;
 
         case template_tags::snippet:
 
             if (!args.empty())
             {
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                     << "Arguments for code snippet."
                     <<std::endl;
- ++actions.error_count;
+ ++state.error_count;
 
                 args.clear();
             }
 
- call_code_snippet(actions, symbol, first);
+ call_code_snippet(state, symbol, first);
             break;
 
         default:
@@ -1456,9 +1456,9 @@
         }
     }
 
- void link_action(quickbook::actions& actions, value link)
+ void link_action(quickbook::state& state, value link)
     {
- write_anchors(actions, actions.phrase);
+ write_anchors(state, state.phrase);
 
         detail::markup markup = detail::get_markup(link.get_tag());
 
@@ -1472,57 +1472,57 @@
         std::string dst = dst_value.is_encoded() ?
             dst_value.get_encoded() : dst_value.get_quickbook();
         
- actions.phrase << markup.pre;
- detail::print_string(dst, actions.phrase.get());
- actions.phrase << "\">";
+ state.phrase << markup.pre;
+ detail::print_string(dst, state.phrase.get());
+ state.phrase << "\">";
 
         if (content.empty())
- detail::print_string(dst, actions.phrase.get());
+ detail::print_string(dst, state.phrase.get());
         else
- actions.phrase << content.get_encoded();
+ state.phrase << content.get_encoded();
 
- actions.phrase << markup.post;
+ state.phrase << markup.post;
     }
 
- void variable_list_action(quickbook::actions& actions, value variable_list)
+ void variable_list_action(quickbook::state& state, value variable_list)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         value_consumer values = variable_list;
         std::string title = values.consume(table_tags::title).get_quickbook();
 
- actions.out << "<variablelist>\n";
+ state.out << "<variablelist>\n";
 
- actions.out << "<title>";
- detail::print_string(title, actions.out.get());
- actions.out << "</title>\n";
+ state.out << "<title>";
+ detail::print_string(title, state.out.get());
+ state.out << "</title>\n";
 
         BOOST_FOREACH(value_consumer entry, values) {
- actions.out << "<varlistentry>";
+ state.out << "<varlistentry>";
             
             if(entry.check()) {
- actions.out << "<term>";
- actions.out << entry.consume().get_encoded();
- actions.out << "</term>";
+ state.out << "<term>";
+ state.out << entry.consume().get_encoded();
+ state.out << "</term>";
             }
             
             if(entry.check()) {
- actions.out << "<listitem>";
- BOOST_FOREACH(value phrase, entry) actions.out << phrase.get_encoded();
- actions.out << "</listitem>";
+ state.out << "<listitem>";
+ BOOST_FOREACH(value phrase, entry) state.out << phrase.get_encoded();
+ state.out << "</listitem>";
             }
 
- actions.out << "</varlistentry>\n";
+ state.out << "</varlistentry>\n";
         }
 
- actions.out << "</variablelist>\n";
+ state.out << "</variablelist>\n";
         
         values.finish();
     }
 
- void table_action(quickbook::actions& actions, value table)
+ void table_action(quickbook::state& state, value table)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         value_consumer values = table;
 
@@ -1536,14 +1536,14 @@
         std::string table_id;
 
         if (!element_id.empty()) {
- table_id = actions.ids.add_id(element_id, id_category::explicit_id);
+ table_id = state.ids.add_id(element_id, id_category::explicit_id);
         }
         else if (has_title) {
- if (actions.ids.compatibility_version() >= 105) {
- table_id = actions.ids.add_id(detail::make_identifier(title.get_quickbook()), id_category::generated);
+ if (state.ids.compatibility_version() >= 105) {
+ table_id = state.ids.add_id(detail::make_identifier(title.get_quickbook()), id_category::generated);
             }
             else {
- table_id = actions.ids.add_id("t", id_category::numbered);
+ table_id = state.ids.add_id("t", id_category::numbered);
             }
         }
 
@@ -1561,64 +1561,64 @@
 
         if (has_title)
         {
- actions.out << "<table frame=\"all\"";
+ state.out << "<table frame=\"all\"";
             if(!table_id.empty())
- actions.out << " id=\"" << table_id << "\"";
- actions.out << ">\n";
- actions.out << "<title>";
+ state.out << " id=\"" << table_id << "\"";
+ state.out << ">\n";
+ state.out << "<title>";
             if (qbk_version_n < 106u) {
- detail::print_string(title.get_quickbook(), actions.out.get());
+ detail::print_string(title.get_quickbook(), state.out.get());
             }
             else {
- actions.out << title.get_encoded();
+ state.out << title.get_encoded();
             }
- actions.out << "</title>";
+ state.out << "</title>";
         }
         else
         {
- actions.out << "<informaltable frame=\"all\"";
+ state.out << "<informaltable frame=\"all\"";
             if(!table_id.empty())
- actions.out << " id=\"" << table_id << "\"";
- actions.out << ">\n";
+ state.out << " id=\"" << table_id << "\"";
+ state.out << ">\n";
         }
 
- actions.out << "<tgroup cols=\"" << span_count << "\">\n";
+ state.out << "<tgroup cols=\"" << span_count << "\">\n";
 
         if (row_count > 1)
         {
- actions.out << "<thead>" << "<row>";
+ state.out << "<thead>" << "<row>";
             BOOST_FOREACH(value cell, values.consume()) {
- actions.out << "<entry>" << cell.get_encoded() << "</entry>";
+ state.out << "<entry>" << cell.get_encoded() << "</entry>";
             }
- actions.out << "</row>\n" << "</thead>\n";
+ state.out << "</row>\n" << "</thead>\n";
         }
 
- actions.out << "<tbody>\n";
+ state.out << "<tbody>\n";
 
         BOOST_FOREACH(value row, values) {
- actions.out << "<row>";
+ state.out << "<row>";
             BOOST_FOREACH(value cell, row) {
- actions.out << "<entry>" << cell.get_encoded() << "</entry>";
+ state.out << "<entry>" << cell.get_encoded() << "</entry>";
             }
- actions.out << "</row>\n";
+ state.out << "</row>\n";
         }
         
         values.finish();
 
- actions.out << "</tbody>\n"
- << "</tgroup>\n";
+ state.out << "</tbody>\n"
+ << "</tgroup>\n";
 
         if (has_title)
         {
- actions.out << "</table>\n";
+ state.out << "</table>\n";
         }
         else
         {
- actions.out << "</informaltable>\n";
+ state.out << "</informaltable>\n";
         }
     }
 
- void begin_section_action(quickbook::actions& actions, value begin_section_list)
+ void begin_section_action(quickbook::state& state, value begin_section_list)
     {
         value_consumer values = begin_section_list;
 
@@ -1626,7 +1626,7 @@
         value content = values.consume();
         values.finish();
 
- std::string full_id = actions.ids.begin_section(
+ std::string full_id = state.ids.begin_section(
             !element_id.empty() ?
                 element_id.get_quickbook() :
                 detail::make_identifier(content.get_quickbook()),
@@ -1634,48 +1634,48 @@
                 id_category::explicit_section_id :
                 id_category::generated_section);
 
- actions.out << "\n<section id=\"" << full_id << "\">\n";
- actions.out << "<title>";
+ state.out << "\n<section id=\"" << full_id << "\">\n";
+ state.out << "<title>";
 
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
- if (self_linked_headers && actions.ids.compatibility_version() >= 103)
+ if (self_linked_headers && state.ids.compatibility_version() >= 103)
         {
- actions.out << "<link linkend=\"" << full_id << "\">"
+ state.out << "<link linkend=\"" << full_id << "\">"
                 << content.get_encoded()
                 << "</link>"
                 ;
         }
         else
         {
- actions.out << content.get_encoded();
+ state.out << content.get_encoded();
         }
         
- actions.out << "</title>\n";
+ state.out << "</title>\n";
     }
 
- void end_section_action(quickbook::actions& actions, value end_section, string_iterator first)
+ void end_section_action(quickbook::state& state, value end_section, string_iterator first)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
- if (actions.ids.section_level() <= actions.min_section_level)
+ if (state.ids.section_level() <= state.min_section_level)
         {
- file_position const pos = actions.current_file->position_of(first);
+ file_position const pos = state.current_file->position_of(first);
 
- detail::outerr(actions.current_file->path, pos.line)
+ detail::outerr(state.current_file->path, pos.line)
                 << "Mismatched [endsect] near column " << pos.column << ".\n";
- ++actions.error_count;
+ ++state.error_count;
             
             return;
         }
 
- actions.out << "</section>";
- actions.ids.end_section();
+ state.out << "</section>";
+ state.ids.end_section();
     }
     
     void element_id_warning_action::operator()(parse_iterator first, parse_iterator) const
     {
- detail::outwarn(actions.current_file, first.base()) << "Empty id.\n";
+ detail::outwarn(state.current_file, first.base()) << "Empty id.\n";
     }
 
     // Not a general purpose normalization function, just
@@ -1766,7 +1766,7 @@
         }
     };
 
- path_details check_path(value const& path, quickbook::actions& actions)
+ path_details check_path(value const& path, quickbook::state& state)
     {
         // Paths are encoded for quickbook 1.6+ and also xmlbase
         // values (technically xmlbase is a 1.6 feature, but that
@@ -1786,7 +1786,7 @@
 
             if (qbk_version_n >= 106u) {
                 err = &detail::outerr(path.get_file(), path.get_position());
- ++actions.error_count;
+ ++state.error_count;
             }
             else {
                 err = &detail::outwarn(path.get_file(), path.get_position());
@@ -1804,9 +1804,9 @@
             is_glob ? path_details::glob : path_details::path);
     }
 
- xinclude_path calculate_xinclude_path(value const& p, quickbook::actions& actions)
+ xinclude_path calculate_xinclude_path(value const& p, quickbook::state& state)
     {
- path_details details = check_path(p, actions);
+ path_details details = check_path(p, state);
 
         if (details.type == path_details::glob) {
             // TODO: Should know if this is an xinclude or an xmlbase.
@@ -1814,8 +1814,8 @@
             detail::outerr(p.get_file(), p.get_position())
                 << "Glob used in xinclude/xmlbase."
                 << std::endl;
- ++actions.error_count;
- return xinclude_path(actions.current_file->path.parent_path(), "");
+ ++state.error_count;
+ return xinclude_path(state.current_file->path.parent_path(), "");
         }
 
         fs::path path = detail::generic_to_path(details.value);
@@ -1825,26 +1825,26 @@
         if (!path.has_root_directory())
         {
             // Resolve the path from the current file
- full_path = actions.current_file->path.parent_path() / path;
+ full_path = state.current_file->path.parent_path() / path;
 
             // Then calculate relative to the current xinclude_base.
- path = path_difference(actions.xinclude_base, full_path);
+ path = path_difference(state.xinclude_base, full_path);
         }
 
         return xinclude_path(full_path, detail::escape_uri(detail::path_to_generic(path)));
     }
 
- void xinclude_action(quickbook::actions& actions, value xinclude)
+ void xinclude_action(quickbook::state& state, value xinclude)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         value_consumer values = xinclude;
- xinclude_path x = calculate_xinclude_path(values.consume(), actions);
+ xinclude_path x = calculate_xinclude_path(values.consume(), state);
         values.finish();
 
- actions.out << "\n<xi:include href=\"";
- detail::print_string(x.uri, actions.out.get());
- actions.out << "\" />\n";
+ state.out << "\n<xi:include href=\"";
+ detail::print_string(x.uri, state.out.get());
+ state.out << "\" />\n";
     }
 
     namespace
@@ -1882,7 +1882,7 @@
         #endif
 
         void include_search_glob(std::set<include_search_return> & result,
- fs::path dir, fs::path path, quickbook::actions const & actions)
+ fs::path dir, fs::path path, quickbook::state const & state)
         {
             // Split the glob into the current dir/glob/rest to search.
             fs::path glob;
@@ -1915,22 +1915,22 @@
                 {
                     result.insert(include_search_return(
                         dir/f,
- actions.filename_relative.parent_path()/dir/f
+ state.filename_relative.parent_path()/dir/f
                         ));
                 }
                 // If it's a matching dir, we recurse looking for more files.
                 else
                 {
- include_search_glob(result,dir,f/rest,actions);
+ include_search_glob(result,dir,f/rest,state);
                 }
             }
         }
 
         std::set<include_search_return> include_search(path_details const& details,
- quickbook::actions const& actions)
+ quickbook::state const& state)
         {
             std::set<include_search_return> result;
- fs::path current = actions.current_file->path.parent_path();
+ fs::path current = state.current_file->path.parent_path();
 
             // If the path has some glob match characters
             // we do a discovery of all the matches..
@@ -1939,11 +1939,11 @@
                 fs::path path(details.value);
 
                 // Search for the current dir accumulating to the result.
- include_search_glob(result,current,path,actions);
+ include_search_glob(result,current,path,state);
                 // Search the include path dirs accumulating to the result.
                 BOOST_FOREACH(fs::path dir, include_path)
                 {
- include_search_glob(result,dir,path,actions);
+ include_search_glob(result,dir,path,state);
                 }
                 // Done.
                 return result;
@@ -1960,7 +1960,7 @@
                     {
                         result.insert(include_search_return(
                             current / path,
- actions.filename_relative.parent_path() / path));
+ state.filename_relative.parent_path() / path));
                         return result;
                     }
 
@@ -1977,13 +1977,13 @@
                 }
 
                 result.insert(include_search_return(path,
- actions.filename_relative.parent_path() / path));
+ state.filename_relative.parent_path() / path));
                 return result;
             }
         }
     }
     
- void load_quickbook(quickbook::actions& actions,
+ void load_quickbook(quickbook::state& state,
             include_search_return const& paths,
             value::tag_type load_type,
             value const& include_doc_id = value())
@@ -2002,32 +2002,32 @@
             //
             // For old versions of quickbook, templates aren't scoped by the
             // file.
- file_state state(actions,
+ file_state save(state,
                 load_type == block_tags::import ? file_state::scope_output :
                 qbk_version_n >= 106u ? file_state::scope_callables :
                 file_state::scope_macros);
 
- actions.current_file = load(paths.filename); // Throws load_error
- actions.filename_relative = paths.filename_relative;
- actions.imported = (load_type == block_tags::import);
+ state.current_file = load(paths.filename); // Throws load_error
+ state.filename_relative = paths.filename_relative;
+ state.imported = (load_type == block_tags::import);
 
             // update the __FILENAME__ macro
- *boost::spirit::classic::find(actions.macro, "__FILENAME__")
- = detail::path_to_generic(actions.filename_relative);
+ *boost::spirit::classic::find(state.macro, "__FILENAME__")
+ = detail::path_to_generic(state.filename_relative);
         
             // parse the file
- quickbook::parse_file(actions, include_doc_id, true);
+ quickbook::parse_file(state, include_doc_id, true);
 
             // Don't restore source_mode on older versions.
- if (keep_inner_source_mode) state.source_mode = actions.source_mode;
+ if (keep_inner_source_mode) save.source_mode = state.source_mode;
         }
 
         // restore the __FILENAME__ macro
- *boost::spirit::classic::find(actions.macro, "__FILENAME__")
- = detail::path_to_generic(actions.filename_relative);
+ *boost::spirit::classic::find(state.macro, "__FILENAME__")
+ = detail::path_to_generic(state.filename_relative);
     }
 
- void load_source_file(quickbook::actions& actions,
+ void load_source_file(quickbook::state& state,
             include_search_return const& paths,
             value::tag_type load_type,
             string_iterator first,
@@ -2039,12 +2039,12 @@
         std::string ext = paths.filename.extension().generic_string();
         std::vector<template_symbol> storage;
         // Throws load_error
- actions.error_count +=
+ state.error_count +=
             load_snippets(paths.filename, storage, ext, load_type);
 
         if (load_type == block_tags::include)
         {
- actions.templates.push();
+ state.templates.push();
         }
 
         BOOST_FOREACH(template_symbol& ts, storage)
@@ -2052,12 +2052,12 @@
             std::string tname = ts.identifier;
             if (tname != "!")
             {
- ts.lexical_parent = &actions.templates.top_scope();
- if (!actions.templates.add(ts))
+ ts.lexical_parent = &state.templates.top_scope();
+ if (!state.templates.add(ts))
                 {
                     detail::outerr(ts.content.get_file(), ts.content.get_position())
                         << "Template Redefinition: " << detail::utf8(tname) << std::endl;
- ++actions.error_count;
+ ++state.error_count;
                 }
             }
         }
@@ -2070,25 +2070,25 @@
 
                 if (tname == "!")
                 {
- ts.lexical_parent = &actions.templates.top_scope();
- call_code_snippet(actions, &ts, first);
+ ts.lexical_parent = &state.templates.top_scope();
+ call_code_snippet(state, &ts, first);
                 }
             }
 
- actions.templates.pop();
+ state.templates.pop();
         }
     }
 
- void include_action(quickbook::actions& actions, value include, string_iterator first)
+ void include_action(quickbook::state& state, value include, string_iterator first)
     {
- write_anchors(actions, actions.out);
+ write_anchors(state, state.out);
 
         value_consumer values = include;
         value include_doc_id = values.optional_consume(general_tags::include_id);
- path_details details = check_path(values.consume(), actions);
+ path_details details = check_path(values.consume(), state);
         values.finish();
 
- std::set<include_search_return> search = include_search(details, actions);
+ std::set<include_search_return> search = include_search(details, state);
         std::set<include_search_return>::iterator i = search.begin();
         std::set<include_search_return>::iterator e = search.end();
         for (; i != e; ++i)
@@ -2097,36 +2097,36 @@
             try {
                 if (qbk_version_n >= 106)
                 {
- if (actions.imported && include.get_tag() == block_tags::include)
+ if (state.imported && include.get_tag() == block_tags::include)
                         return;
 
                     std::string ext = paths.filename.extension().generic_string();
 
                     if (ext == ".qbk" || ext == ".quickbook")
                     {
- load_quickbook(actions, paths, include.get_tag(), include_doc_id);
+ load_quickbook(state, paths, include.get_tag(), include_doc_id);
                     }
                     else
                     {
- load_source_file(actions, paths, include.get_tag(), first, include_doc_id);
+ load_source_file(state, paths, include.get_tag(), first, include_doc_id);
                     }
                 }
                 else
                 {
                     if (include.get_tag() == block_tags::include)
                     {
- load_quickbook(actions, paths, include.get_tag(), include_doc_id);
+ load_quickbook(state, paths, include.get_tag(), include_doc_id);
                     }
                     else
                     {
- load_source_file(actions, paths, include.get_tag(), first, include_doc_id);
+ load_source_file(state, paths, include.get_tag(), first, include_doc_id);
                     }
                 }
             }
             catch (load_error& e) {
- ++actions.error_count;
+ ++state.error_count;
 
- detail::outerr(actions.current_file, first)
+ detail::outerr(state.current_file, first)
                     << "Loading file "
                     << paths.filename
                     << ": "
@@ -2138,9 +2138,9 @@
 
     bool to_value_scoped_action::start(value::tag_type t)
     {
- actions.out.push();
- actions.phrase.push();
- actions.anchors.swap(saved_anchors);
+ state.out.push();
+ state.phrase.push();
+ state.anchors.swap(saved_anchors);
         tag = t;
 
         return true;
@@ -2150,28 +2150,28 @@
     {
         std::string value;
 
- if (!actions.out.str().empty())
+ if (!state.out.str().empty())
         {
- paragraph_action para(actions);
+ paragraph_action para(state);
             para(); // For paragraphs before the template call.
- write_anchors(actions, actions.out);
- actions.out.swap(value);
+ write_anchors(state, state.out);
+ state.out.swap(value);
         }
         else
         {
- write_anchors(actions, actions.phrase);
- actions.phrase.swap(value);
+ write_anchors(state, state.phrase);
+ state.phrase.swap(value);
         }
 
- actions.values.builder.insert(encoded_qbk_value(
- actions.current_file, first.base(), last.base(), value, tag));
+ state.values.builder.insert(encoded_qbk_value(
+ state.current_file, first.base(), last.base(), value, tag));
     }
     
     
     void to_value_scoped_action::cleanup()
     {
- actions.phrase.pop();
- actions.out.pop();
- actions.anchors.swap(saved_anchors);
+ state.phrase.pop();
+ state.out.pop();
+ state.anchors.swap(saved_anchors);
     }
 }

Modified: branches/quickbook-dev/tools/quickbook/src/actions.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/actions.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -52,7 +52,7 @@
 
     std::string syntax_highlight(
         parse_iterator first, parse_iterator last,
- actions& escape_actions,
+ quickbook::state& state,
         std::string const& source_mode,
         bool is_block);
 
@@ -64,20 +64,20 @@
         std::string uri;
     };
 
- xinclude_path calculate_xinclude_path(value const&, quickbook::actions&);
+ xinclude_path calculate_xinclude_path(value const&, quickbook::state&);
 
     struct error_message_action
     {
         // Prints an error message to std::cerr
 
- error_message_action(quickbook::actions& actions, std::string const& m)
- : actions(actions)
+ error_message_action(quickbook::state& state, std::string const& m)
+ : state(state)
             , message(m)
         {}
 
         void operator()(parse_iterator, parse_iterator) const;
 
- quickbook::actions& actions;
+ quickbook::state& state;
         std::string message;
     };
 
@@ -85,27 +85,27 @@
     {
         // Prints an error message to std::cerr
 
- error_action(quickbook::actions& actions)
- : actions(actions) {}
+ error_action(quickbook::state& state)
+ : state(state) {}
 
         void operator()(parse_iterator first, parse_iterator last) const;
 
         error_message_action operator()(std::string const& message)
         {
- return error_message_action(actions, message);
+ return error_message_action(state, message);
         }
 
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct element_action
     {
- element_action(quickbook::actions& actions)
- : actions(actions) {}
+ element_action(quickbook::state& state)
+ : state(state) {}
 
         void operator()(parse_iterator, parse_iterator) const;
 
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct paragraph_action
@@ -114,13 +114,13 @@
         // doesn't output the paragraph if it's only whitespace.
 
         paragraph_action(
- quickbook::actions& actions)
- : actions(actions) {}
+ quickbook::state& state)
+ : state(state) {}
 
         void operator()() const;
         void operator()(parse_iterator, parse_iterator) const { (*this)(); }
 
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct list_item_action
@@ -129,24 +129,24 @@
         // doesn't output the paragraph if it's only whitespace.
 
         list_item_action(
- quickbook::actions& actions)
- : actions(actions) {}
+ quickbook::state& state)
+ : state(state) {}
 
         void operator()() const;
         void operator()(parse_iterator, parse_iterator) const { (*this)(); }
 
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct phrase_end_action
     {
- phrase_end_action(quickbook::actions& actions) :
- actions(actions) {}
+ phrase_end_action(quickbook::state& state) :
+ state(state) {}
 
         void operator()() const;
         void operator()(parse_iterator, parse_iterator) const { (*this)(); }
 
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct simple_phrase_action
@@ -155,25 +155,25 @@
 
         simple_phrase_action(
             collector& out
- , quickbook::actions& actions)
+ , quickbook::state& state)
         : out(out)
- , actions(actions) {}
+ , state(state) {}
 
         void operator()(char) const;
 
         collector& out;
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct cond_phrase_push : scoped_action_base
     {
- cond_phrase_push(quickbook::actions& x)
- : actions(x) {}
+ cond_phrase_push(quickbook::state& x)
+ : state(x) {}
 
         bool start();
         void cleanup();
 
- quickbook::actions& actions;
+ quickbook::state& state;
         bool saved_conditional;
         std::vector<std::string> anchors;
     };
@@ -182,13 +182,13 @@
     {
         // Handles macro substitutions
 
- do_macro_action(collector& phrase, quickbook::actions& actions)
+ do_macro_action(collector& phrase, quickbook::state& state)
             : phrase(phrase)
- , actions(actions) {}
+ , state(state) {}
 
         void operator()(std::string const& str) const;
         collector& phrase;
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct raw_char_action
@@ -209,63 +209,63 @@
         // Prints a single plain char.
         // Converts '<' to "&lt;"... etc See utils.hpp
 
- plain_char_action(collector& phrase, quickbook::actions& actions)
+ plain_char_action(collector& phrase, quickbook::state& state)
         : phrase(phrase)
- , actions(actions) {}
+ , state(state) {}
 
         void operator()(char ch) const;
         void operator()(parse_iterator first, parse_iterator last) const;
 
         collector& phrase;
- quickbook::actions& actions;
+ quickbook::state& state;
     };
     
     struct escape_unicode_action
     {
- escape_unicode_action(collector& phrase, quickbook::actions& actions)
+ escape_unicode_action(collector& phrase, quickbook::state& state)
         : phrase(phrase)
- , actions(actions) {}
+ , state(state) {}
         void operator()(parse_iterator first, parse_iterator last) const;
 
         collector& phrase;
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
     struct break_action
     {
- break_action(collector& phrase, quickbook::actions& actions)
- : phrase(phrase), actions(actions) {}
+ break_action(collector& phrase, quickbook::state& state)
+ : phrase(phrase), state(state) {}
 
         void operator()(parse_iterator f, parse_iterator) const;
 
         collector& phrase;
- quickbook::actions& actions;
+ quickbook::state& state;
     };
 
    struct element_id_warning_action
    {
- element_id_warning_action(quickbook::actions& actions_)
- : actions(actions_) {}
+ element_id_warning_action(quickbook::state& state_)
+ : state(state_) {}
 
         void operator()(parse_iterator first, parse_iterator last) const;
 
- quickbook::actions& actions;
+ quickbook::state& state;
    };
 
     // Returns the doc_type, or an empty string if there isn't one.
- std::string pre(quickbook::actions& actions, parse_iterator pos, value include_doc_id, bool nested_file);
- void post(quickbook::actions& actions, std::string const& doc_type);
+ std::string pre(quickbook::state& state, parse_iterator pos, value include_doc_id, bool nested_file);
+ void post(quickbook::state& state, std::string const& doc_type);
 
     struct to_value_scoped_action : scoped_action_base
     {
- to_value_scoped_action(quickbook::actions& actions)
- : actions(actions) {}
+ to_value_scoped_action(quickbook::state& state)
+ : state(state) {}
 
         bool start(value::tag_type = value::default_tag);
         void success(parse_iterator, parse_iterator);
         void cleanup();
 
- quickbook::actions& actions;
+ quickbook::state& state;
         std::vector<std::string> saved_anchors;
         value::tag_type tag;
     };

Deleted: branches/quickbook-dev/tools/quickbook/src/actions_class.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions_class.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
+++ (empty file)
@@ -1,122 +0,0 @@
-/*=============================================================================
- Copyright (c) 2002 2004 2006 Joel de Guzman
- Copyright (c) 2004 Eric Niebler
- Copyright (c) 2005 Thomas Guest
- http://spirit.sourceforge.net/
-
- Use, modification and distribution is subject to 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)
-=============================================================================*/
-#include "actions_class.hpp"
-#include "actions_state.hpp"
-#include "quickbook.hpp"
-#include "grammar.hpp"
-#include "input_path.hpp"
-
-#if (defined(BOOST_MSVC) && (BOOST_MSVC <= 1310))
-#pragma warning(disable:4355)
-#endif
-
-namespace quickbook
-{
- char const* quickbook_get_date = "__quickbook_get_date__";
- char const* quickbook_get_time = "__quickbook_get_time__";
-
- unsigned qbk_version_n = 0; // qbk_major_version * 100 + qbk_minor_version
-
- actions::actions(fs::path const& filein_, fs::path const& xinclude_base_,
- string_stream& out_, id_manager& ids)
- : grammar_()
-
- , xinclude_base(xinclude_base_)
-
- , templates()
- , error_count(0)
- , anchors()
- , warned_about_breaks(false)
- , conditional(true)
- , ids(ids)
- , callouts()
- , callout_depth(0)
-
- , imported(false)
- , macro()
- , source_mode("c++")
- , source_mode_next()
- , current_file(0)
- , filename_relative(filein_.filename())
-
- , template_depth(0)
- , min_section_level(1)
-
- , out(out_)
- , phrase()
- , values(&current_file)
- {
- // add the predefined macros
- macro.add
- ("__DATE__", std::string(quickbook_get_date))
- ("__TIME__", std::string(quickbook_get_time))
- ("__FILENAME__", detail::path_to_generic(filename_relative))
- ;
-
- boost::scoped_ptr<quickbook_grammar> g(
- new quickbook_grammar(*this));
- grammar_.swap(g);
- }
-
- quickbook_grammar& actions::grammar() const {
- return *grammar_;
- }
-
- file_state::file_state(actions& a, scope_flags scope)
- : a(a)
- , scope(scope)
- , qbk_version(qbk_version_n)
- , imported(a.imported)
- , current_file(a.current_file)
- , filename_relative(a.filename_relative)
- , xinclude_base(a.xinclude_base)
- , source_mode(a.source_mode)
- , macro()
- {
- if (scope & scope_macros) macro = a.macro;
- if (scope & scope_templates) a.templates.push();
- if (scope & scope_output) {
- a.out.push();
- a.phrase.push();
- }
- a.values.builder.save();
- }
-
- file_state::~file_state()
- {
- a.values.builder.restore();
- boost::swap(qbk_version_n, qbk_version);
- boost::swap(a.imported, imported);
- boost::swap(a.current_file, current_file);
- boost::swap(a.filename_relative, filename_relative);
- boost::swap(a.xinclude_base, xinclude_base);
- boost::swap(a.source_mode, source_mode);
- if (scope & scope_output) {
- a.out.pop();
- a.phrase.pop();
- }
- if (scope & scope_templates) a.templates.pop();
- if (scope & scope_macros) a.macro = macro;
- }
-
- template_state::template_state(actions& a)
- : file_state(a, file_state::scope_all)
- , template_depth(a.template_depth)
- , min_section_level(a.min_section_level)
- {
- }
-
- template_state::~template_state()
- {
- boost::swap(a.template_depth, template_depth);
- boost::swap(a.min_section_level, min_section_level);
- }
-}

Deleted: branches/quickbook-dev/tools/quickbook/src/actions_class.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions_class.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
+++ (empty file)
@@ -1,94 +0,0 @@
-/*=============================================================================
- Copyright (c) 2002 2004 2006 Joel de Guzman
- Copyright (c) 2004 Eric Niebler
- http://spirit.sourceforge.net/
-
- Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_ACTIONS_CLASS_HPP)
-#define BOOST_SPIRIT_ACTIONS_CLASS_HPP
-
-#include <boost/scoped_ptr.hpp>
-#include "parsers.hpp"
-#include "values_parse.hpp"
-#include "collector.hpp"
-#include "template_stack.hpp"
-#include "symbols.hpp"
-
-namespace quickbook
-{
- namespace cl = boost::spirit::classic;
- namespace fs = boost::filesystem;
-
- struct actions
- {
- actions(fs::path const& filein_, fs::path const& xinclude_base, string_stream& out_,
- id_manager&);
-
- private:
- boost::scoped_ptr<quickbook_grammar> grammar_;
-
- public:
- ///////////////////////////////////////////////////////////////////////////
- // State
- ///////////////////////////////////////////////////////////////////////////
-
- typedef std::vector<std::string> string_list;
-
- static int const max_template_depth = 100;
-
- // global state
- fs::path xinclude_base;
- template_stack templates;
- int error_count;
- string_list anchors;
- bool warned_about_breaks;
- bool conditional;
- id_manager& ids;
- value_builder callouts; // callouts are global as
- int callout_depth; // they don't nest.
-
- // state saved for files and templates.
- bool imported;
- string_symbols macro;
- std::string source_mode;
- value source_mode_next;
- file_ptr current_file;
- fs::path filename_relative; // for the __FILENAME__ macro.
- // (relative to the original file
- // or include path).
-
- // state saved for templates.
- int template_depth;
- int min_section_level;
-
- // output state - scoped by templates and grammar
- collector out; // main output stream
- collector phrase; // phrase output stream
- value_parser values; // parsed values
-
- quickbook_grammar& grammar() const;
-
- ///////////////////////////////////////////////////////////////////////////
- // actions
- ///////////////////////////////////////////////////////////////////////////
-
- void start_list(char mark);
- void end_list(char mark);
- void start_list_item();
- void end_list_item();
-
- void start_callouts();
- std::string add_callout(value);
- std::string end_callouts();
- };
-
- extern unsigned qbk_version_n; // qbk_major_version * 100 + qbk_minor_version
- extern char const* quickbook_get_date;
- extern char const* quickbook_get_time;
-}
-
-#endif // BOOST_SPIRIT_ACTIONS_CLASS_HPP
-

Deleted: branches/quickbook-dev/tools/quickbook/src/actions_state.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/actions_state.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
+++ (empty file)
@@ -1,60 +0,0 @@
-/*=============================================================================
- Copyright (c) 2002 2004 2006 Joel de Guzman
- Copyright (c) 2004 Eric Niebler
- Copyright (c) 2011 Daniel James
-
- Use, modification and distribution is subject to 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)
-=============================================================================*/
-#if !defined(BOOST_SPIRIT_ACTIONS_STATE_HPP)
-#define BOOST_SPIRIT_ACTIONS_STATE_HPP
-
-#include "actions_class.hpp"
-
-namespace quickbook
-{
- // State savers
- //
- // Defined in actions_class.cpp
-
- struct file_state
- {
- enum scope_flags {
- scope_none = 0,
- scope_macros = 1,
- scope_templates = 2,
- scope_output = 4,
- scope_callables = scope_macros + scope_templates,
- scope_all = scope_callables + scope_output
- };
-
- explicit file_state(actions&, scope_flags);
- ~file_state();
-
- quickbook::actions& a;
- scope_flags scope;
- unsigned qbk_version;
- bool imported;
- std::string doc_type;
- file_ptr current_file;
- fs::path filename_relative;
- fs::path xinclude_base;
- std::string source_mode;
- string_symbols macro;
- private:
- file_state(file_state const&);
- file_state& operator=(file_state const&);
- };
-
- struct template_state : file_state
- {
- explicit template_state(actions&);
- ~template_state();
-
- int template_depth;
- int min_section_level;
- };
-}
-
-#endif // BOOST_SPIRIT_ACTIONS_STATE_HPP

Modified: branches/quickbook-dev/tools/quickbook/src/block_element_grammar.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/block_element_grammar.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/block_element_grammar.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -9,7 +9,7 @@
 =============================================================================*/
 
 #include "utils.hpp"
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "actions.hpp"
 #include "grammar_impl.hpp"
 #include "block_tags.hpp"
@@ -45,15 +45,15 @@
             new block_element_grammar_local);
 
         // Actions
- error_action error(actions);
- element_id_warning_action element_id_warning(actions);
- raw_char_action raw_char(actions.phrase);
- scoped_parser<to_value_scoped_action> to_value(actions);
+ error_action error(state);
+ element_id_warning_action element_id_warning(state);
+ raw_char_action raw_char(state.phrase);
+ scoped_parser<to_value_scoped_action> to_value(state);
 
         local.element_id =
             !( ':'
>> ( !(qbk_since(105u) >> space)
- >> (+(cl::alnum_p | '_')) [actions.values.entry(ph::arg1, ph::arg2, general_tags::element_id)]
+ >> (+(cl::alnum_p | '_')) [state.values.entry(ph::arg1, ph::arg2, general_tags::element_id)]
                 | cl::eps_p [element_id_warning]
                 )
             )
@@ -132,7 +132,7 @@
 
         local.def_macro =
                space
- >> macro_identifier [actions.values.entry(ph::arg1, ph::arg2)]
+ >> macro_identifier [state.values.entry(ph::arg1, ph::arg2)]
>> blank
>> local.inner_phrase
             ;
@@ -151,20 +151,20 @@
 
         local.template_ =
                space
- >> local.template_id [actions.values.entry(ph::arg1, ph::arg2)]
- >> actions.values.list()[
+ >> local.template_id [state.values.entry(ph::arg1, ph::arg2)]
+ >> state.values.list()[
             !(
                 space >> '['
>> *(
                         space
- >> local.template_id [actions.values.entry(ph::arg1, ph::arg2)]
+ >> local.template_id [state.values.entry(ph::arg1, ph::arg2)]
                     )
>> space >> ']'
             )
             ]
>> ( cl::eps_p(*cl::blank_p >> cl::eol_p)
- >> local.template_body [actions.values.entry(ph::arg1, ph::arg2, template_tags::block)]
- | local.template_body [actions.values.entry(ph::arg1, ph::arg2, template_tags::phrase)]
+ >> local.template_body [state.values.entry(ph::arg1, ph::arg2, template_tags::block)]
+ | local.template_body [state.values.entry(ph::arg1, ph::arg2, template_tags::phrase)]
                 )
             ;
 
@@ -187,7 +187,7 @@
         local.varlistentry =
             space
>> cl::ch_p('[')
- >> actions.values.list()
+ >> state.values.list()
             [
                 (
                     local.varlistterm
@@ -231,7 +231,7 @@
>>
             (
                 (
- actions.values.list(table_tags::row)
+ state.values.list(table_tags::row)
                     [ *local.cell
                     ]
>> cl::ch_p(']')
@@ -243,7 +243,7 @@
 
         local.table_title =
                 qbk_before(106)
- >> (*(cl::anychar_p - eol)) [actions.values.entry(ph::arg1, ph::arg2, table_tags::title)]
+ >> (*(cl::anychar_p - eol)) [state.values.entry(ph::arg1, ph::arg2, table_tags::title)]
>> (+eol)
             | qbk_since(106)
>> to_value(table_tags::title)
@@ -292,7 +292,7 @@
            !(
                 ':'
>> (*((cl::alnum_p | '_') - cl::space_p))
- [actions.values.entry(ph::arg1, ph::arg2, general_tags::include_id)]
+ [state.values.entry(ph::arg1, ph::arg2, general_tags::include_id)]
>> space
             )
>> local.include_filename
@@ -300,7 +300,7 @@
 
         local.include_filename =
                 qbk_before(106u)
- >> (*(cl::anychar_p - phrase_end)) [actions.values.entry(ph::arg1, ph::arg2)]
+ >> (*(cl::anychar_p - phrase_end)) [state.values.entry(ph::arg1, ph::arg2)]
             | qbk_since(106u)
>> to_value()
                 [ *( raw_escape

Modified: branches/quickbook-dev/tools/quickbook/src/code_snippet.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/code_snippet.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/code_snippet.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -16,7 +16,7 @@
 #include "block_tags.hpp"
 #include "template_stack.hpp"
 #include "actions.hpp"
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "values.hpp"
 #include "files.hpp"
 #include "input_path.hpp"

Modified: branches/quickbook-dev/tools/quickbook/src/doc_info_actions.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/doc_info_actions.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/doc_info_actions.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -17,7 +17,7 @@
 #include "utils.hpp"
 #include "files.hpp"
 #include "input_path.hpp"
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "actions.hpp"
 #include "doc_info_tags.hpp"
 #include "id_manager.hpp"
@@ -87,7 +87,7 @@
         return values;
     }
 
- unsigned get_version(quickbook::actions& actions, bool using_docinfo,
+ unsigned get_version(quickbook::state& state, bool using_docinfo,
             value version)
     {
         unsigned result = 0;
@@ -106,13 +106,13 @@
             
                 if(result < 100 || result > 107)
                 {
- detail::outerr(actions.current_file->path)
+ detail::outerr(state.current_file->path)
                         << "Unknown version: "
                         << major_verison
                         << "."
                         << minor_verison
                         << std::endl;
- ++actions.error_count;
+ ++state.error_count;
                 }
             }
         }
@@ -120,7 +120,7 @@
         return result;
     }
 
- std::string pre(quickbook::actions& actions, parse_iterator pos,
+ std::string pre(quickbook::state& state, parse_iterator pos,
             value include_doc_id, bool nested_file)
     {
         // The doc_info in the file has been parsed. Here's what we'll do
@@ -129,7 +129,7 @@
         // If there isn't a doc info block, then values will be empty, so most
         // of the following code won't actually do anything.
 
- value_consumer values = actions.values.release();
+ value_consumer values = state.values.release();
 
         // Skip over invalid attributes
 
@@ -149,15 +149,15 @@
         {
             if (!nested_file)
             {
- detail::outerr(actions.current_file, pos.base())
+ detail::outerr(state.current_file, pos.base())
                     << "No doc_info block."
                     << std::endl;
 
- ++actions.error_count;
+ ++state.error_count;
 
                 // Create a fake document info block in order to continue.
                 doc_type = "article";
- doc_title = qbk_value(actions.current_file,
+ doc_title = qbk_value(state.current_file,
                     pos.base(), pos.base(),
                     doc_info_tags::type);
                 use_doc_info = true;
@@ -187,7 +187,7 @@
 
         if(!duplicates.empty())
         {
- detail::outwarn(actions.current_file->path)
+ detail::outwarn(state.current_file->path)
                 << (duplicates.size() > 1 ?
                     "Duplicate attributes" : "Duplicate attribute")
                 << ":" << detail::utf8(boost::algorithm::join(duplicates, ", "))
@@ -204,11 +204,11 @@
 
         // Quickbook version
 
- unsigned new_version = get_version(actions, use_doc_info, qbk_version);
+ unsigned new_version = get_version(state, use_doc_info, qbk_version);
 
         if (new_version != qbk_version_n && new_version >= 106)
         {
- detail::outwarn(actions.current_file->path)
+ detail::outwarn(state.current_file->path)
                 << "Quickbook " << (new_version / 100) << "." << (new_version % 100)
                 << " is still under development and is "
                 "likely to change in the future." << std::endl;
@@ -220,34 +220,34 @@
         else if (use_doc_info) {
             // hard code quickbook version to v1.1
             qbk_version_n = 101;
- detail::outwarn(actions.current_file, pos.base())
+ detail::outwarn(state.current_file, pos.base())
                 << "Quickbook version undefined. "
                 "Version 1.1 is assumed" << std::endl;
         }
 
- actions.current_file->version(qbk_version_n);
+ state.current_file->version(qbk_version_n);
 
         // Compatibility Version
 
         unsigned compatibility_version =
- get_version(actions, use_doc_info, compatibility_mode);
+ get_version(state, use_doc_info, compatibility_mode);
 
         if (!compatibility_version) {
             compatibility_version = use_doc_info ?
- qbk_version_n : actions.ids.compatibility_version();
+ qbk_version_n : state.ids.compatibility_version();
         }
 
         // Start file, finish here if not generating document info.
 
         if (!use_doc_info)
         {
- actions.ids.start_file(compatibility_version, include_doc_id_, id_,
+ state.ids.start_file(compatibility_version, include_doc_id_, id_,
                     doc_title);
             return "";
         }
 
         std::string id_placeholder =
- actions.ids.start_file_with_docinfo(
+ state.ids.start_file_with_docinfo(
                 compatibility_version, include_doc_id_, id_, doc_title);
 
         // Make sure we really did have a document info block.
@@ -260,7 +260,7 @@
 
         if (!xmlbase.empty())
         {
- xinclude_path x = calculate_xinclude_path(xmlbase, actions);
+ xinclude_path x = calculate_xinclude_path(xmlbase, state);
 
             if (!fs::is_directory(x.path))
             {
@@ -270,12 +270,12 @@
                     << "\" isn't a directory."
                     << std::endl;
 
- ++actions.error_count;
+ ++state.error_count;
             }
             else
             {
                 xmlbase_value = x.uri;
- actions.xinclude_base = x.path;
+ state.xinclude_base = x.path;
             }
         }
 
@@ -296,7 +296,7 @@
 
             if(!invalid_attributes.empty())
             {
- detail::outwarn(actions.current_file->path)
+ detail::outwarn(state.current_file->path)
                     << (invalid_attributes.size() > 1 ?
                         "Invalid attributes" : "Invalid attribute")
                     << " for '" << detail::utf8(doc_type) << " document info': "
@@ -310,7 +310,7 @@
 
         if (!nested_file)
         {
- actions.out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+ state.out << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
                 << "<!DOCTYPE "
                 << doc_type
                 << " PUBLIC \"-//Boost//DTD BoostBook XML V1.0//EN\"\n"
@@ -318,51 +318,51 @@
                 ;
         }
 
- actions.out << '<' << doc_type << "\n"
+ state.out << '<' << doc_type << "\n"
             << " id=\""
             << id_placeholder
             << "\"\n";
 
         if(!lang.empty())
         {
- actions.out << " lang=\""
+ state.out << " lang=\""
                 << doc_info_output(lang, 106)
                 << "\"\n";
         }
 
         if(doc_type == "library" && !doc_title.empty())
         {
- actions.out << " name=\"" << doc_info_output(doc_title, 106) << "\"\n";
+ state.out << " name=\"" << doc_info_output(doc_title, 106) << "\"\n";
         }
 
         // Set defaults for dirname + last_revision
 
         if (!dirname.empty() || doc_type == "library")
         {
- actions.out << " dirname=\"";
+ state.out << " dirname=\"";
             if (!dirname.empty()) {
- actions.out << doc_info_output(dirname, 106);
+ state.out << doc_info_output(dirname, 106);
             }
             else if (!id_.empty()) {
- actions.out << id_;
+ state.out << id_;
             }
             else if (!include_doc_id_.empty()) {
- actions.out << include_doc_id_;
+ state.out << include_doc_id_;
             }
             else if (!doc_title.empty()) {
- actions.out << detail::make_identifier(doc_title.get_quickbook());
+ state.out << detail::make_identifier(doc_title.get_quickbook());
             }
             else {
- actions.out << "library";
+ state.out << "library";
             }
 
- actions.out << "\"\n";
+ state.out << "\"\n";
         }
 
- actions.out << " last-revision=\"";
+ state.out << " last-revision=\"";
         if (!last_revision.empty())
         {
- actions.out << doc_info_output(last_revision, 106);
+ state.out << doc_info_output(last_revision, 106);
         }
         else
         {
@@ -377,19 +377,19 @@
                 current_gm_time
             );
 
- actions.out << strdate;
+ state.out << strdate;
         }
 
- actions.out << "\" \n";
+ state.out << "\" \n";
 
         if (!xmlbase.empty())
         {
- actions.out << " xml:base=\""
+ state.out << " xml:base=\""
                 << xmlbase_value
                 << "\"\n";
         }
 
- actions.out << " xmlns:xi=\"http://www.w3.org/2001/XInclude\">\n";
+ state.out << " xmlns:xi=\"http://www.w3.org/2001/XInclude\">\n";
 
         std::ostringstream tmp;
 
@@ -431,9 +431,9 @@
                         year_start;
     
                     if (year_end < year_start) {
- ++actions.error_count;
+ ++state.error_count;
     
- detail::outerr(actions.current_file, copyright.begin()->get_position())
+ detail::outerr(state.current_file, copyright.begin()->get_position())
                             << "Invalid year range: "
                             << year_start
                             << "-"
@@ -458,7 +458,7 @@
         if (!license.empty())
         {
             tmp << " <legalnotice id=\""
- << actions.ids.add_id("legal", id_category::generated)
+ << state.ids.add_id("legal", id_category::generated)
                 << "\">\n"
                 << " <para>\n"
                 << " " << doc_info_output(license, 103) << "\n"
@@ -505,13 +505,13 @@
         }
 
         if(doc_type != "library") {
- write_document_title(actions.out, doc_title, version);
+ write_document_title(state.out, doc_title, version);
         }
 
         std::string docinfo = tmp.str();
         if(!docinfo.empty())
         {
- actions.out << " <" << doc_type << "info>\n"
+ state.out << " <" << doc_type << "info>\n"
                 << docinfo
                 << " </" << doc_type << "info>\n"
                 << "\n"
@@ -519,31 +519,31 @@
         }
 
         if(doc_type == "library") {
- write_document_title(actions.out, doc_title, version);
+ write_document_title(state.out, doc_title, version);
         }
 
         return doc_type;
     }
 
- void post(quickbook::actions& actions, std::string const& doc_type)
+ void post(quickbook::state& state, std::string const& doc_type)
     {
         // We've finished generating our output. Here's what we'll do
         // *after* everything else.
 
         // Close any open sections.
- if (!doc_type.empty() && actions.ids.section_level() > 1) {
- detail::outwarn(actions.current_file->path)
+ if (!doc_type.empty() && state.ids.section_level() > 1) {
+ detail::outwarn(state.current_file->path)
                 << "Missing [endsect] detected at end of file."
                 << std::endl;
 
- while(actions.ids.section_level() > 1) {
- actions.out << "</section>";
- actions.ids.end_section();
+ while(state.ids.section_level() > 1) {
+ state.out << "</section>";
+ state.ids.end_section();
             }
         }
 
- actions.ids.end_file();
- if (!doc_type.empty()) actions.out << "\n</" << doc_type << ">\n\n";
+ state.ids.end_file();
+ if (!doc_type.empty()) state.out << "\n</" << doc_type << ">\n\n";
     }
 
     static void write_document_title(collector& out, value const& title, value const& version)

Modified: branches/quickbook-dev/tools/quickbook/src/doc_info_grammar.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/doc_info_grammar.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/doc_info_grammar.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -19,7 +19,7 @@
 #include <boost/spirit/include/phoenix1_primitives.hpp>
 #include <boost/spirit/include/phoenix1_operators.hpp>
 #include "grammar_impl.hpp"
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "actions.hpp"
 #include "doc_info_tags.hpp"
 #include "phrase_tags.hpp"
@@ -116,9 +116,9 @@
         }
 
         // Actions
- error_action error(actions);
- plain_char_action plain_char(actions.phrase, actions);
- scoped_parser<to_value_scoped_action> to_value(actions);
+ error_action error(state);
+ plain_char_action plain_char(state.phrase, state);
+ scoped_parser<to_value_scoped_action> to_value(state);
         
         doc_info_details =
                 space [ph::var(local.source_mode_unset) = true]
@@ -132,7 +132,7 @@
                 '['
>> space
>> (local.doc_types >> cl::eps_p)
- [actions.values.entry(ph::arg1, ph::arg2, doc_info_tags::type)]
+ [state.values.entry(ph::arg1, ph::arg2, doc_info_tags::type)]
>> hard_space
>> to_value(doc_info_tags::title)
                 [ *( ~cl::eps_p(blank >> (cl::ch_p('[') | ']' | cl::eol_p))
@@ -144,11 +144,11 @@
                 ]
>> space
>> !(qbk_since(106u) >> cl::eps_p(ph::var(local.source_mode_unset))
- [cl::assign_a(actions.source_mode, "c++")]
+ [cl::assign_a(state.source_mode, "c++")]
                 )
>> (*( local.doc_info_attribute
>> space
- )) [actions.values.sort()]
+ )) [state.values.sort()]
>> ( ']'
>> (+eol | cl::end_p)
                 | cl::eps_p [error]
@@ -160,8 +160,8 @@
>> space
>> local.doc_attributes [local.assign_attribute]
>> hard_space
- >> actions.values.list(ph::var(local.attribute_tag))
- [ cl::eps_p [actions.values.entry(ph::arg1, ph::arg2, doc_info_tags::before_docinfo)]
+ >> state.values.list(ph::var(local.attribute_tag))
+ [ cl::eps_p [state.values.entry(ph::arg1, ph::arg2, doc_info_tags::before_docinfo)]
>> local.attribute_rule
                 ]
>> space
@@ -178,7 +178,7 @@
                                             [error("Unrecognized document attribute: '%s'.")]
                 )
>> hard_space
- >> actions.values.list(ph::var(local.attribute_tag))
+ >> state.values.list(ph::var(local.attribute_tag))
                 [local.attribute_rule]
>> space
>> ']'
@@ -191,17 +191,17 @@
         // Document Attributes
 
         local.quickbook_version =
- cl::uint_p [actions.values.entry(ph::arg1)]
+ cl::uint_p [state.values.entry(ph::arg1)]
>> '.'
- >> uint2_t() [actions.values.entry(ph::arg1)]
+ >> uint2_t() [state.values.entry(ph::arg1)]
             ;
 
         local.attribute_rules[doc_attributes::qbk_version] = &local.quickbook_version;
 
         local.doc_compatibility_mode =
- cl::uint_p [actions.values.entry(ph::arg1)]
+ cl::uint_p [state.values.entry(ph::arg1)]
>> '.'
- >> uint2_t() [actions.values.entry(ph::arg1)]
+ >> uint2_t() [state.values.entry(ph::arg1)]
             ;
 
         local.attribute_rules[doc_attributes::compatibility_mode] = &local.doc_compatibility_mode;
@@ -211,7 +211,7 @@
                    cl::str_p("c++")
                 | "python"
                 | "teletype"
- ) [cl::assign_a(actions.source_mode)]
+ ) [cl::assign_a(state.source_mode)]
                                             [ph::var(local.source_mode_unset) = false]
             ;
 
@@ -238,12 +238,12 @@
 
         local.doc_copyright =
             *( +( local.doc_copyright_year
- [actions.values.entry(ph::arg1, doc_info_tags::copyright_year)]
+ [state.values.entry(ph::arg1, doc_info_tags::copyright_year)]
>> space
>> !( '-'
>> space
>> local.doc_copyright_year
- [actions.values.entry(ph::arg1, doc_info_tags::copyright_year_end)]
+ [state.values.entry(ph::arg1, doc_info_tags::copyright_year_end)]
>> space
                     )
>> !cl::ch_p(',')
@@ -282,7 +282,7 @@
         local.attribute_rules[doc_info_attributes::authors] = &local.doc_authors;
 
         local.doc_biblioid =
- (+cl::alnum_p) [actions.values.entry(ph::arg1, ph::arg2, doc_info_tags::biblioid_class)]
+ (+cl::alnum_p) [state.values.entry(ph::arg1, ph::arg2, doc_info_tags::biblioid_class)]
>> hard_space
>> to_value(doc_info_tags::biblioid_value)
                 [+(~cl::eps_p(']') >> local.char_)]

Modified: branches/quickbook-dev/tools/quickbook/src/fwd.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/fwd.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/fwd.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -16,7 +16,7 @@
 
 namespace quickbook
 {
- struct actions;
+ struct state;
     struct quickbook_grammar;
     struct collector;
     struct id_manager;

Modified: branches/quickbook-dev/tools/quickbook/src/grammar.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/grammar.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/grammar.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -13,8 +13,8 @@
 
 namespace quickbook
 {
- quickbook_grammar::quickbook_grammar(quickbook::actions& a)
- : impl_(new impl(a))
+ quickbook_grammar::quickbook_grammar(quickbook::state& s)
+ : impl_(new impl(s))
         , command_line_macro(impl_->command_line, "command_line_macro")
         , inline_phrase(impl_->inline_phrase, "inline_phrase")
         , phrase(impl_->phrase_start, "phrase")
@@ -27,8 +27,8 @@
     {
     }
 
- quickbook_grammar::impl::impl(quickbook::actions& a)
- : actions(a)
+ quickbook_grammar::impl::impl(quickbook::state& s)
+ : state(s)
         , cleanup_()
     {
         init_main();

Modified: branches/quickbook-dev/tools/quickbook/src/grammar.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/grammar.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/grammar.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -62,7 +62,7 @@
         grammar block;
         grammar doc_info;
 
- quickbook_grammar(quickbook::actions&);
+ quickbook_grammar(quickbook::state&);
         ~quickbook_grammar();
     };
 }

Modified: branches/quickbook-dev/tools/quickbook/src/grammar_impl.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/grammar_impl.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/grammar_impl.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -59,7 +59,7 @@
 
     struct quickbook_grammar::impl
     {
- quickbook::actions& actions;
+ quickbook::state& state;
         cleanup cleanup_;
 
         // Main Grammar
@@ -92,7 +92,7 @@
         // Doc Info
         cl::rule<scanner> doc_info_details;
         
- impl(quickbook::actions&);
+ impl(quickbook::state&);
 
     private:
 

Modified: branches/quickbook-dev/tools/quickbook/src/main_grammar.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/main_grammar.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/main_grammar.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -9,7 +9,7 @@
 =============================================================================*/
 
 #include "grammar_impl.hpp"
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "actions.hpp"
 #include "utils.hpp"
 #include "template_tags.hpp"
@@ -179,17 +179,17 @@
         element_info info;
         element_info::type_enum element_type;
 
- // actions
- quickbook::actions& actions_;
+ // state
+ quickbook::state& state_;
 
         ////////////////////////////////////////////////////////////////////////
         // Local constructor
 
- main_grammar_local(quickbook::actions& actions)
+ main_grammar_local(quickbook::state& state)
             : list_stack()
             , list_indent(0)
             , no_eols(true)
- , actions_(actions)
+ , state_(state)
             {}
     };
 
@@ -208,18 +208,18 @@
             if (info_.type != element_info::phrase &&
                     info_.type != element_info::maybe_block)
             {
- quickbook::paragraph_action para(l.actions_);
+ paragraph_action para(l.state_);
                 para();
             }
 
- assert(l.actions_.values.builder.empty());
+ assert(l.state_.values.builder.empty());
 
- if (!l.actions_.source_mode_next.empty() &&
+ if (!l.state_.source_mode_next.empty() &&
                 info_.type != element_info::maybe_block)
             {
- l.actions_.source_mode.swap(saved_source_mode_);
- l.actions_.source_mode = l.actions_.source_mode_next.get_quickbook();
- l.actions_.source_mode_next = value();
+ l.state_.source_mode.swap(saved_source_mode_);
+ l.state_.source_mode = l.state_.source_mode_next.get_quickbook();
+ l.state_.source_mode_next = value();
             }
 
             return true;
@@ -231,7 +231,7 @@
             if (result || info_.type & element_info::in_phrase)
                 return result;
 
- error_action error(l.actions_);
+ error_action error(l.state_);
             error(scan.first, scan.first);
             return true;
         }
@@ -241,7 +241,7 @@
 
         void cleanup() {
             if (!saved_source_mode_.empty())
- l.actions_.source_mode.swap(saved_source_mode_);
+ l.state_.source_mode.swap(saved_source_mode_);
         }
 
         main_grammar_local& l;
@@ -286,27 +286,27 @@
     void quickbook_grammar::impl::init_main()
     {
         main_grammar_local& local = cleanup_.add(
- new main_grammar_local(actions));
+ new main_grammar_local(state));
 
         // Global Actions
- element_action element(actions);
- paragraph_action paragraph(actions);
- list_item_action list_item(actions);
+ element_action element(state);
+ paragraph_action paragraph(state);
+ list_item_action list_item(state);
 
- phrase_end_action end_phrase(actions);
- raw_char_action raw_char(actions.phrase);
- plain_char_action plain_char(actions.phrase, actions);
- escape_unicode_action escape_unicode(actions.phrase, actions);
+ phrase_end_action end_phrase(state);
+ raw_char_action raw_char(state.phrase);
+ plain_char_action plain_char(state.phrase, state);
+ escape_unicode_action escape_unicode(state.phrase, state);
 
- simple_phrase_action simple_markup(actions.phrase, actions);
+ simple_phrase_action simple_markup(state.phrase, state);
 
- break_action break_(actions.phrase, actions);
- do_macro_action do_macro(actions.phrase, actions);
+ break_action break_(state.phrase, state);
+ do_macro_action do_macro(state.phrase, state);
 
- error_action error(actions);
- element_id_warning_action element_id_warning(actions);
+ error_action error(state);
+ element_id_warning_action element_id_warning(state);
 
- scoped_parser<to_value_scoped_action> to_value(actions);
+ scoped_parser<to_value_scoped_action> to_value(state);
 
         // Local Actions
         scoped_parser<process_element_impl> process_element(local);
@@ -331,7 +331,7 @@
         // nested_phrase is used for a phrase nested inside square
         // brackets.
         nested_phrase =
- actions.values.save()
+ state.values.save()
             [ *( ~cl::eps_p(']')
>> local.common(element_info::in_phrase)
                 )
@@ -341,7 +341,7 @@
         // paragraph_phrase is like a nested_phrase but is also terminated
         // by a paragraph end.
         paragraph_phrase =
- actions.values.save()
+ state.values.save()
             [ *( ~cl::eps_p(phrase_end)
>> local.common(element_info::in_phrase)
                 )
@@ -351,7 +351,7 @@
         // extended_phrase is like a paragraph_phrase but allows some block
         // elements.
         extended_phrase =
- actions.values.save()
+ state.values.save()
             [ *( ~cl::eps_p(phrase_end)
>> local.common(element_info::in_conditional)
                 )
@@ -363,13 +363,13 @@
         // is expanding a template, which is parsed separately but
         // is part of the paragraph that contains it.
         inline_phrase =
- actions.values.save()
+ state.values.save()
             [ *local.common(element_info::in_phrase)
             ]
             ;
 
         table_title_phrase =
- actions.values.save()
+ state.values.save()
             [ *( ~cl::eps_p(space >> (']' | '[' >> space >> '['))
>> local.common(element_info::in_phrase)
                 )
@@ -456,7 +456,7 @@
 
         // Blocks contains within an element, e.g. a table cell or a footnote.
         inside_paragraph =
- actions.values.save()
+ state.values.save()
             [ *( local.paragraph_separator [paragraph]
>> *eol
                 | ~cl::eps_p(']')
@@ -467,7 +467,7 @@
 
         local.hr =
                 cl::str_p("----")
- >> actions.values.list(block_tags::hr)
+ >> state.values.list(block_tags::hr)
                 [ ( qbk_since(106u)
>> *(line_comment | (cl::anychar_p - (cl::eol_p | '[' | ']')))
                     | qbk_before(106u)
@@ -485,7 +485,7 @@
>> (cl::eps_p - (cl::alnum_p | '_'))
                 )
>> process_element()
- [ actions.values.list(ph::var(local.info.tag))
+ [ state.values.list(ph::var(local.info.tag))
                     [ cl::lazy_p(*ph::var(local.info.rule))
>> space
>> ']'
@@ -494,10 +494,10 @@
             ;
 
         local.code =
- actions.values.list(code_tags::code_block)
+ state.values.list(code_tags::code_block)
             [( local.code_line
>> *(*local.blank_line >> local.code_line)
- ) [actions.values.entry(ph::arg1, ph::arg2)]
+ ) [state.values.entry(ph::arg1, ph::arg2)]
             ] [element]
>> *eol
             ;
@@ -543,23 +543,23 @@
 
         local.macro =
             cl::eps_p
- ( ( actions.macro
+ ( ( state.macro
>> ~cl::eps_p(cl::alpha_p | '_')
                                                 // must not be followed by alpha or underscore
                 )
                 & macro_identifier // must be a valid macro for the current version
             )
- >> actions.macro [do_macro]
+ >> state.macro [do_macro]
             ;
 
         local.template_ =
             ( '['
>> space
- >> actions.values.list(template_tags::template_)
- [ !cl::str_p("`") [actions.values.entry(ph::arg1, ph::arg2, template_tags::escape)]
+ >> state.values.list(template_tags::template_)
+ [ !cl::str_p("`") [state.values.entry(ph::arg1, ph::arg2, template_tags::escape)]
>> ( cl::eps_p(cl::punct_p)
- >> actions.templates.scope [actions.values.entry(ph::arg1, ph::arg2, template_tags::identifier)]
- | actions.templates.scope [actions.values.entry(ph::arg1, ph::arg2, template_tags::identifier)]
+ >> state.templates.scope [state.values.entry(ph::arg1, ph::arg2, template_tags::identifier)]
+ | state.templates.scope [state.values.entry(ph::arg1, ph::arg2, template_tags::identifier)]
>> cl::eps_p(hard_space)
                     )
>> space
@@ -578,8 +578,8 @@
 
         local.template_arg_1_4 =
             ( cl::eps_p(*cl::blank_p >> cl::eol_p)
- >> local.template_inner_arg_1_4 [actions.values.entry(ph::arg1, ph::arg2, template_tags::block)]
- | local.template_inner_arg_1_4 [actions.values.entry(ph::arg1, ph::arg2, template_tags::phrase)]
+ >> local.template_inner_arg_1_4 [state.values.entry(ph::arg1, ph::arg2, template_tags::block)]
+ | local.template_inner_arg_1_4 [state.values.entry(ph::arg1, ph::arg2, template_tags::phrase)]
             )
             ;
 
@@ -595,8 +595,8 @@
 
         local.template_arg_1_5 =
             ( cl::eps_p(*cl::blank_p >> cl::eol_p)
- >> local.template_arg_1_5_content [actions.values.entry(ph::arg1, ph::arg2, template_tags::block)]
- | local.template_arg_1_5_content [actions.values.entry(ph::arg1, ph::arg2, template_tags::phrase)]
+ >> local.template_arg_1_5_content [state.values.entry(ph::arg1, ph::arg2, template_tags::block)]
+ | local.template_arg_1_5_content [state.values.entry(ph::arg1, ph::arg2, template_tags::phrase)]
             )
             ;
 
@@ -622,7 +622,7 @@
                 ;
 
         local.inline_code =
- '`' >> actions.values.list(code_tags::inline_code)
+ '`' >> state.values.list(code_tags::inline_code)
             [(
                *(cl::anychar_p -
                     ( '`'
@@ -630,7 +630,7 @@
                                                 // Make sure that we don't go
                     ) // past a single block
                 ) >> cl::eps_p('`')
- ) [actions.values.entry(ph::arg1, ph::arg2)]
+ ) [state.values.entry(ph::arg1, ph::arg2)]
>> '`'
             ] [element]
             ;
@@ -638,7 +638,7 @@
         local.code_block =
                 "```"
>> ~cl::eps_p("`")
- >> ( actions.values.list(code_tags::inline_code_block)
+ >> ( state.values.list(code_tags::inline_code_block)
                     [ *(*cl::blank_p >> cl::eol_p)
>> ( *( "````" >> *cl::ch_p('`')
                             | ( cl::anychar_p
@@ -646,7 +646,7 @@
                                 )
                             )
>> !(*cl::blank_p >> cl::eol_p)
- ) [actions.values.entry(ph::arg1, ph::arg2)]
+ ) [state.values.entry(ph::arg1, ph::arg2)]
>> (*cl::space_p >> "```")
                     ] [element]
                 | cl::eps_p [error("Unfinished code block")]
@@ -654,7 +654,7 @@
                 )
             | "``"
>> ~cl::eps_p("`")
- >> ( actions.values.list(code_tags::inline_code_block)
+ >> ( state.values.list(code_tags::inline_code_block)
                     [ *(*cl::blank_p >> cl::eol_p)
>> ( *( "```" >> *cl::ch_p('`')
                             | ( cl::anychar_p
@@ -662,7 +662,7 @@
                                 )
                             )
>> !(*cl::blank_p >> cl::eol_p)
- ) [actions.values.entry(ph::arg1, ph::arg2)]
+ ) [state.values.entry(ph::arg1, ph::arg2)]
>> (*cl::space_p >> "``")
                     ] [element]
                 | cl::eps_p [error("Unfinished code block")]
@@ -683,12 +683,12 @@
                                                 // by space or punctuation or the
                                                 // mark character or a the start.
                 ]
- >> actions.values.save()
+ >> state.values.save()
                 [
                     to_value()
                     [
- cl::eps_p((actions.macro & macro_identifier) >> local.simple_markup_end)
- >> actions.macro [do_macro]
+ cl::eps_p((state.macro & macro_identifier) >> local.simple_markup_end)
+ >> state.macro [do_macro]
                     | ~cl::eps_p(cl::f_ch_p(local.simple_markup.mark))
>> +( ~cl::eps_p
                             ( lookback [~cl::f_ch_p(local.simple_markup.mark)]
@@ -728,8 +728,8 @@
             | "\\U" >> cl::repeat_p(8) [cl::chset<>("0-9a-fA-F")]
                                                 [escape_unicode]
             | ("'''" >> !eol)
- >> actions.values.save()
- [ (*(cl::anychar_p - "'''")) [actions.values.entry(ph::arg1, ph::arg2, phrase_tags::escape)]
+ >> state.values.save()
+ [ (*(cl::anychar_p - "'''")) [state.values.entry(ph::arg1, ph::arg2, phrase_tags::escape)]
>> ( cl::str_p("'''")
                     | cl::eps_p [error("Unclosed boostbook escape.")]
                     ) [element]
@@ -758,10 +758,10 @@
         //
 
         command_line =
- actions.values.list(block_tags::macro_definition)
+ state.values.list(block_tags::macro_definition)
             [ *cl::space_p
>> local.command_line_macro_identifier
- [actions.values.entry(ph::arg1, ph::arg2)]
+ [state.values.entry(ph::arg1, ph::arg2)]
>> *cl::space_p
>> !( '='
>> *cl::space_p
@@ -896,8 +896,8 @@
             else {
                 while (!list_stack.top().root && new_indent < list_stack.top().indent)
                 {
- actions_.end_list_item();
- actions_.end_list(list_stack.top().mark);
+ state_.end_list_item();
+ state_.end_list(list_stack.top().mark);
                     list_stack.pop();
                     list_indent = list_stack.top().indent;
                 }
@@ -930,8 +930,8 @@
                         new_indent > list_stack.top().indent);
 
                     if (new_indent <= list_stack.top().indent2) {
- actions_.end_list_item();
- actions_.end_list(save.mark);
+ state_.end_list_item();
+ state_.end_list(save.mark);
                         list_indent = list_stack.top().indent;
                     }
                     else {
@@ -966,44 +966,44 @@
 
         if (list_stack.top().root || new_indent > list_indent) {
             list_stack.push(list_stack_item(mark, new_indent, new_indent2));
- actions_.start_list(mark);
+ state_.start_list(mark);
         }
         else if (new_indent == list_indent) {
- actions_.end_list_item();
+ state_.end_list_item();
         }
         else {
             // This should never reach root, since the first list
             // has indentation 0.
             while(!list_stack.top().root && new_indent < list_stack.top().indent)
             {
- actions_.end_list_item();
- actions_.end_list(list_stack.top().mark);
+ state_.end_list_item();
+ state_.end_list(list_stack.top().mark);
                 list_stack.pop();
             }
 
- actions_.end_list_item();
+ state_.end_list_item();
         }
 
         list_indent = new_indent;
 
         if (mark != list_stack.top().mark)
         {
- detail::outerr(actions_.current_file, first)
+ detail::outerr(state_.current_file, first)
                 << "Illegal change of list style.\n";
- detail::outwarn(actions_.current_file, first)
+ detail::outwarn(state_.current_file, first)
                 << "Ignoring change of list style." << std::endl;
- ++actions_.error_count;
+ ++state_.error_count;
         }
 
- actions_.start_list_item();
+ state_.start_list_item();
         block_type = block_types::list;
     }
 
     void main_grammar_local::clear_stack()
     {
         while (!list_stack.top().root) {
- actions_.end_list_item();
- actions_.end_list(list_stack.top().mark);
+ state_.end_list_item();
+ state_.end_list(list_stack.top().mark);
             list_stack.pop();
         }
     }

Modified: branches/quickbook-dev/tools/quickbook/src/phrase_element_grammar.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/phrase_element_grammar.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/phrase_element_grammar.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -9,7 +9,7 @@
 =============================================================================*/
 
 #include "grammar_impl.hpp"
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "actions.hpp"
 #include "utils.hpp"
 #include "phrase_tags.hpp"
@@ -37,10 +37,10 @@
         phrase_element_grammar_local& local = cleanup_.add(
             new phrase_element_grammar_local);
 
- error_action error(actions);
- raw_char_action raw_char(actions.phrase);
- scoped_parser<cond_phrase_push> scoped_cond_phrase(actions);
- scoped_parser<to_value_scoped_action> to_value(actions);
+ error_action error(state);
+ raw_char_action raw_char(state.phrase);
+ scoped_parser<cond_phrase_push> scoped_cond_phrase(state);
+ scoped_parser<to_value_scoped_action> to_value(state);
 
         elements.add
             ("?", element_info(element_info::phrase, &local.cond_phrase))
@@ -48,7 +48,7 @@
 
         local.cond_phrase =
                 blank
- >> macro_identifier [actions.values.entry(ph::arg1, ph::arg2)]
+ >> macro_identifier [state.values.entry(ph::arg1, ph::arg2)]
>> scoped_cond_phrase() [extended_phrase]
             ;
 
@@ -65,7 +65,7 @@
>> (+(
                         *cl::space_p
>> +(cl::anychar_p - (cl::space_p | phrase_end | '['))
- )) [actions.values.entry(ph::arg1, ph::arg2)]
+ )) [state.values.entry(ph::arg1, ph::arg2)]
                 | qbk_since(106u)
>> to_value()
                     [ +( raw_escape
@@ -77,14 +77,14 @@
                     ]
                 )
>> hard_space
- >> *actions.values.list()
+ >> *state.values.list()
                 [ '['
>> (*(cl::alnum_p | '_'))
- [actions.values.entry(ph::arg1, ph::arg2)]
+ [state.values.entry(ph::arg1, ph::arg2)]
>> space
>> ( qbk_before(106u)
>> (*(cl::anychar_p - (phrase_end | '[')))
- [actions.values.entry(ph::arg1, ph::arg2)]
+ [state.values.entry(ph::arg1, ph::arg2)]
                     | qbk_since(106u)
>> to_value()
                         [ *( raw_escape
@@ -99,7 +99,7 @@
>> cl::eps_p(']')
             | qbk_before(105u)
>> blank
- >> (*(cl::anychar_p - phrase_end)) [actions.values.entry(ph::arg1, ph::arg2)]
+ >> (*(cl::anychar_p - phrase_end)) [state.values.entry(ph::arg1, ph::arg2)]
>> cl::eps_p(']')
             ;
             
@@ -120,7 +120,7 @@
                 space
>> ( qbk_before(106u)
>> (*(cl::anychar_p - (']' | space)))
- [actions.values.entry(ph::arg1, ph::arg2)]
+ [state.values.entry(ph::arg1, ph::arg2)]
                 | qbk_since(106u)
>> to_value()
                     [ *( raw_escape
@@ -143,7 +143,7 @@
         local.anchor =
                 blank
>> ( qbk_before(106u)
- >> (*(cl::anychar_p - phrase_end)) [actions.values.entry(ph::arg1, ph::arg2)]
+ >> (*(cl::anychar_p - phrase_end)) [state.values.entry(ph::arg1, ph::arg2)]
                 | qbk_since(106u)
>> to_value()
                     [ *( raw_escape
@@ -172,7 +172,7 @@
             ( cl::str_p("c++")
             | "python"
             | "teletype"
- ) [actions.values.entry(ph::arg1, ph::arg2)];
+ ) [state.values.entry(ph::arg1, ph::arg2)];
 
         elements.add
             ("c++", element_info(element_info::phrase, &local.empty, source_mode_tags::cpp))
@@ -186,7 +186,7 @@
 
         local.role
             = space
- >> (+(cl::alnum_p | '_')) [actions.values.entry(ph::arg1, ph::arg2)]
+ >> (+(cl::alnum_p | '_')) [state.values.entry(ph::arg1, ph::arg2)]
>> hard_space
>> local.inner_phrase
             ;

Modified: branches/quickbook-dev/tools/quickbook/src/quickbook.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/quickbook.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/quickbook.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -9,7 +9,7 @@
 =============================================================================*/
 #include "grammar.hpp"
 #include "quickbook.hpp"
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "actions.hpp"
 #include "post_process.hpp"
 #include "utils.hpp"
@@ -53,7 +53,7 @@
     std::vector<std::string> preset_defines;
     fs::path image_location;
 
- static void set_macros(actions& actor)
+ static void set_macros(quickbook::state& state)
     {
         for(std::vector<std::string>::const_iterator
                 it = preset_defines.begin(),
@@ -64,7 +64,7 @@
             parse_iterator last(it->end());
 
             cl::parse_info<parse_iterator> info =
- cl::parse(first, last, actor.grammar().command_line_macro);
+ cl::parse(first, last, state.grammar().command_line_macro);
 
             if (!info.full) {
                 detail::outerr()
@@ -72,7 +72,7 @@
                     << detail::utf8(*it)
                     << "'"
                     << std::endl;
- ++actor.error_count;
+ ++state.error_count;
             }
         }
     }
@@ -82,29 +82,29 @@
     // Parse a file
     //
     ///////////////////////////////////////////////////////////////////////////
- void parse_file(actions& actor, value include_doc_id, bool nested_file)
+ void parse_file(quickbook::state& state, value include_doc_id, bool nested_file)
     {
- parse_iterator first(actor.current_file->source.begin());
- parse_iterator last(actor.current_file->source.end());
+ parse_iterator first(state.current_file->source.begin());
+ parse_iterator last(state.current_file->source.end());
 
- cl::parse_info<parse_iterator> info = cl::parse(first, last, actor.grammar().doc_info);
+ cl::parse_info<parse_iterator> info = cl::parse(first, last, state.grammar().doc_info);
         assert(info.hit);
 
- if (!actor.error_count)
+ if (!state.error_count)
         {
             parse_iterator pos = info.stop;
- std::string doc_type = pre(actor, pos, include_doc_id, nested_file);
+ std::string doc_type = pre(state, pos, include_doc_id, nested_file);
 
- info = cl::parse(info.hit ? info.stop : first, last, actor.grammar().block);
+ info = cl::parse(info.hit ? info.stop : first, last, state.grammar().block);
 
- post(actor, doc_type);
+ post(state, doc_type);
 
             if (!info.full)
             {
- file_position const& pos = actor.current_file->position_of(info.stop.base());
- detail::outerr(actor.current_file->path, pos.line)
+ file_position const& pos = state.current_file->position_of(info.stop.base());
+ detail::outerr(state.current_file->path, pos.line)
                     << "Syntax Error near column " << pos.column << ".\n";
- ++actor.error_count;
+ ++state.error_count;
             }
         }
     }
@@ -124,21 +124,21 @@
         int result = 0;
 
         try {
- actions actor(filein_, xinclude_base_, buffer, ids);
- set_macros(actor);
+ quickbook::state state(filein_, xinclude_base_, buffer, ids);
+ set_macros(state);
 
- if (actor.error_count == 0) {
- actor.current_file = load(filein_); // Throws load_error
+ if (state.error_count == 0) {
+ state.current_file = load(filein_); // Throws load_error
 
- parse_file(actor);
+ parse_file(state);
 
- if(actor.error_count) {
+ if(state.error_count) {
                     detail::outerr()
- << "Error count: " << actor.error_count << ".\n";
+ << "Error count: " << state.error_count << ".\n";
                 }
             }
 
- result = actor.error_count ? 1 : 0;
+ result = state.error_count ? 1 : 0;
         }
         catch (load_error& e) {
             detail::outerr(filein_) << detail::utf8(e.what()) << std::endl;

Modified: branches/quickbook-dev/tools/quickbook/src/quickbook.hpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/quickbook.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/quickbook.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -31,7 +31,7 @@
     extern std::vector<std::string> preset_defines;
     extern fs::path image_location;
 
- void parse_file(actions& actor,
+ void parse_file(quickbook::state& state,
             value include_doc_id = value(),
             bool nested_file = false);
     // Some initialisation methods

Copied: branches/quickbook-dev/tools/quickbook/src/state.cpp (from r76643, /branches/quickbook-dev/tools/quickbook/src/actions_class.cpp)
==============================================================================
--- /branches/quickbook-dev/tools/quickbook/src/actions_class.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/state.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -8,8 +8,8 @@
     License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
     http://www.boost.org/LICENSE_1_0.txt)
 =============================================================================*/
-#include "actions_class.hpp"
-#include "actions_state.hpp"
+#include "state.hpp"
+#include "state_save.hpp"
 #include "quickbook.hpp"
 #include "grammar.hpp"
 #include "input_path.hpp"
@@ -25,7 +25,7 @@
 
     unsigned qbk_version_n = 0; // qbk_major_version * 100 + qbk_minor_version
 
- actions::actions(fs::path const& filein_, fs::path const& xinclude_base_,
+ state::state(fs::path const& filein_, fs::path const& xinclude_base_,
             string_stream& out_, id_manager& ids)
         : grammar_()
 
@@ -60,63 +60,63 @@
             ("__TIME__", std::string(quickbook_get_time))
             ("__FILENAME__", detail::path_to_generic(filename_relative))
         ;
-
+
         boost::scoped_ptr<quickbook_grammar> g(
             new quickbook_grammar(*this));
         grammar_.swap(g);
     }
 
- quickbook_grammar& actions::grammar() const {
+ quickbook_grammar& state::grammar() const {
         return *grammar_;
     }
 
- file_state::file_state(actions& a, scope_flags scope)
- : a(a)
+ file_state::file_state(quickbook::state& state, scope_flags scope)
+ : state(state)
         , scope(scope)
         , qbk_version(qbk_version_n)
- , imported(a.imported)
- , current_file(a.current_file)
- , filename_relative(a.filename_relative)
- , xinclude_base(a.xinclude_base)
- , source_mode(a.source_mode)
+ , imported(state.imported)
+ , current_file(state.current_file)
+ , filename_relative(state.filename_relative)
+ , xinclude_base(state.xinclude_base)
+ , source_mode(state.source_mode)
         , macro()
     {
- if (scope & scope_macros) macro = a.macro;
- if (scope & scope_templates) a.templates.push();
+ if (scope & scope_macros) macro = state.macro;
+ if (scope & scope_templates) state.templates.push();
         if (scope & scope_output) {
- a.out.push();
- a.phrase.push();
+ state.out.push();
+ state.phrase.push();
         }
- a.values.builder.save();
+ state.values.builder.save();
     }
 
     file_state::~file_state()
     {
- a.values.builder.restore();
+ state.values.builder.restore();
         boost::swap(qbk_version_n, qbk_version);
- boost::swap(a.imported, imported);
- boost::swap(a.current_file, current_file);
- boost::swap(a.filename_relative, filename_relative);
- boost::swap(a.xinclude_base, xinclude_base);
- boost::swap(a.source_mode, source_mode);
+ boost::swap(state.imported, imported);
+ boost::swap(state.current_file, current_file);
+ boost::swap(state.filename_relative, filename_relative);
+ boost::swap(state.xinclude_base, xinclude_base);
+ boost::swap(state.source_mode, source_mode);
         if (scope & scope_output) {
- a.out.pop();
- a.phrase.pop();
+ state.out.pop();
+ state.phrase.pop();
         }
- if (scope & scope_templates) a.templates.pop();
- if (scope & scope_macros) a.macro = macro;
+ if (scope & scope_templates) state.templates.pop();
+ if (scope & scope_macros) state.macro = macro;
     }
-
- template_state::template_state(actions& a)
- : file_state(a, file_state::scope_all)
- , template_depth(a.template_depth)
- , min_section_level(a.min_section_level)
+
+ template_state::template_state(quickbook::state& state)
+ : file_state(state, file_state::scope_all)
+ , template_depth(state.template_depth)
+ , min_section_level(state.min_section_level)
     {
     }
 
     template_state::~template_state()
     {
- boost::swap(a.template_depth, template_depth);
- boost::swap(a.min_section_level, min_section_level);
+ boost::swap(state.template_depth, template_depth);
+ boost::swap(state.min_section_level, min_section_level);
     }
 }

Copied: branches/quickbook-dev/tools/quickbook/src/state.hpp (from r76643, /branches/quickbook-dev/tools/quickbook/src/actions_class.hpp)
==============================================================================
--- /branches/quickbook-dev/tools/quickbook/src/actions_class.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/state.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -22,9 +22,9 @@
     namespace cl = boost::spirit::classic;
     namespace fs = boost::filesystem;
 
- struct actions
+ struct state
     {
- actions(fs::path const& filein_, fs::path const& xinclude_base, string_stream& out_,
+ state(fs::path const& filein_, fs::path const& xinclude_base, string_stream& out_,
                 id_manager&);
 
     private:
@@ -38,7 +38,7 @@
         typedef std::vector<std::string> string_list;
 
         static int const max_template_depth = 100;
-
+
     // global state
         fs::path xinclude_base;
         template_stack templates;
@@ -91,4 +91,3 @@
 }
 
 #endif // BOOST_SPIRIT_ACTIONS_CLASS_HPP
-

Copied: branches/quickbook-dev/tools/quickbook/src/state_save.hpp (from r76643, /branches/quickbook-dev/tools/quickbook/src/actions_state.hpp)
==============================================================================
--- /branches/quickbook-dev/tools/quickbook/src/actions_state.hpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/state_save.hpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -10,13 +10,13 @@
 #if !defined(BOOST_SPIRIT_ACTIONS_STATE_HPP)
 #define BOOST_SPIRIT_ACTIONS_STATE_HPP
 
-#include "actions_class.hpp"
+#include "state.hpp"
 
 namespace quickbook
 {
     // State savers
     //
- // Defined in actions_class.cpp
+ // Defined in state.cpp
 
     struct file_state
     {
@@ -29,10 +29,10 @@
             scope_all = scope_callables + scope_output
         };
 
- explicit file_state(actions&, scope_flags);
+ explicit file_state(quickbook::state&, scope_flags);
         ~file_state();
 
- quickbook::actions& a;
+ quickbook::state& state;
         scope_flags scope;
         unsigned qbk_version;
         bool imported;
@@ -49,7 +49,7 @@
 
     struct template_state : file_state
     {
- explicit template_state(actions&);
+ explicit template_state(quickbook::state&);
         ~template_state();
 
         int template_depth;

Modified: branches/quickbook-dev/tools/quickbook/src/syntax_highlight.cpp
==============================================================================
--- branches/quickbook-dev/tools/quickbook/src/syntax_highlight.cpp (original)
+++ branches/quickbook-dev/tools/quickbook/src/syntax_highlight.cpp 2012-01-22 18:06:56 EST (Sun, 22 Jan 2012)
@@ -14,7 +14,7 @@
 #include <boost/spirit/include/classic_loops.hpp>
 #include "grammar.hpp"
 #include "grammar_impl.hpp" // Just for context stuff. Should move?
-#include "actions_class.hpp"
+#include "state.hpp"
 #include "actions.hpp"
 #include "utils.hpp"
 #include "files.hpp"
@@ -24,10 +24,6 @@
 {
     namespace cl = boost::spirit::classic;
 
- // quickbook::actions is used in a few places here, as 'escape_actions'.
- // It's named differently to distinguish it from the syntax highlighting
- // actions, declared below.
-
     template <typename T, typename Value>
     struct member_action_value
     {
@@ -92,19 +88,18 @@
     struct syntax_highlight_actions
     {
         quickbook::collector out;
- quickbook::actions& escape_actions;
+ quickbook::state& state;
         do_macro_action do_macro_impl;
 
         // State
         bool support_callouts;
         string_ref marked_text;
 
- syntax_highlight_actions(quickbook::actions& escape_actions,
- bool is_block) :
- out(), escape_actions(escape_actions),
- do_macro_impl(out, escape_actions),
+ syntax_highlight_actions(quickbook::state& state, bool is_block) :
+ out(), state(state),
+ do_macro_impl(out, state),
             support_callouts(is_block && (qbk_version_n >= 107u ||
- escape_actions.current_file->is_code_snippets)),
+ state.current_file->is_code_snippets)),
             marked_text()
         {}
 
@@ -149,9 +144,9 @@
     void syntax_highlight_actions::unexpected_char(parse_iterator first,
             parse_iterator last)
     {
- file_position const pos = escape_actions.current_file->position_of(first.base());
+ file_position const pos = state.current_file->position_of(first.base());
 
- detail::outwarn(escape_actions.current_file->path, pos.line)
+ detail::outwarn(state.current_file->path, pos.line)
             << "in column:" << pos.column
             << ", unexpected character: " << detail::utf8(first, last)
             << "\n";
@@ -173,14 +168,14 @@
     void syntax_highlight_actions::pre_escape_back(parse_iterator,
             parse_iterator)
     {
- escape_actions.phrase.push(); // save the stream
+ state.phrase.push(); // save the stream
     }
 
     void syntax_highlight_actions::post_escape_back(parse_iterator,
             parse_iterator)
     {
- out << escape_actions.phrase.str();
- escape_actions.phrase.pop(); // restore the stream
+ out << state.phrase.str();
+ state.phrase.pop(); // restore the stream
     }
 
     void syntax_highlight_actions::do_macro(std::string const& v)
@@ -196,7 +191,7 @@
 
     void syntax_highlight_actions::callout(parse_iterator, parse_iterator)
     {
- out << escape_actions.add_callout(qbk_value(escape_actions.current_file,
+ out << state.add_callout(qbk_value(state.current_file,
             marked_text.begin(), marked_text.end()));
         marked_text.clear();
     }
@@ -258,7 +253,7 @@
         struct definition
         {
             definition(cpp_highlight const& self)
- : g(self.actions.escape_actions.grammar())
+ : g(self.actions.state.grammar())
             {
                 member_action1<syntax_highlight_actions, char const*>
                     span(self.actions, &syntax_highlight_actions::span),
@@ -273,7 +268,7 @@
                     callout(self.actions, &syntax_highlight_actions::callout);
                 member_action_value<syntax_highlight_actions, std::string const&>
                     do_macro(self.actions, &syntax_highlight_actions::do_macro);
- error_action error(self.actions.escape_actions);
+ error_action error(self.actions.state);
 
                 program
                     =
@@ -298,9 +293,9 @@
 
                 macro =
                     // must not be followed by alpha or underscore
- cl::eps_p(self.actions.escape_actions.macro
+ cl::eps_p(self.actions.state.macro
>> (cl::eps_p - (cl::alpha_p | '_')))
- >> self.actions.escape_actions.macro
+ >> self.actions.state.macro
                                                         [do_macro]
                     ;
 
@@ -419,7 +414,7 @@
         struct definition
         {
             definition(python_highlight const& self)
- : g(self.actions.escape_actions.grammar())
+ : g(self.actions.state.grammar())
             {
                 member_action1<syntax_highlight_actions, char const*>
                     span(self.actions, &syntax_highlight_actions::span),
@@ -434,7 +429,7 @@
                     callout(self.actions, &syntax_highlight_actions::callout);
                 member_action_value<syntax_highlight_actions, std::string const&>
                     do_macro(self.actions, &syntax_highlight_actions::do_macro);
- error_action error(self.actions.escape_actions);
+ error_action error(self.actions.state);
 
                 program
                     =
@@ -453,9 +448,9 @@
 
                 macro =
                     // must not be followed by alpha or underscore
- cl::eps_p(self.actions.escape_actions.macro
+ cl::eps_p(self.actions.state.macro
>> (cl::eps_p - (cl::alpha_p | '_')))
- >> self.actions.escape_actions.macro
+ >> self.actions.state.macro
                                                         [do_macro]
                     ;
 
@@ -555,7 +550,7 @@
         struct definition
         {
             definition(teletype_highlight const& self)
- : g(self.actions.escape_actions.grammar())
+ : g(self.actions.state.grammar())
             {
                 member_action<syntax_highlight_actions>
                     plain_char(self.actions, &syntax_highlight_actions::plain_char),
@@ -563,7 +558,7 @@
                     post_escape_back(self.actions, &syntax_highlight_actions::post_escape_back);
                 member_action_value<syntax_highlight_actions, std::string const&>
                     do_macro(self.actions, &syntax_highlight_actions::do_macro);
- error_action error(self.actions.escape_actions);
+ error_action error(self.actions.state);
 
                 program
                     =
@@ -575,9 +570,9 @@
 
                 macro =
                     // must not be followed by alpha or underscore
- cl::eps_p(self.actions.escape_actions.macro
+ cl::eps_p(self.actions.state.macro
>> (cl::eps_p - (cl::alpha_p | '_')))
- >> self.actions.escape_actions.macro
+ >> self.actions.state.macro
                                                         [do_macro]
                     ;
 
@@ -615,11 +610,11 @@
     std::string syntax_highlight(
         parse_iterator first,
         parse_iterator last,
- actions& escape_actions,
+ quickbook::state& state,
         std::string const& source_mode,
         bool is_block)
     {
- syntax_highlight_actions syn_actions(escape_actions, is_block);
+ syntax_highlight_actions syn_actions(state, is_block);
 
         // print the code with syntax coloring
         if (source_mode == "c++")


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