muo_convert.cc

Go to the documentation of this file.

/*
 * Copyright (C) 2001 Karsten Reincke <karsten.reincke@gnukose.org>
 *  
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program 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 General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software 
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *  
 * file <muo_convert.cc> version <#1.3.1#> of project <MrProjext>
 */   

#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include "muo_convert.h"

/* &&& (1) local preprocessor-defines &&&&&&&&&&&&&&&&&&&&&&& */

/* &&& (2) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&& (2) definitions of static global variables &&&&&&&&&&& */

/* &&& (3) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class &&& */

/* --- (3.A) - public ----------------------------------------- */
/* :-: (3.A.1) public constructors, inits & operators :-:-:-:-: */
krmuo::Converter::Converter()
: mUnConvertedToken(""),
  mConvertedToken(""),
  mConvertedString(""),
  mUtf8String(""),
  mTokenMap(NULL)
{
  mUtf8Sign[0]=0;
}

krmuo::Converter::~Converter()
{
}

/* :-: (3.A.2) public getter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
/* :-: (3.A.3) public setter -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */
/* :-: (3.A.4) public others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

const string krmuo::Converter::decode(const string& pUnDecodedString)
{
  assert(mTokenMap);
  mUnConvertedStringEnd=pUnDecodedString.end();
  mUnConvertedStringIterator=pUnDecodedString.begin();
  mConvertedString="";
  unsigned char sign;
  while(getNextUnDecodedToken(mUnConvertedToken))
  {
    if (isDecodableEmbeddedUtf8Token(mUnConvertedToken,sign))
      mConvertedString+=sign;
    else if (mTokenMap->isDecodableToken(mUnConvertedToken))
      mConvertedString+=mTokenMap->decodeToken(mUnConvertedToken);
    else
      mConvertedString+=mUnConvertedToken;
  }
  return mConvertedString;
}

const string krmuo::Converter::encode(const string& pUnEncodedString)
{
  assert(mTokenMap);
  mUnConvertedStringIterator=pUnEncodedString.begin();
  mConvertedString="";
  while(mUnConvertedStringIterator!=pUnEncodedString.end())
  {
    if (mTokenMap->isEncodableSign((unsigned char)*mUnConvertedStringIterator))
      mConvertedString+=mTokenMap->encodeSign((unsigned char)*mUnConvertedStringIterator);
    else if (isUtf8EncodableSign((unsigned char)*mUnConvertedStringIterator,mUtf8String))
      mConvertedString+=mUtf8String;
    else
      mConvertedString+=(unsigned char)*mUnConvertedStringIterator;
    mUnConvertedStringIterator++;
  }
  return mConvertedString;
}

bool krmuo::Converter::isDecodableEmbeddedUtf8Token
( const string& pUtf8Token,
  unsigned char& pSign
)
{
  if (pUtf8Token.size()<3)
    return false;
    
  string::const_iterator tokenSign=pUtf8Token.begin(); 
  if (((unsigned char)* tokenSign)  != ((unsigned char)'&'))
    return false;

  tokenSign++;
  if (((unsigned char) *tokenSign) != ((unsigned char)'#'))
    return false;
               
  tokenSign++;
  // *tokensign == 'x' | 'X' | 'o' | 'O' | '1' ... '0'
    
  enum NumberStil { UNKNOWN, HEX, OCTAL, DECIMAL } numberStil=UNKNOWN;
    
  if (  ((unsigned char) toupper(*tokenSign)) == (unsigned char)'X' )
  {
    numberStil=HEX;
    tokenSign++;
  }
  else if (((unsigned char) toupper(*tokenSign)) == (unsigned char)'O' )
  {
    numberStil=OCTAL;
    tokenSign++;      
  }
  else if ( isdigit(*tokenSign) )
  {
    numberStil=DECIMAL;
  }
    
  if (numberStil==UNKNOWN)
    return false;

  string utf8DecodedToken="";
  while(    (tokenSign !=pUtf8Token.end())
        &&  (   ((unsigned char)*tokenSign) 
            !=  ((unsigned char)';')
            ) 
        ) 
  {    
    utf8DecodedToken+=*tokenSign;
    tokenSign++;
  }
  
  unsigned int signValue=0;
  switch(numberStil)
  {
    case HEX:
      sscanf(utf8DecodedToken.c_str(),"%x",&signValue);
        break;
    case OCTAL:
      sscanf(utf8DecodedToken.c_str(),"%o",&signValue);
        break;
    default:
      sscanf(utf8DecodedToken.c_str(),"%u",&signValue);
  }
  pSign=(unsigned char) signValue;
  return true;  
}    

bool krmuo::Converter::getNextUnDecodedToken(string& pUnDecodedToken)
{
  // are there still candidates for decoding?
  if (mUnConvertedStringIterator==mUnConvertedStringEnd)
    return false;
    
  pUnDecodedToken="";
  
  // take the start position of the next candidate
  string::const_iterator
    unDecodedParseIterator=mUnConvertedStringIterator;
  
  // is the candidate more than a simple token
  if (  ( (unsigned char)*unDecodedParseIterator )
     == ( (unsigned char) '&')
     )
  {
    bool doParse=true;  
    
    while(doParse)
    {
      // did we run into uncorrect html
      if (  (unDecodedParseIterator==mUnConvertedStringEnd)
         ||
            (   (unsigned char)*unDecodedParseIterator 
            <=  (unsigned char)' '
          ) )
      {
        
        // ... then eval the first sign (=&) as normal sign
        unDecodedParseIterator=mUnConvertedStringIterator;
        pUnDecodedToken="";
        
        // each last sign of an html-tag will 
        // be overtaken at the end of this method 
        // and in this case the last sign  is the first sign
        doParse=false;
      }
      else
      {
        // have we reached the correct end of an html-tag?
        if  (   (unsigned char)*unDecodedParseIterator 
            ==  (unsigned char)';'
            )
        {
          // each last sign of an html-sign-tag will 
          // be overtaken at the end of this method 
          doParse=false;
        }
        else
        {
          // overtake the signtagsign into the token-string
          // and test the next signtagsign
          pUnDecodedToken+=*unDecodedParseIterator;
          unDecodedParseIterator++;
        }        
      }
    }    
    mUnConvertedStringIterator=unDecodedParseIterator;
  }
  
  // take over the last still not overtaken sign of the token:
  // if the token is only a simple the sign this (first) sign
  // is also the last sign
  pUnDecodedToken+=*mUnConvertedStringIterator;
  mUnConvertedStringIterator++;
  return true;
}

bool krmuo::Converter::isUtf8EncodableSign(const unsigned char pSign, string& pUtf8Token)
{
  if (pSign < 0x80)
    return false;
  sprintf(mUtf8Sign,"&#%02d;", pSign);
  pUtf8Token=mUtf8Sign;
  return true;
}

/* &&& (4) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class HtmlConverter &&&&&&&&&&&&&&&&&&&& */
/* --- (4.A) - public ----------------------------------------- */
/* :-: (4.A.1) public constructors, inits & operators :-:-:-:-: */
krmuo::HtmlConverter::HtmlConverter()
{
  mTokenMap=&mHtmlCodeTokenMap; 
}

