textscanner.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef __TEXTWOLF_TEXT_SCANNER_HPP__
#define __TEXTWOLF_TEXT_SCANNER_HPP__

#include "textwolf/char.hpp"
#include "textwolf/charset_interface.hpp"
#include "textwolf/exception.hpp"
#include "textwolf/sourceiterator.hpp"
#include "textwolf/istreamiterator.hpp"
#include "textwolf/cstringiterator.hpp"
#include <cstddef>

namespace textwolf {

template <typename Iterator>
struct Traits{};

template <>
struct Traits<char*>
{
        static inline std::size_t getPosition( const char* start, char const* itr)
        {
                return itr-start;
        }
};

template <>
struct Traits<SrcIterator>
{
        static inline std::size_t getPosition( const SrcIterator&, const SrcIterator& itr)
        {
                return itr.position();
        }
};

template <>
struct Traits<IStreamIterator>
{
        static inline std::size_t getPosition( const IStreamIterator&, const IStreamIterator& itr)
        {
                return itr.position();
        }
};

template <>
struct Traits<CStringIterator>
{
        static inline std::size_t getPosition( const CStringIterator&, const CStringIterator& itr)
        {
                return itr.pos();
        }
};


template <typename Iterator, class CharSet>
class TextScanner
{
private:
        Iterator start;                 
        Iterator input;                 
        char buf[8];                    
        UChar val;                      
        signed char cur;                
        unsigned int state;             
        CharSet charset;

public:
        struct ControlCharMap  :public CharMap<ControlCharacter,Undef>
        {
                ControlCharMap()
                {
                        (*this)
                        (0,EndOfText)
                        (1,31,Cntrl)
                        (5,Undef)
                        (33,127,Any)
                        (128,255,Undef)
                        ('\t',Space)
                        ('\r',Space)
                        ('\n',EndOfLine)
                        (' ',Space)
                        ('&',Amp)
                        ('<',Lt)
                        ('=',Equal)
                        ('>',Gt)
                        ('/',Slash)
                        ('-',Dash)
                        ('!',Exclam)
                        ('?',Questm)
                        ('\'',Sq)
                        ('\"',Dq)
                        ('[',Osb)
                        (']',Csb);
                }
        };

        TextScanner( const CharSet& charset_)
                :val(0),cur(0),state(0),charset(charset_)
        {
                for (unsigned int ii=0; ii<sizeof(buf); ii++) buf[ii] = 0;
        }

        TextScanner( const CharSet& charset_, const Iterator& p_iterator)
                :start(p_iterator),input(p_iterator),val(0),cur(0),state(0),charset(charset_)
        {
                for (unsigned int ii=0; ii<sizeof(buf); ii++) buf[ii] = 0;
        }

        TextScanner( const Iterator& p_iterator)
                :start(p_iterator),input(p_iterator),val(0),cur(0),state(0),charset(CharSet())
        {
                for (unsigned int ii=0; ii<sizeof(buf); ii++) buf[ii] = 0;
        }

        TextScanner( const TextScanner& orig)
                :start(orig.start)
                ,input(orig.input)
                ,val(orig.val)
                ,cur(orig.cur)
                ,state(orig.state)
                ,charset(orig.charset)
        {
                for (unsigned int ii=0; ii<sizeof(buf); ii++) buf[ii]=orig.buf[ii];
        }

        template <class IteratorAssignment>
        void setSource( const IteratorAssignment& a)
        {
                input = a;
                start = a;
        }

        std::size_t getPosition() const
        {
                return Traits<Iterator>::getPosition( start, input) - state;
        }

        inline UChar chr()
        {
                if (val == 0)
                {
                        val = charset.value( buf, state, input);
                }
                return val;
        }

        inline void getcur()
        {
                cur = CharSet::asciichar( buf, state, input);
        }

        inline const Iterator& getIterator() const
        {
                return input;
        }

        inline Iterator& getIterator()
        {
                return input;
        }

        template <class Buffer>
        inline void copychar( CharSet& output_, Buffer& buf_)
        {
                if (CharSet::is_equal( charset, output_))
                {
                        // ... if the character sets are equal and of the same subclass (code pages)
                        //      then we do not decode/encode the character but copy it directly to the output
                        charset.fetchbytes( buf, state, input);
#ifdef __GNUC__
#if (__GNUC__ >= 5 && __GNUC_MINOR__ >= 0)
                        for (unsigned int ii=0; ii<8 && ii<state; ++ii) buf_.push_back(buf[ii]);
#else
                        for (unsigned int ii=0; ii<state; ++ii) buf_.push_back(buf[ii]);
#endif
#else
                        for (unsigned int ii=0; ii<state; ++ii) buf_.push_back(buf[ii]);
#endif
                }
                else
                {
                        output_.print( chr(), buf_);
                }
        }

        inline ControlCharacter control()
        {
                static ControlCharMap controlCharMap;
                getcur();
                return controlCharMap[ (unsigned char)cur];
        }

        inline unsigned char ascii()
        {
                getcur();
                return cur>=0?(unsigned char)cur:0;
        }

        inline TextScanner& skip()
        {
                CharSet::skip( buf, state, input);
                state = 0;
                cur = 0;
                val = 0;
                return *this;
        }

        inline UChar operator*()
        {
                return chr();
        }

        inline TextScanner& operator ++()       {return skip();}

        inline TextScanner operator ++(int)     {TextScanner tmp(*this); skip(); return tmp;}
};

}//namespace
#endif