/*=============================================================================

     Copyright (c) 2001-2003 Joel de Guzman

     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)

 =============================================================================*/

 #ifndef BOOST_SPIRIT_SYMBOLS_HPP

 #define BOOST_SPIRIT_SYMBOLS_HPP

 ///////////////////////////////////////////////////////////////////////////////

 #include <string>

 #include <boost/ref.hpp>

 #include <boost/spirit/core/parser.hpp>

 #include <boost/spirit/core/composite/directives.hpp>

 #include <boost/spirit/symbols/symbols_fwd.hpp>

 ///////////////////////////////////////////////////////////////////////////////

 namespace boost { namespace spirit {

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  symbols class

 //

 //      This class implements a symbol table. The symbol table holds a

 //      dictionary of symbols where each symbol is a sequence of CharTs.

 //      The template class can work efficiently with 8, 16 and 32 bit

 //      characters. Mutable data of type T is associated with each

 //      symbol.

 //

 //      The class is a parser. The parse member function returns

 //      additional information in the symbol_match class (see below).

 //      The additional data is a pointer to some data associated with

 //      the matching symbol.

 //

 //      The actual set implementation is supplied by the SetT template

 //      parameter. By default, this uses the tst class (see tst.ipp).

 //

 //      Symbols are added into the symbol table statically using the

 //      construct:

 //

 //          sym = a, b, c, d ...;

 //

 //      where sym is a symbol table and a..d are strings. Example:

 //

 //          sym = "pineapple", "orange", "banana", "apple";

 //

 //      Alternatively, symbols may be added dynamically through the

 //      member functor 'add' (see symbol_inserter below). The member

 //      functor 'add' may be attached to a parser as a semantic action

 //      taking in a begin/end pair:

 //

 //          p[sym.add]

 //

 //      where p is a parser (and sym is a symbol table). On success,

 //      the matching portion of the input is added to the symbol table.

 //

 //      'add' may also be used to directly initialize data. Examples:

 //

 //          sym.add("hello", 1)("crazy", 2)("world", 3);

 //

 ///////////////////////////////////////////////////////////////////////////////

 template <typename T, typename CharT, typename SetT>

 class symbols

 :   private SetT

 ,   public parser<symbols<T, CharT, SetT> >

 {

 public:

     typedef parser<symbols<T, CharT, SetT> > parser_base_t;

     typedef symbols<T, CharT, SetT> self_t;

     typedef self_t const& embed_t;

     typedef T symbol_data_t;

     typedef boost::reference_wrapper<T> symbol_ref_t;

     symbols();

     symbols(symbols const& other);

     ~symbols();

     symbols&

     operator=(symbols const& other);

     symbol_inserter<T, SetT> const&

     operator=(CharT const* str);

     template <typename ScannerT>

     struct result

     {

         typedef typename match_result<ScannerT, symbol_ref_t>::type type;

     };

     template <typename ScannerT>

     typename parser_result<self_t, ScannerT>::type

     parse_main(ScannerT const& scan) const

     {

         typedef typename ScannerT::iterator_t iterator_t;

         iterator_t first = scan.first;

         typename SetT::search_info result = SetT::find(scan);

         if (result.data)

             return scan.

                 create_match(

                     result.length,

                     symbol_ref_t(*result.data),

                     first,

                     scan.first);

         else

             return scan.no_match();

     }

     template <typename ScannerT>

     typename parser_result<self_t, ScannerT>::type

     parse(ScannerT const& scan) const

     {

         typedef typename parser_result<self_t, ScannerT>::type result_t;

         return impl::implicit_lexeme_parse<result_t>

             (*this, scan, scan);

     }

     template < typename ScannerT >

     T* find(ScannerT const& scan) const

     { return SetT::find(scan).data; }

     symbol_inserter<T, SetT> const add;

 };

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  Symbol table utilities

 //

 //  add

 //

 //      adds a symbol 'sym' (string) to a symbol table 'table' plus an

 //      optional data 'data' associated with the symbol. Returns a pointer to

 //      the data associated with the symbol or NULL if add failed (e.g. when

 //      the symbol is already added before).

 //

 //  find

 //

 //      finds a symbol 'sym' (string) from a symbol table 'table'. Returns a

 //      pointer to the data associated with the symbol or NULL if not found

 //

 ///////////////////////////////////////////////////////////////////////////////

 template <typename T, typename CharT, typename SetT>

 T*  add(symbols<T, CharT, SetT>& table, CharT const* sym, T const& data = T());

 template <typename T, typename CharT, typename SetT>

 T*  find(symbols<T, CharT, SetT> const& table, CharT const* sym);

 ///////////////////////////////////////////////////////////////////////////////

 //

 //  symbol_inserter class

 //

 //      The symbols class holds an instance of this class named 'add'.

 //      This can be called directly just like a member function,

 //      passing in a first/last iterator and optional data:

 //

 //          sym.add(first, last, data);

 //

 //      Or, passing in a C string and optional data:

 //

 //          sym.add(c_string, data);

 //

 //      where sym is a symbol table. The 'data' argument is optional.

 //      This may also be used as a semantic action since it conforms

 //      to the action interface (see action.hpp):

 //

 //          p[sym.add]

 //

 ///////////////////////////////////////////////////////////////////////////////

 template <typename T, typename SetT>

 class symbol_inserter

 {

 public:

     symbol_inserter(SetT& set_)

     : set(set_) {}

     typedef symbol_inserter const & result_type;

     template <typename IteratorT>

     symbol_inserter const&

     operator()(IteratorT first, IteratorT const& last, T const& data = T()) const

     {

         set.add(first, last, data);

         return *this;

     }

     template <typename CharT>

     symbol_inserter const&

     operator()(CharT const* str, T const& data = T()) const

     {

         CharT const* last = str;

         while (*last)

             last++;

         set.add(str, last, data);

         return *this;

     }

     template <typename CharT>

     symbol_inserter const&

     operator,(CharT const* str) const

     {

         CharT const* last = str;

         while (*last)

             last++;

         set.add(str, last, T());

         return *this;

     }

 private:

     SetT& set;

 };

 ///////////////////////////////////////////////////////////////////////////////

 }} // namespace boost::spirit

 #include <boost/spirit/symbols/impl/symbols.ipp>

 #endif