Added boost header

test/external/boost/wave/cpplexer/detect_include_guards.hpp

@@ -0,0 +1,263 @@
+/*=============================================================================
+    Boost.Wave: A Standard compliant C++ preprocessor library
+
+    http://www.boost.org/
+
+    State machine detecting include guards in an included file. 
+    This detects two forms of include guards:
+
+        #ifndef INCLUDE_GUARD_MACRO
+        #define INCLUDE_GUARD_MACRO
+        ...
+        #endif
+
+    or
+
+        if !defined(INCLUDE_GUARD_MACRO)
+        #define INCLUDE_GUARD_MACRO
+        ...
+        #endif
+
+    note, that the parenthesis are optional (i.e. !defined INCLUDE_GUARD_MACRO
+    will work as well). The code allows for any whitespace, newline and single 
+    '#' tokens before the #if/#ifndef and after the final #endif.
+
+    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(DETECT_INCLUDE_GUARDS_HK060304_INCLUDED)
+#define DETECT_INCLUDE_GUARDS_HK060304_INCLUDED
+
+#include <boost/wave/wave_config.hpp>
+#include <boost/wave/token_ids.hpp>
+
+// this must occur after all of the includes and before any code appears
+#ifdef BOOST_HAS_ABI_HEADERS
+#include BOOST_ABI_PREFIX
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+namespace boost {
+namespace wave {
+namespace cpplexer {
+
+template <typename Token>
+class include_guards
+{
+public:
+    include_guards()
+    :   state(&include_guards::state_0), detected_guards(false), 
+        current_state(true), if_depth(0)
+    {}
+
+    Token& detect_guard(Token& t) 
+        { return current_state ? (this->*state)(t) : t; }
+    bool detected(std::string& guard_name_) const 
+    {
+        if (detected_guards) {
+            guard_name_ = guard_name.c_str();
+            return true;
+        }
+        return false; 
+    }
+
+private:
+    typedef Token& state_type(Token& t);
+    state_type include_guards::* state;
+
+    bool detected_guards;
+    bool current_state;
+    typename Token::string_type guard_name;
+    int if_depth;
+
+    state_type state_0, state_1, state_2, state_3, state_4, state_5;
+    state_type state_1a, state_1b, state_1c, state_1d, state_1e;
+
+    bool is_skippable(token_id id) const
+    {
+        return (T_POUND == BASE_TOKEN(id) || 
+                IS_CATEGORY(id, WhiteSpaceTokenType) ||
+                IS_CATEGORY(id, EOLTokenType));
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 0: beginning of a file, tries to recognize #ifndef or #if tokens
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_0(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_PP_IFNDEF == id)
+        state = &include_guards::state_1;
+    else if (T_PP_IF == id)
+        state = &include_guards::state_1a;
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 1: found #ifndef, looking for T_IDENTIFIER
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_1(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_IDENTIFIER == id) {
+        guard_name = t.get_value();
+        state = &include_guards::state_2;
+    }
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 1a: found T_PP_IF, looking for T_NOT ("!")
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_1a(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_NOT == BASE_TOKEN(id)) 
+        state = &include_guards::state_1b;
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 1b: found T_NOT, looking for 'defined'
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_1b(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_IDENTIFIER == id && t.get_value() == "defined") 
+        state = &include_guards::state_1c;
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 1c: found 'defined', looking for (optional) T_LEFTPAREN
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_1c(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_LEFTPAREN == id) 
+        state = &include_guards::state_1d;
+    else if (T_IDENTIFIER == id) {
+        guard_name = t.get_value();
+        state = &include_guards::state_2;
+    }
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 1d: found T_LEFTPAREN, looking for T_IDENTIFIER guard
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_1d(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_IDENTIFIER == id) {
+        guard_name = t.get_value();
+        state = &include_guards::state_1e;
+    }
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 1e: found T_IDENTIFIER guard, looking for T_RIGHTPAREN
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_1e(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_RIGHTPAREN == id) 
+        state = &include_guards::state_2;
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 2: found T_IDENTIFIER, looking for #define
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_2(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_PP_DEFINE == id) 
+        state = &include_guards::state_3;
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 3: found #define, looking for T_IDENTIFIER as recognized by state 1
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_3(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_IDENTIFIER == id && t.get_value() == guard_name)
+        state = &include_guards::state_4;
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 4: found guard T_IDENTIFIER, looking for #endif
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_4(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_PP_IF == id || T_PP_IFDEF == id || T_PP_IFNDEF == id)
+        ++if_depth;
+    else if (T_PP_ENDIF == id) {
+        if (if_depth > 0)
+            --if_depth;
+        else
+            state = &include_guards::state_5;
+    }
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  state 5: found final #endif, looking for T_EOF
+template <typename Token>
+inline Token& 
+include_guards<Token>::state_5(Token& t)
+{
+    token_id id = token_id(t);
+    if (T_EOF == id) 
+        detected_guards = current_state;
+    else if (!is_skippable(id))
+        current_state = false;
+    return t;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+}   // namespace cpplexer
+}   // namespace wave
+}   // namespace boost
+
+// the suffix header occurs after all of the code
+#ifdef BOOST_HAS_ABI_HEADERS
+#include BOOST_ABI_SUFFIX
+#endif
+
+#endif // !DETECT_INCLUDE_GUARDS_HK060304_INCLUDED