xtl_quote.h

Go to the documentation of this file.

// Common Text Transformation Library
// Copyright (C) 1997-2006 by Igor Kholodov. 
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the
// Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// mailto:cttl@users.sourceforge.net
// http://sourceforge.net/projects/cttl/

// xtl_quote.h

#ifndef _CTTL_XTL_QUOTE_H_INCLUDED_
#define _CTTL_XTL_QUOTE_H_INCLUDED_

namespace cttl_impl {

typedef xtl_wrap< xtl_bool< true > >
relaxed_bool_T;

template< typename LeftT, typename MiddleT, typename RightT, typename DerivedT >
class xtl_quote_base {

protected:
    LeftT   m_left;

    MiddleT m_middle;

    RightT  m_right;

public:
    // compile-time

    xtl_quote_base( LeftT const& left_, MiddleT const& middle_, RightT const& right_ )
    : m_left( left_ ), m_middle( middle_ ), m_right( right_ )
    {
    }

    // run-time

    template< typename UniverseT >
    size_t match( UniverseT& edge_ )
    {
        // L+M+R_ balanced pair
        CTTL_TRACE_LEVEL_MATCH( '\"' );
        typename UniverseT::offset_manager_T saved_first_offset( edge_.parent().container(), edge_.first.offset() );
        typename UniverseT::offset_manager_T left_offset( edge_.parent().container(), m_left.match( edge_ ) );

        if ( left_offset != UniverseT::string_T::npos ) {
            if ( static_cast< DerivedT* >( this )->match_pair( edge_ ) )
                return left_offset;
        }
                
        edge_.first.offset( saved_first_offset );       // restore universe
        CTTL_TRACE_TEXT_RESULT( false, '\"', "xtl_quote_base: opening close failed" );
        return UniverseT::string_T::npos;
    }
    
    template< typename UniverseT >
    size_t find( UniverseT& edge_ )
    {
        // !L+M+R_
        CTTL_TRACE_LEVEL_FIND( '\"' );
        typename UniverseT::offset_manager_T saved_first_offset( edge_.parent().container(), edge_.first.offset() );
        typename UniverseT::offset_manager_T left_offset( edge_.parent().container(), m_left.find( edge_ ) );
        if ( left_offset != UniverseT::string_T::npos ) {
            if ( static_cast< DerivedT* >( this )->match_pair( edge_ ) )
                return left_offset;
        }

        edge_.first.offset( saved_first_offset );       // restore universe
        CTTL_TRACE_TEXT_RESULT( false, '\"', "xtl_quote_base: opening clause failed" );
        return UniverseT::string_T::npos;
    }
    
    template< typename UniverseT >
    size_t bang_find( UniverseT& edge_ )
    {
        // !!L+M+R_
        CTTL_TRACE_LEVEL_BANG( '\"' );
        typename UniverseT::offset_manager_T saved_first_offset( edge_.parent().container(), edge_.first.offset() );
        // if this offset stops progressing, we must bail out of infinite loop:
        typename UniverseT::offset_manager_T iteration_offset( edge_.parent().container(), UniverseT::string_T::npos );
        typename UniverseT::offset_manager_T left_offset( edge_.parent().container(), UniverseT::string_T::npos );

        while ( ( left_offset = m_left.bang_find( edge_ ) ) != UniverseT::string_T::npos ) {
            if ( static_cast< DerivedT* >( this )->match_pair( edge_ ) )
                return left_offset;

            if ( iteration_offset == edge_.first.offset() ) {
                CTTL_TRACE_TEXT( '\"', "!!(left,middle,right): iteration has not made any progress: bailing out" );
                break;  // second, third, etc., iteration hasn't made any progress: bail out
            }

            iteration_offset = edge_.first.offset();
        }

        edge_.first.offset( saved_first_offset );       // restore universe
        CTTL_TRACE_TEXT_RESULT( false, '\"', "xtl_quote_base: LHS bang_find failed" );
        return UniverseT::string_T::npos;
    }
    
};  // xtl_quote_base


template< typename LeftT, typename MiddleT, typename RightT >
class xtl_quote_generic : public xtl_quote_base< LeftT, MiddleT, RightT, xtl_quote_generic< LeftT, MiddleT, RightT > > {
public:
    // compile-time

    xtl_quote_generic( LeftT const& left_, MiddleT const& middle_, RightT const& right_ )
    : xtl_quote_base< LeftT, MiddleT, RightT, xtl_quote_generic< LeftT, MiddleT, RightT > >( left_, middle_, right_ )
    {
    }

