243 lines
7.8 KiB
C++
243 lines
7.8 KiB
C++
// Copyright (c) 2001-2011 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)
|
|
|
|
#if !defined(BOOST_SPIRIT_LEX_CHAR_TOKEN_DEF_MAR_28_2007_0626PM)
|
|
#define BOOST_SPIRIT_LEX_CHAR_TOKEN_DEF_MAR_28_2007_0626PM
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <boost/spirit/home/support/common_terminals.hpp>
|
|
#include <boost/spirit/home/support/string_traits.hpp>
|
|
#include <boost/spirit/home/lex/domain.hpp>
|
|
#include <boost/spirit/home/lex/lexer_type.hpp>
|
|
#include <boost/spirit/home/lex/meta_compiler.hpp>
|
|
|
|
namespace boost { namespace spirit
|
|
{
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Enablers
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
// enables 'x'
|
|
template <>
|
|
struct use_terminal<lex::domain, char>
|
|
: mpl::true_ {};
|
|
|
|
// enables "x"
|
|
template <>
|
|
struct use_terminal<lex::domain, char[2]>
|
|
: mpl::true_ {};
|
|
|
|
// enables wchar_t
|
|
template <>
|
|
struct use_terminal<lex::domain, wchar_t>
|
|
: mpl::true_ {};
|
|
|
|
// enables L"x"
|
|
template <>
|
|
struct use_terminal<lex::domain, wchar_t[2]>
|
|
: mpl::true_ {};
|
|
|
|
// enables char_('x'), char_("x")
|
|
template <typename CharEncoding, typename A0>
|
|
struct use_terminal<lex::domain
|
|
, terminal_ex<
|
|
tag::char_code<tag::char_, CharEncoding>
|
|
, fusion::vector1<A0> > >
|
|
: mpl::true_ {};
|
|
|
|
// enables char_('x', ID), char_("x", ID)
|
|
template <typename CharEncoding, typename A0, typename A1>
|
|
struct use_terminal<lex::domain
|
|
, terminal_ex<
|
|
tag::char_code<tag::char_, CharEncoding>
|
|
, fusion::vector2<A0, A1> > >
|
|
: mpl::true_ {};
|
|
}}
|
|
|
|
namespace boost { namespace spirit { namespace lex
|
|
{
|
|
// use char_ from standard character set by default
|
|
#ifndef BOOST_SPIRIT_NO_PREDEFINED_TERMINALS
|
|
using spirit::standard::char_;
|
|
#endif
|
|
using spirit::standard::char_type;
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// char_token_def
|
|
// represents a single character token definition
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////
|
|
template <typename CharEncoding = char_encoding::standard
|
|
, typename IdType = std::size_t>
|
|
struct char_token_def
|
|
: primitive_lexer<char_token_def<CharEncoding, IdType> >
|
|
{
|
|
typedef typename CharEncoding::char_type char_type;
|
|
|
|
char_token_def(char_type ch, IdType const& id)
|
|
: ch(ch), id_(id), unique_id_(std::size_t(~0))
|
|
, token_state_(std::size_t(~0))
|
|
{}
|
|
|
|
template <typename LexerDef, typename String>
|
|
void collect(LexerDef& lexdef, String const& state
|
|
, String const& targetstate) const
|
|
{
|
|
std::size_t state_id = lexdef.add_state(state.c_str());
|
|
|
|
// If the following assertion fires you are probably trying to use
|
|
// a single char_token_def instance in more than one lexer state.
|
|
// This is not possible. Please create a separate token_def instance
|
|
// from the same regular expression for each lexer state it needs
|
|
// to be associated with.
|
|
BOOST_ASSERT(
|
|
(std::size_t(~0) == token_state_ || state_id == token_state_) &&
|
|
"Can't use single char_token_def with more than one lexer state");
|
|
|
|
char_type const* target = targetstate.empty() ? 0 : targetstate.c_str();
|
|
if (target)
|
|
lexdef.add_state(target);
|
|
|
|
token_state_ = state_id;
|
|
unique_id_ = lexdef.add_token (state.c_str(), ch, id_, target);
|
|
}
|
|
|
|
template <typename LexerDef>
|
|
void add_actions(LexerDef&) const {}
|
|
|
|
IdType id() const { return id_; }
|
|
std::size_t unique_id() const { return unique_id_; }
|
|
std::size_t state() const { return token_state_; }
|
|
|
|
char_type ch;
|
|
mutable IdType id_;
|
|
mutable std::size_t unique_id_;
|
|
mutable std::size_t token_state_;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Lexer generators: make_xxx function (objects)
|
|
///////////////////////////////////////////////////////////////////////////
|
|
namespace detail
|
|
{
|
|
template <typename CharEncoding>
|
|
struct basic_literal
|
|
{
|
|
typedef char_token_def<CharEncoding> result_type;
|
|
|
|
template <typename Char>
|
|
result_type operator()(Char ch, unused_type) const
|
|
{
|
|
return result_type(ch, ch);
|
|
}
|
|
|
|
template <typename Char>
|
|
result_type operator()(Char const* str, unused_type) const
|
|
{
|
|
return result_type(str[0], str[0]);
|
|
}
|
|
};
|
|
}
|
|
|
|
// literals: 'x', "x"
|
|
template <typename Modifiers>
|
|
struct make_primitive<char, Modifiers>
|
|
: detail::basic_literal<char_encoding::standard> {};
|
|
|
|
template <typename Modifiers>
|
|
struct make_primitive<char const(&)[2], Modifiers>
|
|
: detail::basic_literal<char_encoding::standard> {};
|
|
|
|
// literals: L'x', L"x"
|
|
template <typename Modifiers>
|
|
struct make_primitive<wchar_t, Modifiers>
|
|
: detail::basic_literal<char_encoding::standard_wide> {};
|
|
|
|
template <typename Modifiers>
|
|
struct make_primitive<wchar_t const(&)[2], Modifiers>
|
|
: detail::basic_literal<char_encoding::standard_wide> {};
|
|
|
|
// handle char_('x')
|
|
template <typename CharEncoding, typename Modifiers, typename A0>
|
|
struct make_primitive<
|
|
terminal_ex<
|
|
tag::char_code<tag::char_, CharEncoding>
|
|
, fusion::vector1<A0>
|
|
>
|
|
, Modifiers>
|
|
{
|
|
typedef char_token_def<CharEncoding> result_type;
|
|
|
|
template <typename Terminal>
|
|
result_type operator()(Terminal const& term, unused_type) const
|
|
{
|
|
return result_type(fusion::at_c<0>(term.args), fusion::at_c<0>(term.args));
|
|
}
|
|
};
|
|
|
|
// handle char_("x")
|
|
template <typename CharEncoding, typename Modifiers, typename Char>
|
|
struct make_primitive<
|
|
terminal_ex<
|
|
tag::char_code<tag::char_, CharEncoding>
|
|
, fusion::vector1<Char(&)[2]> // single char strings
|
|
>
|
|
, Modifiers>
|
|
{
|
|
typedef char_token_def<CharEncoding> result_type;
|
|
|
|
template <typename Terminal>
|
|
result_type operator()(Terminal const& term, unused_type) const
|
|
{
|
|
Char ch = fusion::at_c<0>(term.args)[0];
|
|
return result_type(ch, ch);
|
|
}
|
|
};
|
|
|
|
// handle char_('x', ID)
|
|
template <typename CharEncoding, typename Modifiers, typename A0, typename A1>
|
|
struct make_primitive<
|
|
terminal_ex<
|
|
tag::char_code<tag::char_, CharEncoding>
|
|
, fusion::vector2<A0, A1>
|
|
>
|
|
, Modifiers>
|
|
{
|
|
typedef char_token_def<CharEncoding> result_type;
|
|
|
|
template <typename Terminal>
|
|
result_type operator()(Terminal const& term, unused_type) const
|
|
{
|
|
return result_type(
|
|
fusion::at_c<0>(term.args), fusion::at_c<1>(term.args));
|
|
}
|
|
};
|
|
|
|
// handle char_("x", ID)
|
|
template <typename CharEncoding, typename Modifiers, typename Char, typename A1>
|
|
struct make_primitive<
|
|
terminal_ex<
|
|
tag::char_code<tag::char_, CharEncoding>
|
|
, fusion::vector2<Char(&)[2], A1> // single char strings
|
|
>
|
|
, Modifiers>
|
|
{
|
|
typedef char_token_def<CharEncoding> result_type;
|
|
|
|
template <typename Terminal>
|
|
result_type operator()(Terminal const& term, unused_type) const
|
|
{
|
|
return result_type(
|
|
fusion::at_c<0>(term.args)[0], fusion::at_c<1>(term.args));
|
|
}
|
|
};
|
|
}}} // namespace boost::spirit::lex
|
|
|
|
#endif
|