charSetTranslator.cxx

Go to the documentation of this file.

#include <cxxtls/charSetTranslator.h>

namespace cxxtls
{
    std::string CharSetTranslator::translate(std::string const &s) const
    {
        std::string rv;

        if(!ok_)
          return std::string();

        std::string::const_iterator first = s.begin(),
                                    last  = s.end();
        while(first != last)
        {
            rv += this->operator[](*first++);
        }

        return rv;
        
    }

    void CharSetTranslator::populateLhs(char const *inset, LhsRange &lhs)
    {
        int rhsOffset=0;   // assuming characters are arrange in ascending order in the lhs string
                           // and that the character position on the lhs, tells you the character
                           // position in the rhs to establish the mapping

        while(*inset)
        {
           unsigned char c = *inset++;

           if(*inset == '-')
           {
              // this is a range not a single character

              char const *next = inset; ++next;

              unsigned char end = *next;

              if(end != 0)
              {
                 // there is an end to the range

                 if(end < c)
                 {
                     ok_ = false;
                     error_ = "lhs: end of range smaller than beginning";
                     break;
                 }

                 while(c <= end)
                 {
                     lhs.push_back(LhsSubrange(c++, rhsOffset++));
                 }

                 inset += 2;

              }
              else
              {
                 ok_    = false;
                 error_ = "lhs: missing end of range, '-' is last character of string";
                 break;
              }
           }
           else
           {
              // this is a single character range

              lhs.push_back(LhsSubrange(c, rhsOffset++));

           }

        }

    }

    void CharSetTranslator::populateRhs(char const *set, char *rhs)
    {
        if(*set == 0)
        {
           ok_     = false;
           error_  = "rhs:  empty string now allowed";
           return;
        }

        char *end = rhs+256;

        unsigned char c = *set++;

        while(c != 0 && rhs != end)
        {
            if(*set == 0)
            {
               // when you reach the end of specified input data, use the
               // final character to populate the remainder of the translation
               // table.

               while(rhs != end)
                   *rhs++ = c;

               return;
            }

            if(*set == '-')
            {
                 char const *next =  set; ++next;

                 if(*next == 0)
                 {
                     ok_    = false;
                     error_ = "rhs:  missing end of range, '-' is last char";
                     return;
                 }

                 unsigned char g = *next;

                 if(c > g)
                 {
                     ok_ = false;
                     error_ = "rhs:  end of range less than beginning";
                     return;
                 }

                 while(    (c <= g) 
                       && (rhs != end)
                      )
                 {
                     *rhs++ = c++; 
                 }

                 set += 2;

            }
            else
            {
               // this is a single character sub-range

               *rhs++ = c;
            }
           
            c = *set++;
        }

    }

    void CharSetTranslator::populateMapping(LhsRange const &lhs, char const *rhs)
    {

        // populate the mapping table with a default mapping ( 1:1 )

        char *scan = mapping_;
        size_t   count= 0;

        while(count < sizeof(mapping_))
        {
           *scan++ = count++;
        }

        // find mapped characters and change from the default
        // mapping to the user specified mapping.


        LhsRange::const_iterator first = lhs.begin(),
                                 last  = lhs.end();

         while(first != last)
         {
             mapping_[ first->offset_ ] = rhs[ first->mappedOffset_ ];
             ++first;
         }

    }

    std::string CharSetTranslator::unEscape(std::string const &in)
    {
        std::string rv;

        char const *scan = in.data();
        char const * end = in.size() + scan;

        while(scan != end)
        {
           char c = *scan++;

           if(c == '\\')
           {
             if(scan == end)
               rv += c;
             else
             {
                 c = *scan++;

                 switch(c)
                 {
                     case 'n':  c = '\n'; break;
                     case 'r':  c = '\r'; break;
                     case 't':  c = '\t'; break;
                     case 's':  c = ' '; break;
                     case 'b':  c = '\b'; break;
                     case 'a':  c = '\a'; break;
                     case 'f':  c = '\f'; break;

                     case '0':
                     case 'o':
                       {
                           // handle octal numbers of the form:  \o123
                           //                                      ^
                           //                                      scan is here

                           if(   (end - scan >= 3)
                              && (scan[0] >= '0' && scan[0] <= '7')
                              && (scan[1] >= '0' && scan[1] <= '7')
                              && (scan[2] >= '0' && scan[2] <= '7')
                              )
                           {
                              c =  (scan[0]-'0') * 64;
                              c += (scan[1]-'0') * 8;
                              c += (scan[2]-'0');

                              scan+= 3;
                           }

                       }
                       break;

                     default:
                       break; // just eat the \ and keep the character
                              // that follows
                 }

                 rv += c;
             }


           }
           else
             rv += c;
        }

        return rv;

    }



};