    // run-time

    template< typename UniverseT >
    bool match_pair( UniverseT& edge_ )
    {
        // LHS matched
        typename UniverseT::offset_manager_T middle_offset_start( edge_.parent().container(), edge_.first.offset() );
        size_t level = 1;   // we are inside a quote

        typename UniverseT::offset_manager_T current_offset( edge_.parent().container(), edge_.first.offset() );
        typename UniverseT::offset_manager_T right_offset( edge_.parent().container(), UniverseT::string_T::npos );
        typename UniverseT::offset_manager_T right_right_offset( edge_.parent().container(), UniverseT::string_T::npos );

        for (
            ;
            level && ( ( right_offset = this->m_right.bang_find( edge_ ) ) != UniverseT::string_T::npos );
            current_offset = edge_.first.offset()
            )
        {
            // RHS found
            // restart left search position
            right_right_offset = edge_.first.offset( current_offset );
            size_t left_offset = this->m_left.bang_find( edge_ );
            if ( left_offset != UniverseT::string_T::npos )
                if ( left_offset < right_offset ) {
                    // LHS found earlier, keep searching
                    ++level;
                    continue;   // ------->
                }

            // restore edge after right pos
            edge_.first.offset( right_right_offset );
            --level;
        }

        if ( level ) {
            // RHS was never found - we fail
            CTTL_TRACE_TEXT_RESULT( false, '\"', "xtl_quote_generic: closing clause not found" );
            return false;
        }

        // preserve edge
        xtl_edge_offset_manager< UniverseT > edge_mgr( edge_ );
        edge_.first.offset( middle_offset_start );
        edge_.second.offset( right_offset );
        if ( this->m_middle.match( edge_ ) != UniverseT::string_T::npos ) {
            edge_mgr.restore( edge_ );
            return true;
        }

        edge_mgr.restore( edge_ );
        CTTL_TRACE_TEXT_RESULT( false, '\"', "xtl_quote_generic: middle clause failed" );
        return false;
    }
    
};  // class xtl_quote_generic


template< typename MiddleT, typename RightT >
class xtl_quote_bool : public xtl_quote_base< relaxed_bool_T, MiddleT, RightT, xtl_quote_bool< MiddleT, RightT > > {

public:
    // compile-time

    xtl_quote_bool( MiddleT const& middle_, RightT const& right_ )
    : xtl_quote_base< relaxed_bool_T, MiddleT, RightT, xtl_quote_bool< MiddleT, RightT > >( true, middle_, right_ )
    {
    }

    // run-time