krmuo::HtmlConverter::~HtmlConverter()
{
}

/* &&& (5) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class XmlConverter &&&&&&&&&&&&&&&&&&&& */
/* --- (5.A) - public ----------------------------------------- */
/* :-: (5.A.1) public constructors, inits & operators :-:-:-:-: */
krmuo::XmlConverter::XmlConverter()
{
  mTokenMap=&mXmlCodeTokenMap; 
}

krmuo::XmlConverter::~XmlConverter()
{
}

/* &&& (6) &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& */
/* &&&     methods for class UrlConverter &&&&&&&&&&&&&&&&&&&& */
/* --- (6.A) - public ----------------------------------------- */
/* :-: (6.A.1) public constructors, inits & operators :-:-:-:-: */
krmuo::UrlConverter::UrlConverter()
{
  mTokenMap=&mUrlCodeTokenMap; 
}

krmuo::UrlConverter::~UrlConverter()
{
}
/* :-: (6.A.4) public others -:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-:-: */

const string krmuo::UrlConverter::decode(const string& pUnDecodedString)
{

  mUnConvertedStringEnd=pUnDecodedString.end();
  mUnConvertedStringIterator=pUnDecodedString.begin();
  mConvertedString="";
  unsigned char sign;
  while(getNextUnDecodedToken(mUnConvertedToken))
  {
    
    if (isDecodableEmbeddedUtf8Token(mUnConvertedToken,sign))
      mConvertedString+=sign;
    else if (mUrlCodeTokenMap.isDecodableToken(mUnConvertedToken))
      mConvertedString+=mUrlCodeTokenMap.decodeToken(mUnConvertedToken);
    else
      mConvertedString+=mUnConvertedToken;
  }  
  return mConvertedString;
}

