xst_stack.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/

// xst_stack.h

#ifndef _XST_STACK_H_INCLUDED_
#define _XST_STACK_H_INCLUDED_

namespace cttl_impl {


template< typename StackT >
struct xst_stack {

    // allow any lambda primitive to access stack primitive implementation
    template< typename D > friend struct xst_lambda_wrap;

    // allow any lambda primitive to access translator implementation
    template< typename D, typename T > friend struct xst_translator;

    enum {
        const_value_,

        depth_ = 1,

        capacity_ = 1,

        primitive_id_ = primitive_id_stack
    };
    
    typedef typename xst_storage_adaptor< StackT >::value_type stack_T;

    typedef typename stack_T::value_type value_T;

    typedef value_T dereferenced_value_T;

    typedef xst_stack< StackT > left_T;

    typedef xst_stack< StackT > right_T;
    
    typedef xst_stack< typename xst_storage_adaptor< StackT >::reference > reference_T;

    xst_stack()
    {
    }

    xst_stack( StackT stack_ )
        :
    m_stack( stack_ )
    {
    }

    xst_stack( value_T const& )
    {
    }

    xst_stack( xst_stack< StackT > const& other_ )
        :
    m_stack( other_.m_stack )
    {
    }

    reference_T make_reference() const
    {
        return reference_T( const_cast< xst_stack< StackT >* >( this )->m_stack.value() );
    }
    
    template<
        int LocationT
    >
    dereferenced_value_T& dereferenced_value( xst_lambda_wrap< xst_const_scalar< LocationT > > subscript_ )
    {
        return top( subscript_ );
    }

    // Direct access to stack primitive

    left_T& left_lambda()
    {
        return *this;
    }


    left_T const& left_lambda() const
    {
        return *this;
    }

    right_T& right_lambda()
    {
        return *this;
    }

    right_T const& right_lambda() const
    {
        return *this;
    }


    // subscript traversal algorithms

    template< typename FunctorT >
    static void subscript_top_down( FunctorT& functor_ )
    {
        functor_( const_scalar( 0 ) );
    }

    template< typename FunctorT >
    static void subscript_bottom_up( FunctorT& functor_ )
    {
        functor_( const_scalar( 0 ) );
    }

    // lambda compound traversal algorithms

    template< typename FunctorT >
    void traverse_bottom_up( FunctorT& functor_ )
    {
        functor_( *this );
    }
    
    template< typename FunctorT >
    void traverse_top_down( FunctorT& functor_ )
    {
        functor_( *this );
    }
    
    template< typename FunctorT >
    void traverse_bottom_up( FunctorT& functor_ ) const
    {
        functor_( *this );
    }
    
    template< typename FunctorT >
    void traverse_top_down( FunctorT& functor_ ) const
    {
        functor_( *this );
    }
    

    // Lambda primitive stack interface support

    template<
        int LocationT,
        typename InputValueT
    >
    void
    push(
        xst_lambda_wrap< xst_const_scalar< LocationT > >,
        InputValueT const& data_
        )
    {
        CTTL_TRACE_DEPOSIT_TEXT( "->" );
        CTTL_TRACE_DEPOSIT_TEXT( xst_storage_adaptor< StackT >::trace_char() );
        CTTL_TRACE_DEPOSIT_TEXT( "push$" );
        CTTL_TRACE_DEPOSIT_TEXT( xst_non_scalar_traits< InputValueT >::identity( data_ ) );
        CTTL_TRACE_DEPOSIT_TEXT( ' ' );
        xpush_descend< LocationT >( data_ );
    }