    template< typename UniverseT >
    bool match_pair( UniverseT& edge_ )
    {
        // LHS matched
        typename UniverseT::offset_manager_T middle_offset_start( edge_.parent().container(), edge_.first.offset() );
        typename UniverseT::offset_manager_T right_offset( edge_.parent().container(), this->m_right.bang_find( edge_ ) );

        if ( right_offset != UniverseT::string_T::npos ) {
            // RHS matched
            // preserve edge
            xtl_edge_offset_manager< UniverseT > edge_mgr( edge_ );
            edge_.first.offset( middle_offset_start );
            edge_.second.offset( right_offset );
            if ( this->m_middle.match( edge_ ) != UniverseT::string_T::npos ) {
                edge_mgr.restore( edge_ );
                return true;
            }
            edge_mgr.restore( edge_ );
            CTTL_TRACE_TEXT_RESULT( false, '\"', "quote(true,M,R) middle clause failed" );
            return false;
        }

        CTTL_TRACE_TEXT_RESULT( false, '\"', "quote(true,M,R) closing clause failed" );
        return false;
    }
    
};  // class xtl_quote_bool


template< typename UniverseT, typename MiddleT, typename RightT, typename CharT >
inline bool
xtl_match_quote( UniverseT& edge_, MiddleT& middle_, RightT& right_, CharT const* chars2find_ )
{
    typename UniverseT::string_T const& str = edge_.parent().text();

    // Closing quote is specified by the first character
    const CharT close_quote = chars2find_[ 0 ];
    const CharT back_whack = CharT( '\\' );
    const CharT cr = CharT( '\r' );
    const CharT lf = CharT( '\n' );

    // LHS matched.
    size_t middle_offset_start = edge_.first.offset();
    size_t current_offset = edge_.first.offset();

    // Assume we will fail
    size_t close_offset = UniverseT::string_T::npos;
    for (
        size_t temp_offset = str.find_first_of( chars2find_, current_offset );
        temp_offset != UniverseT::string_T::npos;
        temp_offset = str.find_first_of( chars2find_, temp_offset + 1 )
        )
    {
        if ( edge_.second.offset() <= temp_offset )
            // attempt to step beyond current universe
            return false;

        // make sure offset is valid, if not, keep retrying
        size_t adjusted_offset = edge_.space_policy().lower_bound( temp_offset, edge_.second.offset() );
        if ( adjusted_offset != temp_offset ) {
            temp_offset = adjusted_offset - 1;
            if ( edge_.second.offset() <= temp_offset )
                // attempt to step beyond current universe
                return false;
            continue;
        }

        // note: if open and close tokens are the same, then close token has higher priority
        if ( str[ temp_offset ] == back_whack ) {
            // this is C literal, and escape sequence was found inside:
            ++temp_offset;  // automatically skip next CTTL_STD_CHAR
            // Now we look at one more character; if it's remaining part of <cr><lf> pair,
            // eat it and go on:
            if ( str[ temp_offset ] == cr )
                ++temp_offset;  // skip cr

            else if ( str[ temp_offset ] == lf )
                ++temp_offset;  // skip lf

        } else if ( str[ temp_offset ] == close_quote ) {
            // RHS quote is found:
            close_offset = temp_offset;
            break;
        }

        // If we encounter unexpected cr or lf, halt evaluation of string literal:
        if ( ( str[ temp_offset ] == cr ) || ( str[ temp_offset ] == lf ) )
            // RHS not found on the same line - fail immediately
            return false;
    }

    if ( close_offset == UniverseT::string_T::npos )
        // RHS was never found
        return false;

    edge_.first.offset( close_offset );
    // Note: because right side is simply xtl_wrap< xtl_char< CharT > >, no
    // offset protection is used for middle_offset_start and right_offset:
    typename UniverseT::strict_edge_T strict_universe( edge_ );
    size_t right_offset = right_.match( strict_universe );
    if ( right_offset == UniverseT::string_T::npos ) {
        assert( false );
        return false;
    }

    xtl_edge_offset_manager< UniverseT > edge_mgr( edge_ ); // preserve edge
    edge_.first.offset( middle_offset_start );
    edge_.second.offset( right_offset );
    if ( middle_.match( edge_ ) != UniverseT::string_T::npos ) {
        edge_mgr.restore( edge_ );
        return true;
    }
    edge_mgr.restore( edge_ );
    return false;

}   // xtl_match_quote()


template< typename MiddleT, typename CharT >
class xtl_quote_ansi_double_quote : public xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_ansi_double_quote< MiddleT, CharT > > {
public:
    // compile-time

    xtl_quote_ansi_double_quote()
    : xtl_quote_base< xtl_wrap< xtl_char< CharT > >, relaxed_bool_T, xtl_wrap< xtl_char< CharT > >, xtl_quote_ansi_double_quote< relaxed_bool_T, CharT > >( CharT( '\"' ), true, CharT( '\"' ) )
    {
    }

    xtl_quote_ansi_double_quote( MiddleT const& middle_ )
    : xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_ansi_double_quote< MiddleT, CharT > >( CharT( '\"' ), middle_, CharT( '\"' ) )
    {
    }

    // run-time

    template< typename UniverseT >
    bool match_pair( UniverseT& edge_ )
    {
//      typedef typename UniverseT::char_T char_T;
        static const CharT chars2find[] = { '\"', '\n', '\r', 0x00 };
        return xtl_match_quote( edge_, this->m_middle, this->m_right, chars2find ); // "\"\n\r"
    }
    
};  // class xtl_quote_ansi_double_quote


template< typename MiddleT, typename CharT >
class xtl_quote_ansi_single_quote : public xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_ansi_single_quote< MiddleT, CharT > > {

public:

    // compile-time

    xtl_quote_ansi_single_quote()
    : xtl_quote_base< xtl_wrap< xtl_char< CharT > >, relaxed_bool_T, xtl_wrap< xtl_char< CharT > >, xtl_quote_ansi_single_quote< relaxed_bool_T, CharT > >( CharT( '\'' ), true, CharT( '\'' ) )
    {
    }

