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

// xml_lexer.h

#ifndef _XML_LEXER_H_INCLUDED_
#define _XML_LEXER_H_INCLUDED_

template< typename ParserT >
struct lexer : public ParserT {

    typedef typename ParserT::universe_T universe_T;

    typedef typename universe_T::strict_edge_T strict_universe_T;

    strict_universe_T& consumed_data;

    strict_universe_T edge_xml_name;

    strict_universe_T attribute_value;
    
    lambda< inode_writer<> >::scalar inode_text;

    lambda< inode_writer<> >::scalar inode_element;

    lambda< inode_writer<> >::scalar inode_first;

    lambda< inode_writer<> >::scalar inode_last;

    lambda< inode_writer<> >::scalar inode_attribute;

    lambda< inode_writer<> >::scalar inode_parent;

    lambda< size_t >::stack element_stack;

    lambda<>::scalar id_xml_element;

    lambda<>::scalar id_attribute_value;


    lexer( strict_universe_T& consumed_data_ )
        :
        consumed_data( consumed_data_ ),
        edge_xml_name( new_edge( consumed_data_.parent() ) ),
        attribute_value( new_edge( consumed_data_.parent() ) ),
        inode_text( inode_writer<>( this->vect_xml_tree ) ),
        inode_element( inode_writer<>( this->vect_xml_tree ) ),
        inode_first( inode_writer<>( this->vect_xml_tree ) ),
        inode_last( inode_writer<>( this->vect_xml_tree ) ),
        inode_attribute( inode_writer<>( this->vect_xml_tree ) ),
        inode_parent( inode_writer<>( this->vect_xml_tree ) )
    {
    }

    void operator=( lexer< ParserT > const& ) const
    {
    }

    size_t xml_grammar( universe_T& universe_ )
    {
        offset_stack_guard< universe_T > error_info( this->xml_offset_stack, universe_.first );

        return (
            *CTTL_RULE( lexer< ParserT >::xml_node )
            +
            ( end() | CTTL_RULE( ParserT::error_parser_failed ) )

        ).match( universe_ )
        ;
    }

    size_t xml_node( universe_T& universe_ )
    {
        return (

#ifdef DISPOSE_CONSUMED_DATA
            consumed_data.second( begin( true ) )
            +
#endif // DISPOSE_CONSUMED_DATA

            (
                CTTL_RULE( lexer< ParserT >::xml_pi )
                |
                CTTL_RULE( lexer< ParserT >::xml_element )
                |
                CTTL_RULE( lexer< ParserT >::xml_comment )
                |
                CTTL_RULE( lexer< ParserT >::xml_text )
            )

        ).match( universe_ )
        ;
    }

    size_t xml_name( universe_T& universe_ )
    {
        edge< policy_strict_stream > strict_stream_universe( universe_, universe_.space_policy() );

        return (
            *entity( isspace )
            +
            edge_xml_name( +entity( &LITERAL_XML_NAME ) )
            +
            // In this implementation xml elements and
            // attributes share name dictionary:
            *( ++( id_xml_element.make_reference() ^ this->xml_name_dictionary ^ edge_xml_name ) )

        ).match( strict_stream_universe )
        ;
    }

    size_t xml_comment( universe_T& universe_ )
    {
        offset_stack_guard< universe_T > error_info( this->xml_offset_stack, universe_.first );

        return (
            universe_.first( symbol() + 4 )
            +
            &LITERAL_XML_COMMENT_OPEN    //"<!--"
            +
            *( -( universe_.first( symbol() + 3 ) + &LITERAL_XML_COMMENT_CLOSE ) + symbol() )
            +
            universe_.first( symbol() + 3 )
            +
            ( &LITERAL_XML_COMMENT_CLOSE | CTTL_RULE( ParserT::error_missing_comment_close ) )   // "-->"

        ).match( universe_ )
        ;
    }

    size_t xml_pi( universe_T& universe_ )
    {
        offset_stack_guard< universe_T > error_info( this->xml_offset_stack, universe_.first );

        return (
            universe_.first( symbol() + 2 )
            +
            &LITERAL_XML_PI_OPEN    // "<?"
            +
            ( CTTL_RULE( lexer< ParserT >::xml_name ) | CTTL_RULE( ParserT::error_bad_pi ) )
            +
            *( -( universe_.first( symbol() + 2 ) + &LITERAL_XML_PI_CLOSE ) + symbol() )
            +
            universe_.first( symbol() + 2 )
            +
            ( &LITERAL_XML_PI_CLOSE | CTTL_RULE( ParserT::error_missing_pi_close ) )   // "?>"

        ).match( universe_ )
        ;
    }

