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 "<"... 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(¤t_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++")