[Boost-commit] svn:boost r57299 - in trunk/libs/spirit/test: . lex

Subject: [Boost-commit] svn:boost r57299 - in trunk/libs/spirit/test: . lex
From: hartmut.kaiser_at_[hidden]
Date: 2009-11-02 20:54:02

Author: hkaiser
Date: 2009-11-02 20:54:01 EST (Mon, 02 Nov 2009)
New Revision: 57299
URL: http://svn.boost.org/trac/boost/changeset/57299

Log:
Spirit: added new lexer test
Added:
   trunk/libs/spirit/test/lex/semantic_actions.cpp   (contents, props changed)
Text files modified: 
   trunk/libs/spirit/test/Jamfile |     1 +                                       
   1 files changed, 1 insertions(+), 0 deletions(-)

Modified: trunk/libs/spirit/test/Jamfile
==============================================================================
--- trunk/libs/spirit/test/Jamfile	(original)
+++ trunk/libs/spirit/test/Jamfile	2009-11-02 20:54:01 EST (Mon, 02 Nov 2009)
@@ -122,6 +122,7 @@
     [ run lex/set_token_value.cpp           : : : : ]
     [ run lex/dedent_handling_phoenix.cpp   : : : : ]
     [ run lex/set_token_value_phoenix.cpp   : : : : ]
+    [ run lex/semantic_actions.cpp          : : : : ]
 
     [ run lex/regression001.cpp             : : : : lex_regression001 ]
     [ run lex/regression002.cpp             : : : : lex_regression002 ]