    size_t xml_element( universe_T& universe_ )
    {
        offset_stack_guard< universe_T > error_info( this->xml_offset_stack, universe_.first );
        return (
            '<'
            +
            CTTL_RULE( lexer< ParserT >::xml_name )
            +
            // in-line semantic action to create new xml element node
            (
                inode_element << ELEMENT_SIZE,
                inode_element[ FLD_ELEMENT_NAME ] = id_xml_element,
                element_stack = alias::offset( inode_element )
                ,
                const_scalar( 1 )
            )
            +
            *CTTL_RULE( lexer< ParserT >::xml_attr )
            +
            (
                (
                    universe_.first( symbol() + 2 )
                    +
                    &LITERAL_XML_ELEM_CLOSED    // "/>" closed inode_element
                )
                |
                (
                    '>'                         // open inode_element
                    +
                    *CTTL_RULE( lexer< ParserT >::xml_node )
                    +
                    ( CTTL_RULE( lexer< ParserT >::xml_closeElement ) | CTTL_RULE( ParserT::error_missing_close_element ) )
                )
            )
            +
            // in-line semantic action to add xml element to the parse tree:
            (
                CTTL_LAMBDA_ASSERT( +element_stack ),
                inode_element = *element_stack--,
                +element_stack
                && (
                    // if a parent element exists:
                    inode_parent = *element_stack,
                    inode_first = inode_parent[ FLD_FIRST_ELEMENT ],
                    !inode_first
                    &&
                    (
                        // if no children exist,
                        inode_parent[ FLD_FIRST_ELEMENT ] = alias::offset( inode_element ),
                        const_scalar( 1 )
                    ) || (
                        // otherwise
                        inode_last = inode_parent[ FLD_LAST_ELEMENT ],
                        CTTL_LAMBDA_ASSERT( alias::offset( inode_last ) ),
                        inode_last[ FLD_NEXT_ELEMENT ] = alias::offset( inode_element ),
                        const_scalar( 1 )
                    )
                    ,
                    inode_parent[ FLD_LAST_ELEMENT ] = alias::offset( inode_element )
                )
                ,
                const_scalar( 1 )
            )

        ).match( universe_ )
        ;
    }

    size_t xml_closeElement( universe_T& universe_ )
    {
        return (
            universe_.first( symbol() + 2 )
            +
            &LITERAL_XML_CLOSE_ELEM // "</"
            +
            CTTL_RULE( lexer< ParserT >::xml_name )
            +
            '>'

        ).match( universe_ )
        ;
    }

    static int validate_text( universe_T& universe_ )
    {
        universe_.first.find_class( isspace );
        universe_.second.rfind_class( isspace );
        return universe_.length();
    }

    size_t xml_text( universe_T& universe_ )
    {
        return (
            +( -symbol( '<' ) + symbol() )
            &
            (
                // In-line semantic action to add text node to the current xml element:
                ++(
                    scalar( 0 )
                    ^
                    CTTL_STATIC_ACTION(
                        std::ptr_fun( &lexer< ParserT >::validate_text ),
                        &universe_
                    )
                )
                &&
                (
                    inode_text << TEXT_SIZE,
                    inode_text[ FLD_TEXT_VALUE ] = ++( scalar( 0 )^this->vect_xml_text^universe_ ),
                    CTTL_LAMBDA_ASSERT( +element_stack ),
                    inode_element = *element_stack,
                    inode_first = inode_element[ FLD_FIRST_TEXT ],
                    !inode_first
                    &&
                    (
                        // if no children exist,
                        inode_element[ FLD_FIRST_TEXT ] = alias::offset( inode_text ), // consider using macro here
                        const_scalar( 1 )
                    ) || (
                        inode_last = inode_element[ FLD_LAST_TEXT ],
                        CTTL_LAMBDA_ASSERT( alias::offset( inode_last ) ),
                        inode_last[ FLD_NEXT_TEXT ] = alias::offset( inode_text ),
                        const_scalar( 1 )
                    )
                    ,
                    inode_element[ FLD_LAST_TEXT ] = alias::offset( inode_text )
                )
                ,
                const_scalar( 1 )

            )

        ).match( universe_ )
        ;
    }

    size_t xml_attr( universe_T& universe_ )
    {
        offset_stack_guard< universe_T > error_info( this->xml_offset_stack, universe_.first );

        return (
            CTTL_RULE( lexer< ParserT >::xml_name )
            +
            '='
            +
            (
                (
                    CTTL_RULE( lexer< ParserT >::xml_value )
                    +
                    *( ++( id_attribute_value ^ this->vect_xml_text ^ attribute_value ) )
                )
                |
                CTTL_RULE( ParserT::error_bad_attr_format )
            )
            +
            // in-line semantic action to add xml attribute node to the parse subtree
            // (attributes and xml elements share symbol table of names).
            (
                inode_attribute << ATTRIBUTE_SIZE,
                inode_attribute[ FLD_ATTRIBUTE_NAME ] = id_xml_element,
                inode_attribute[ FLD_ATTRIBUTE_VALUE ] = id_attribute_value,

                // link with parent element
                CTTL_LAMBDA_ASSERT( +element_stack ),
                inode_element = *element_stack,
                inode_first = inode_element[ FLD_FIRST_ATTRIBUTE ],
                !inode_first
                &&
                (
                    inode_element[ FLD_FIRST_ATTRIBUTE ] = alias::offset( inode_attribute )
                ) || (
                    inode_last = inode_element[ FLD_LAST_ATTRIBUTE ],
                    CTTL_LAMBDA_ASSERT( alias::offset( inode_last ) ),
                    inode_last[ FLD_NEXT_ATTRIBUTE ] = alias::offset( inode_attribute ),
                    const_scalar( 1 )
                )
                ,
                inode_element[ FLD_LAST_ATTRIBUTE ] = alias::offset( inode_attribute ),
                const_scalar( 1 )
            )

        ).match( universe_ )
        ;
    }

    size_t xml_value( universe_T& universe_ )
    {
        return (
            (
                '\"'
                +
                attribute_value( *( -symbol( '\"' ) + symbol() ) )
                +
                '\"'
            )
            |
            (
                '\''
                +
                attribute_value( *( -symbol( '\'' ) + symbol() ) )
                +
                '\''
            )
        ).match( universe_ )
        ;
    }
};

#endif //_XML_LEXER_H_INCLUDED_

---