const string krmuo::UrlConverter::encode(const string& pUnEncodedString)
{
  mUnConvertedStringIterator=pUnEncodedString.begin();
  mConvertedString="";
  while(mUnConvertedStringIterator!=pUnEncodedString.end())
  {
    if (mUrlCodeTokenMap.isEncodableSign((unsigned char)*mUnConvertedStringIterator))
      mConvertedString+=mUrlCodeTokenMap.encodeSign((unsigned char)*mUnConvertedStringIterator);
    else if (isUtf8EncodableSign((unsigned char)*mUnConvertedStringIterator,mUtf8String))
      mConvertedString+=mUtf8String;
    else
      mConvertedString+=(unsigned char)*mUnConvertedStringIterator;
    mUnConvertedStringIterator++;
  }
  return mConvertedString;
}

bool krmuo::UrlConverter::getNextUnDecodedToken(string& pUnDecodedToken)
{
  // are there still candidates for decoding?
  if (mUnConvertedStringIterator==mUnConvertedStringEnd)
    return false;
    
  pUnDecodedToken="";
  
  // take the start position of the next candidate
  string::const_iterator
    unDecodedParseIterator=mUnConvertedStringIterator;
  
  // is the candidate more than a simple token
  if (  ( (unsigned char)*unDecodedParseIterator )
     == ( (unsigned char) '%')
     )
  {
    unDecodedParseIterator++;
    if (unDecodedParseIterator==mUnConvertedStringEnd)
      unDecodedParseIterator=mUnConvertedStringIterator;
    else
    {
      pUnDecodedToken="%";
      pUnDecodedToken+=*unDecodedParseIterator;
      unDecodedParseIterator++;
      if (unDecodedParseIterator==mUnConvertedStringEnd)
        unDecodedParseIterator=mUnConvertedStringIterator;
    }
  }
  mUnConvertedStringIterator=unDecodedParseIterator;
  
  // take over the last still not overtaken sign of the token:
  // if the token is only a simple the sign this (first) sign
  // is also the last sign
  pUnDecodedToken+=*mUnConvertedStringIterator;
  mUnConvertedStringIterator++;
  return true;
}

bool krmuo::UrlConverter::isUtf8EncodableSign(const unsigned char pSign, string& pUtf8Token)
{
  if (pSign < 0x80)
    return false;
  sprintf(mUtf8Sign,"%c%02x",'%',(unsigned int)pSign);     
  pUtf8Token=mUtf8Sign;
  return true;
}

bool krmuo::UrlConverter::isDecodableEmbeddedUtf8Token
( const string& pUtf8Token,
  unsigned char& pSign
)
{
  if (pUtf8Token.size()<3)
    return false;
    
  string::const_iterator tokenSign=pUtf8Token.begin(); 
  if (((unsigned char)* tokenSign)  != ((unsigned char)'%'))
    return false;

  tokenSign++;

  string utf8DecodedToken="";
  while(tokenSign !=pUtf8Token.end())
  {    
    utf8DecodedToken+=*tokenSign;
    tokenSign++;
  }
  
  unsigned int signValue=0;
  sscanf(utf8DecodedToken.c_str(),"%x",&signValue);
  pSign=(unsigned char) signValue;
  return true;  
}    

---