    template<
        int LocationT
    >
    void
    pop(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        
    {
        xpop_descend< LocationT >();
    }

    template<
        int LocationT
    >
    value_T const& top(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
         const
    {
        return xtop_descend< LocationT >();
    }

    template<
        int LocationT
    >
    value_T& top(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        
    {
        return xtop_descend< LocationT >();
    }

    template<
        int LocationT
    >
    size_t
    size(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        const
    {
        return xsize_at_location< LocationT >();
    }

    template<
        int LocationT
    >
    stack_T const*
    stack_ptr(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
        const
    {
        return xstack_ptr_at_location< LocationT >();
    }

    template<
        int LocationT
    >
    stack_T*
    stack_ptr(
        xst_lambda_wrap< xst_const_scalar< LocationT > >
        )
    {
        return xstack_ptr_at_location< LocationT >();
    }

#ifdef CTTL_LAMBDA_REFLECTION

    typedef xst_stack< StackT > reflection_T;

    reflection_T reflection() const
    {
        return *this;
    }
#endif // CTTL_LAMBDA_REFLECTION

private:
    // Implementation

    xst_storage_adaptor< StackT > m_stack;

    template< int LocationT, typename InputValueT >
    void xpush_at_location( InputValueT const& data_ )
    {
        assert( !LocationT );
        m_stack.value().push( data_ );
    }

    template< int LocationT >
    void xpop_at_location()
    {
        assert( !LocationT );
        CTTL_TRACE_DEPOSIT_TEXT( xst_storage_adaptor< StackT >::trace_char() );
        CTTL_TRACE_DEPOSIT_TEXT( "pop$" );
        assert( m_stack.const_value().size() );
        CTTL_TRACE_DEPOSIT_TEXT( xst_non_scalar_traits< value_T >::identity( m_stack.const_value().top() ) );
        CTTL_TRACE_DEPOSIT_TEXT( ' ' );
        m_stack.value().pop();
    }

    template< int LocationT >
    value_T const& xtop_at_location() const
    {
        assert( !LocationT );
        CTTL_TRACE_DEPOSIT_TEXT( xst_storage_adaptor< StackT >::trace_char() );
        CTTL_TRACE_DEPOSIT_TEXT( '$' );
        assert( m_stack.const_value().size() );
        CTTL_TRACE_DEPOSIT_TEXT( xst_non_scalar_traits< value_T >::identity( m_stack.const_value().top() ) );
        CTTL_TRACE_DEPOSIT_TEXT( ' ' );
        return m_stack.const_value().top();
    }

    template< int LocationT, typename InputValueT >
    void xpush_descend( InputValueT const& data_ )
    {
        xpush_at_location< LocationT >( data_ );
    }

    template< int LocationT >
    void xpop_descend()
    {
        xpop_at_location< LocationT >();
    }

    template< int LocationT >
    value_T const& xtop_descend() const
    {
        return xtop_at_location< LocationT >();
    }

    // subscript traversal algorithms

    template< typename SubscriptLambdaT, typename FunctorT >
    static void xsubscript_top_down_subtree_switch( SubscriptLambdaT subscript_, FunctorT& functor_ )
    {
        functor_( subscript_ );
    }

    template< int LocationT, typename FunctorT >
    static void xsubscript_top_down_descend( FunctorT& )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
    static void xsubscript_top_down_subtree_descend( SubscriptLambdaT, FunctorT& )
    {
        assert( false );
    }

    // subscript bottom up traversal

    template< typename SubscriptLambdaT, typename FunctorT >
    static void xsubscript_bottom_up_subtree_switch( SubscriptLambdaT subscript_, FunctorT& functor_ )
    {
        functor_( subscript_ );
    }

    template< int LocationT, typename FunctorT >
    static void xsubscript_bottom_up_descend( FunctorT& )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT, typename FunctorT >
    static void xsubscript_bottom_up_subtree_descend( SubscriptLambdaT, FunctorT& )
    {
        assert( false );
    }

    // Lambda primitive stack interface support

    template< typename SubscriptLambdaT, typename InputValueT >
    void xpush_sub_split( SubscriptLambdaT, InputValueT const& )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT, typename InputValueT >
    void xpush_sub_descend( SubscriptLambdaT, InputValueT const& )
    {
        assert( false );
    }

    template< typename SubscriptLambdaT >
    void xpop_sub_split( SubscriptLambdaT )
    {
        assert( false );
    }

    template< int LocationT, typename SubscriptLambdaT >
    void xpop_sub_descend( SubscriptLambdaT )
    {
        assert( false );
    }

    template< typename SubscriptLambdaT >
    value_T const& xtop_sub_split( SubscriptLambdaT ) const
    {
        assert( false );
        return m_stack.const_value().top();
    }

    template< int LocationT, typename SubscriptLambdaT >
    value_T const& xtop_sub_descend( SubscriptLambdaT ) const
    {
        assert( false );
        return m_stack.const_value().top();
    }

    template< int LocationT >
    value_T& xtop_at_location()
    {
        assert( !LocationT );
        CTTL_TRACE_DEPOSIT_TEXT( "->" );
        CTTL_TRACE_DEPOSIT_TEXT( xst_storage_adaptor< StackT >::trace_char() );
        CTTL_TRACE_DEPOSIT_TEXT( '$' );
        assert( m_stack.const_value().size() );
        CTTL_TRACE_DEPOSIT_TEXT( xst_non_scalar_traits< value_T >::identity( m_stack.const_value().top() ) );
        CTTL_TRACE_DEPOSIT_TEXT( ' ' );
        return m_stack.value().top();
    }

    template< int LocationT >
    value_T& xtop_descend()
    {
        return xtop_at_location< LocationT >();
    }

    template< typename SubscriptLambdaT >
    value_T& xtop_sub_split( SubscriptLambdaT )
    {
        assert( false );
        return xtop_descend< 0 >();
    }

    template< int LocationT, typename SubscriptLambdaT >
    value_T& xtop_sub_descend( SubscriptLambdaT )
    {
        assert( false );
        return xtop_descend< 0 >();
    }

    template< int LocationT >
    size_t xsize_at_location() const
    {
        assert( !LocationT );
        return m_stack.const_value().size();
    }

    template< int LocationT >
    size_t xsize_descend() const
    {
        return xsize_at_location< LocationT >();
    }

    template< typename SubscriptLambdaT >
    size_t xsize_sub_split( SubscriptLambdaT ) const
    {
        assert( false );
        return 0;   // compile time optimization
    }

    template< int LocationT, typename SubscriptLambdaT >
    size_t xsize_sub_descend( SubscriptLambdaT ) const
    {
        assert( false );
        return 0;   // compile time optimization
    }

    template< int LocationT >
    stack_T const* xstack_ptr_at_location() const
    {
        assert( !LocationT );
        return &m_stack.const_value();
    }

    template< int LocationT >
    stack_T const* xstack_ptr_descend() const
    {
        return xstack_ptr_at_location< LocationT >();
    }

    template< typename SubscriptLambdaT >
    stack_T const* xstack_ptr_sub_split( SubscriptLambdaT ) const
    {
        assert( false );
        return NULL;    // compile time optimization
    }

    template< int LocationT, typename SubscriptLambdaT >
    stack_T const* xstack_ptr_sub_descend( SubscriptLambdaT ) const
    {
        assert( false );
        return NULL;    // compile time optimization
    }


    template< int LocationT >
    stack_T* xstack_ptr_at_location()
    {
        assert( !LocationT );
        return &m_stack.value();
    }

    template< int LocationT >
    stack_T* xstack_ptr_descend()
    {
        return xstack_ptr_at_location< LocationT >();
    }

    template< typename SubscriptLambdaT >
    stack_T* xstack_ptr_sub_split( SubscriptLambdaT )
    {
        assert( false );
        return NULL;    // compile time optimization
    }

    template< int LocationT, typename SubscriptLambdaT >
    stack_T* xstack_ptr_sub_descend( SubscriptLambdaT )
    {
        assert( false );
        return NULL;    // compile time optimization
    }


};  // xst_stack


}   // namespace cttl_impl


#endif //_XST_STACK_H_INCLUDED_

---