    xtl_quote_ansi_single_quote( MiddleT const& middle_ )
    : xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_ansi_single_quote< MiddleT, CharT > >( CharT( '\'' ), middle_, CharT( '\'' ) )
    {
    }

    // run-time

    template< typename UniverseT >
    bool match_pair( UniverseT& edge_ )
    {
//      typedef typename UniverseT::char_T char_T;
        static const CharT chars2find[] = { '\'', '\n', '\r', 0x00 };
        return xtl_match_quote( edge_, this->m_middle, this->m_right, chars2find ); // "\'\n\r"
    }
    
};  // class xtl_quote_ansi_single_quote


template< typename MiddleT, typename CharT >
class xtl_quote_c_double_quote : public xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_c_double_quote< MiddleT, CharT > > {

public:

    // compile-time

    xtl_quote_c_double_quote()
    : xtl_quote_base<
        xtl_wrap< xtl_char< CharT > >,
        relaxed_bool_T,
        xtl_wrap< xtl_char< CharT > >,
        xtl_quote_c_double_quote< xtl_wrap< xtl_bool< true > >, CharT >
        >( CharT( '\"' ), true, CharT( '\"' ) )
    {
    }

    xtl_quote_c_double_quote( MiddleT const& middle_ )
    : xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_c_double_quote< MiddleT, CharT > >( CharT( '\"' ), middle_, CharT( '\"' ) )
    {
    }

    // run-time

    template< typename UniverseT >
    bool match_pair( UniverseT& edge_ )
    {
//      typedef typename UniverseT::char_T char_T;
        static const CharT chars2find[] = { '\"', '\n', '\r', '\\', 0x00 };
        return xtl_match_quote( edge_, this->m_middle, this->m_right, chars2find ); // "\"\n\r\\"
    }
    
};  // class xtl_quote_c_double_quote


template< typename MiddleT, typename CharT >
class xtl_quote_c_single_quote : public xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_c_single_quote< MiddleT, CharT > > {

public:

    // compile-time

    xtl_quote_c_single_quote()
    : xtl_quote_base< xtl_wrap< xtl_char< CharT > >, relaxed_bool_T, xtl_wrap< xtl_char< CharT > >, xtl_quote_c_single_quote< relaxed_bool_T, CharT > >( CharT( '\'' ), true, CharT( '\'' ) )
    {
    }

    xtl_quote_c_single_quote( MiddleT const& middle_ )
    : xtl_quote_base< xtl_wrap< xtl_char< CharT > >, MiddleT, xtl_wrap< xtl_char< CharT > >, xtl_quote_c_single_quote< MiddleT, CharT > >( CharT( '\'' ), middle_, CharT( '\'' ) )
    {
    }

    // run-time

    template< typename UniverseT >
    bool match_pair( UniverseT& edge_ )
    {
//      typedef typename UniverseT::char_T char_T;
        static const CharT chars2find[] = { '\'', '\n', '\r', '\\', 0x00 };
        return xtl_match_quote( edge_, this->m_middle, this->m_right, chars2find ); // "\'\n\r\\"
    }
    
};  // class xtl_quote_c_single_quote

typedef xtl_wrap< xtl_quote_ansi_single_quote< relaxed_bool_T, CTTL_STD_CHAR > >
ansi_single_quote_T;

typedef xtl_wrap< xtl_quote_ansi_double_quote< relaxed_bool_T, CTTL_STD_CHAR > >
ansi_double_quote_T;

typedef xtl_wrap< xtl_quote_c_single_quote< relaxed_bool_T, CTTL_STD_CHAR > >
c_single_quote_T;

typedef xtl_wrap< xtl_quote_c_double_quote< relaxed_bool_T, CTTL_STD_CHAR > >
c_double_quote_T;


typedef xtl_wrap< xtl_quote_ansi_single_quote< relaxed_bool_T, CTTL_STD_WCHAR > >
wchar_ansi_single_quote_T;

typedef xtl_wrap< xtl_quote_ansi_double_quote< relaxed_bool_T, CTTL_STD_WCHAR > >
wchar_ansi_double_quote_T;

typedef xtl_wrap< xtl_quote_c_single_quote< relaxed_bool_T, CTTL_STD_WCHAR > >
wchar_c_single_quote_T;

typedef xtl_wrap< xtl_quote_c_double_quote< relaxed_bool_T, CTTL_STD_WCHAR > >
wchar_c_double_quote_T;

}   // namespace cttl_impl


#endif // _CTTL_XTL_QUOTE_H_INCLUDED_

---