comparison DEPENDENCIES/generic/include/boost/spirit/home/classic/symbols/symbols.hpp @ 16:2665513ce2d3

Add boost headers

+/*=============================================================================
+    Copyright (c) 2001-2003 Joel de Guzman
+    http://spirit.sourceforge.net/
+
+  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)
+=============================================================================*/
+#ifndef BOOST_SPIRIT_SYMBOLS_HPP
+#define BOOST_SPIRIT_SYMBOLS_HPP
+
+///////////////////////////////////////////////////////////////////////////////
+#include <string>
+
+#include <boost/ref.hpp>
+
+#include <boost/spirit/home/classic/namespace.hpp>
+#include <boost/spirit/home/classic/core/parser.hpp>
+#include <boost/spirit/home/classic/core/composite/directives.hpp>
+
+#include <boost/spirit/home/classic/symbols/symbols_fwd.hpp>
+
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost { namespace spirit {
+
+BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN
+
+///////////////////////////////////////////////////////////////////////////////
+//
+//  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;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+BOOST_SPIRIT_CLASSIC_NAMESPACE_END
+
+}} // namespace BOOST_SPIRIT_CLASSIC_NS
+
+#include <boost/spirit/home/classic/symbols/impl/symbols.ipp>
+#endif