Added: trunk/libs/spirit/test/lex/semantic_actions.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/spirit/test/lex/semantic_actions.cpp	2009-11-02 20:54:01 EST (Mon, 02 Nov 2009)
@@ -0,0 +1,300 @@
+//  Copyright (c) 2001-2009 Hartmut Kaiser
+//
+//  Distributed under the Boost Software License, Version 1.0. (See accompanying
+//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/config/warning_disable.hpp>
+
+#include <boost/spirit/include/lex_lexertl.hpp>
+
+namespace lex = boost::spirit::lex;
+
+typedef lex::lexertl::token<std::string::iterator> token_type;
+typedef lex::lexertl::actor_lexer<token_type> lexer_type;
+
+///////////////////////////////////////////////////////////////////////////////
+static bool found_identifier_flag = false;
+
+///////////////////////////////////////////////////////////////////////////////
+void found_identifier_sa0()
+{
+    found_identifier_flag = true;
+}
+
+template <typename Lexer>
+struct lexer_sa0 : lex::lexer<Lexer>
+{
+    lexer_sa0() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [&found_identifier_sa0];
+    }
+    lex::token_def<> identifier;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+static std::string found_identifier_str;
+
+void found_identifier_sa2(std::string::iterator& start
+  , std::string::iterator& end)
+{
+    found_identifier_flag = true;
+    found_identifier_str = std::string(start, end);
+}
+
+template <typename Lexer>
+struct lexer_sa2 : lex::lexer<Lexer>
+{
+    lexer_sa2() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [&found_identifier_sa2];
+    }
+    lex::token_def<> identifier;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+void found_identifier_sa3_normal(std::string::iterator& start
+  , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass)
+{
+    BOOST_TEST(pass == lex::pass_flags::pass_normal);
+
+    found_identifier_flag = true;
+    found_identifier_str = std::string(start, end);
+}
+
+template <typename Lexer>
+struct lexer_sa3_normal : lex::lexer<Lexer>
+{
+    lexer_sa3_normal() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [&found_identifier_sa3_normal];
+    }
+    lex::token_def<> identifier;
+};
+
+void found_identifier_sa3_fail(std::string::iterator&, std::string::iterator&
+  , BOOST_SCOPED_ENUM(lex::pass_flags)& pass)
+{
+    pass = lex::pass_flags::pass_fail;
+}
+
+template <typename Lexer>
+struct lexer_sa3_fail : lex::lexer<Lexer>
+{
+    lexer_sa3_fail() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [&found_identifier_sa3_fail];
+    }
+    lex::token_def<> identifier;
+};
+
+void found_identifier_sa3_ignore(std::string::iterator&, std::string::iterator&
+  , BOOST_SCOPED_ENUM(lex::pass_flags)& pass)
+{
+    pass = lex::pass_flags::pass_ignore;
+}
+
+template <typename Lexer>
+struct lexer_sa3_ignore : lex::lexer<Lexer>
+{
+    lexer_sa3_ignore() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [&found_identifier_sa3_ignore];
+    }
+    lex::token_def<> identifier;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+static std::size_t found_identifier_id = 0;
+
+void found_identifier_sa4(std::string::iterator& start
+  , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass
+  , std::size_t id)
+{
+    BOOST_TEST(pass == lex::pass_flags::pass_normal);
+
+    found_identifier_flag = true;
+    found_identifier_str = std::string(start, end);
+    found_identifier_id = id;
+}
+
+template <typename Lexer>
+struct lexer_sa4 : lex::lexer<Lexer>
+{
+    lexer_sa4() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [&found_identifier_sa4];
+    }
+    lex::token_def<> identifier;
+};
+
+void found_identifier_sa4_id(std::string::iterator& start
+  , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass
+  , std::size_t& id)
+{
+    BOOST_TEST(pass == lex::pass_flags::pass_normal);
+
+    found_identifier_flag = true;
+    found_identifier_str = std::string(start, end);
+    found_identifier_id = id;
+    id = 1;
+}
+
+template <typename Lexer>
+struct lexer_sa4_id : lex::lexer<Lexer>
+{
+    lexer_sa4_id() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [&found_identifier_sa4_id];
+    }
+    lex::token_def<> identifier;
+};
+
+static std::size_t found_identifier_id2 = 0;
+
+bool identifier_token(token_type const& t)
+{
+    found_identifier_id2 = t.id();
+    return true;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+struct found_identifier_sa5
+{
+    template <typename Context>
+    void operator()(std::string::iterator& start
+      , std::string::iterator& end, BOOST_SCOPED_ENUM(lex::pass_flags)& pass
+      , std::size_t& id, Context& ctx)
+    {
+        BOOST_TEST(pass == lex::pass_flags::pass_normal);
+
+        found_identifier_flag = true;
+        found_identifier_str = std::string(ctx.get_value().begin(), ctx.get_value().end());
+    }
+};
+
+template <typename Lexer>
+struct lexer_sa5 : lex::lexer<Lexer>
+{
+    lexer_sa5() 
+    {
+        identifier = "[a-zA-Z][_a-zA-Z0-9]*";
+        this->self += identifier [found_identifier_sa5()];
+    }
+    lex::token_def<> identifier;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+int main()
+{
+    std::string identifier ("id_1234");
+    std::string::iterator first = identifier.begin();
+    std::string::iterator last = identifier.end();
+
+    // test semantic action taking no arguments
+    found_identifier_flag = false;
+    {
+        lexer_sa0<lexer_type> sa0;
+        BOOST_TEST(lex::tokenize(first, last, sa0));
+        BOOST_TEST(first == last);
+        BOOST_TEST(found_identifier_flag);
+    }
+
+    // test semantic action taking two arguments (iterator pair for matched 
+    // sequence)
+    found_identifier_flag = false;
+    found_identifier_str.clear();
+    first = identifier.begin();
+    {
+        lexer_sa2<lexer_type> sa2;
+        BOOST_TEST(lex::tokenize(first, last, sa2));
+        BOOST_TEST(first == last);
+        BOOST_TEST(found_identifier_flag);
+        BOOST_TEST(found_identifier_str == identifier);
+    }
+
+    // test semantic action taking three arguments (iterator pair for matched 
+    // sequence and pass_flags) - pass_flags::pass_normal
+    found_identifier_flag = false;
+    found_identifier_str.clear();
+    first = identifier.begin();
+    {
+        lexer_sa3_normal<lexer_type> sa3;
+        BOOST_TEST(lex::tokenize(first, last, sa3));
+        BOOST_TEST(first == last);
+        BOOST_TEST(found_identifier_flag);
+        BOOST_TEST(found_identifier_str == identifier);
+    }
+
+    // test semantic action taking three arguments (iterator pair for matched 
+    // sequence and pass_flags) - pass_flags::pass_fail
+    first = identifier.begin();
+    {
+        lexer_sa3_fail<lexer_type> sa3;
+        BOOST_TEST(!lex::tokenize(first, last, sa3));
+        BOOST_TEST(first != last);
+    }
+
+    // test semantic action taking three arguments (iterator pair for matched 
+    // sequence and pass_flags) - pass_flags::pass_ignore
+    first = identifier.begin();
+    {
+        lexer_sa3_ignore<lexer_type> sa3;
+        BOOST_TEST(lex::tokenize(first, last, sa3));
+        BOOST_TEST(first == last);
+    }
+
+    // test semantic action taking four arguments (iterator pair for matched 
+    // sequence and pass_flags, and token id)
+    found_identifier_flag = false;
+    found_identifier_str.clear();
+    first = identifier.begin();
+    found_identifier_id = 0;
+    {
+        lexer_sa4<lexer_type> sa4;
+        BOOST_TEST(lex::tokenize(first, last, sa4));
+        BOOST_TEST(first == last);
+        BOOST_TEST(found_identifier_flag);
+        BOOST_TEST(found_identifier_str == identifier);
+        BOOST_TEST(found_identifier_id == lex::min_token_id);
+    }
+
+    found_identifier_flag = false;
+    found_identifier_str.clear();
+    first = identifier.begin();
+    found_identifier_id = 0;
+    found_identifier_id2 = 0;
+    {
+        lexer_sa4_id<lexer_type> sa4;
+        BOOST_TEST(lex::tokenize(first, last, sa4, identifier_token));
+        BOOST_TEST(first == last);
+        BOOST_TEST(found_identifier_flag);
+        BOOST_TEST(found_identifier_str == identifier);
+        BOOST_TEST(found_identifier_id == lex::min_token_id);
+        BOOST_TEST(found_identifier_id2 == 1);
+    }
+
+    // test semantic action taking four arguments (iterator pair for matched 
+    // sequence and pass_flags, token id, and context)
+    found_identifier_flag = false;
+    found_identifier_str.clear();
+    first = identifier.begin();
+    found_identifier_id = 0;
+    found_identifier_id2 = 0;
+    {
+        lexer_sa5<lexer_type> sa5;
+        BOOST_TEST(lex::tokenize(first, last, sa5));
+        BOOST_TEST(first == last);
+        BOOST_TEST(found_identifier_flag);
+        BOOST_TEST(found_identifier_str == identifier);
+    }
+
+    return boost::report_errors();
+}