libi2ncommon: (tomj) smart HTML entities engine

[libi2ncommon] / src / stringfunc.cpp

/***************************************************************************
                          escape.cpp  -  escaping of strings
                             -------------------
    begin                : Sun Nov 14 1999
    copyright            : (C) 1999 by Intra2net AG
    email                : info@intra2net.com
 ***************************************************************************/

#include <iostream>
#include <string>
#include <sstream>
#include <stdexcept>

#include <stdlib.h>
#include <iconv.h>
#include <i18n.h>

#include <stringfunc.hxx>

using namespace std;

std::string iso_to_utf8(const std::string& isostring)
{
    string result;

    iconv_t i2utf8 = iconv_open ("UTF-8", "ISO-8859-1");

    if (iso_to_utf8 == (iconv_t)-1)
        throw runtime_error("iconv can't convert from ISO-8859-1 to UTF-8");

    size_t in_size=isostring.size();
    size_t out_size=in_size*4;

    char *buf = (char *)malloc(out_size+1);
    if (buf == NULL)
        throw runtime_error("out of memory for iconv buffer");

    const char *in = isostring.c_str();
    char *out = buf;
    iconv (i2utf8, &in, &in_size, &out, &out_size);

    buf[isostring.size()*4-out_size]=0;

    result=buf;

    free(buf);
    iconv_close (i2utf8);

    return result;
}

std::string utf8_to_iso(const std::string& utf8string)
{
    string result;

    iconv_t utf82iso = iconv_open ("ISO-8859-1","UTF-8");

    if (utf82iso == (iconv_t)-1)
        throw runtime_error("iconv can't convert from UTF-8 to ISO-8859-1");

    size_t in_size=utf8string.size();
    size_t out_size=in_size;

    char *buf = (char *)malloc(out_size+1);
    if (buf == NULL)
        throw runtime_error("out of memory for iconv buffer");

    const char *in = utf8string.c_str();
    char *out = buf;
    iconv (utf82iso, &in, &in_size, &out, &out_size);

    buf[utf8string.size()-out_size]=0;

    result=buf;

    free(buf);
    iconv_close (utf82iso);

    return result;
}

std::string utf7imap_to_iso(const std::string& utf7imapstring)
{
    string result;

    iconv_t utf7imap2iso = iconv_open ("ISO-8859-1","UTF-7-IMAP");

    if (utf7imap2iso == (iconv_t)-1)
        throw runtime_error("iconv can't convert from UTF-7-IMAP to ISO-8859-1");

    size_t in_size=utf7imapstring.size();
    size_t out_size=in_size;

    char *buf = (char *)malloc(out_size+1);
    if (buf == NULL)
        throw runtime_error("out of memory for iconv buffer");

    const char *in = utf7imapstring.c_str();
    char *out = buf;
    iconv (utf7imap2iso, &in, &in_size, &out, &out_size);

    buf[utf7imapstring.size()-out_size]=0;

    result=buf;

    free(buf);
    iconv_close (utf7imap2iso);

    return result;
}

// DEPRECATED, WILL BE REMOVED TOMORROW!
std::string iso_to_html(const std::string& isostring, bool showerr_bug)
{
    string result = isostring;

    // TODO: This needs to be removed soon by a proper 
    // HTML quoted chars engine. Then we can also remove &uuml; from i18n files.
    if (!showerr_bug) {
        replace_all (result, "&", "&amp;");
        replace_all (result, "\"", "&quot;");
        replace_all (result, "<", "&lt;");
        replace_all (result, ">", "&gt;");
    }

    replace_all (result, utf8_to_iso("ä"), "&auml;");
    replace_all (result, utf8_to_iso("ö"), "&ouml;");
    replace_all (result, utf8_to_iso("ü"), "&uuml;");
    replace_all (result, utf8_to_iso("Ä"), "&Auml;");
    replace_all (result, utf8_to_iso("Ö"), "&Ouml;");
    replace_all (result, utf8_to_iso("Ü"), "&Uuml;");
    replace_all (result, utf8_to_iso("ß"), "&szlig;");

    return result;
}

// Tokenize string by (html) tags
void tokenize_by_tag(vector<pair<string,bool> > &tokenized, const std::string &input)
{
    string::size_type pos, len = input.size();
    bool inside_tag = false;
    string current;

    for (pos = 0; pos < len; pos++) {
        if (input[pos] == '<') {
            inside_tag = true;

            if (!current.empty()) {
                tokenized.push_back(make_pair(current, false));
                current = "";
            }

            current += input[pos];
        } else if (input[pos] == '>' && inside_tag) {
            current += input[pos];
            inside_tag = false;
            if (!current.empty()) {
                tokenized.push_back(make_pair(current, true));
                current = "";
            }
        } else
            current += input[pos];
    }

    // String left over in buffer?
    if (!current.empty())
        tokenized.push_back(make_pair(current, false));
}

std::string strip_html_tags(const std::string &input)
{
    // Pair first: string, second: isTag
    vector<pair<string,bool> > tokenized;
    tokenize_by_tag(tokenized, input);

    string output;
    vector<pair<string,bool> >::const_iterator token, tokens_end = tokenized.end();
    for (token = tokenized.begin(); token != tokens_end; token++)
        if (!token->second)
            output += token->first;

    return output;
}

// Smart-encode HTML en
string smart_html_entities(const std::string &input)
{
    // Pair first: string, second: isTag
    vector<pair<string,bool> > tokenized;
    tokenize_by_tag(tokenized, input);

    string output;
    vector<pair<string,bool> >::const_iterator token, tokens_end = tokenized.end();
    for (token = tokenized.begin(); token != tokens_end; token++) {
        // keep HTML tags as they are
        if (token->second)
            output += token->first;
        else
            output += html_entities(token->first);
    }

    return output;
}

// encoded UTF-8 chars into HTML entities
string html_entities(std::string str)
{
    // Normal chars
    replace_all (str, "&", "&amp;");
    replace_all (str, "\"", "&quot;");
    replace_all (str, "<", "&lt;");
    replace_all (str, ">", "&gt;");

    // Umlauts
    replace_all (str, "ä", "&auml;");
    replace_all (str, "ö", "&ouml;");
    replace_all (str, "ü", "&uuml;");
    replace_all (str, "Ä", "&Auml;");
    replace_all (str, "Ö", "&Ouml;");
    replace_all (str, "Ü", "&Uuml;");

    // Misc
    replace_all (str, "ß", "&szlig;");

    return str;
}

bool replace_all(string &base, const char *ist, const char *soll)
{
    string i=ist;
    string s=soll;
    return replace_all(base,&i,&s);
}

bool replace_all(string &base, const string &ist, const char *soll)
{
    string s=soll;
    return replace_all(base,&ist,&s);
}

bool replace_all(string &base, const string *ist, const string *soll)
{
    return replace_all(base,*ist,*soll);
}

bool replace_all(string &base, const char *ist, const string *soll)
{
    string i=ist;
    return replace_all(base,&i,soll);
}

bool replace_all(string &base, const string &ist, const string &soll)
{
    bool found_ist = false;
    string::size_type a=0;

    if (ist.empty())
        throw runtime_error("replace_all called with empty search string");

    while((a=base.find(ist,a))!=string::npos)
    {
        base.replace(a,ist.size(),soll);
        a=a+soll.size();
        found_ist = true;
    }
    
    return found_ist;
}

string to_lower(const string &src)
{
    string dst = src;

    string::size_type pos = 0, end = dst.size();
    for (pos = 0; pos < end; pos++)
        dst[pos] = tolower(dst[pos]);

    return dst;
}

string to_upper(const string &src)
{
    string dst = src;

    string::size_type pos = 0, end = dst.size();
    for (pos = 0; pos < end; pos++)
        dst[pos] = toupper(dst[pos]);

    return dst;
}

string nice_unit_format (int input) {
    float size = input;
    int sizecount = 0;

    while (size > 1000) {
        size = size / 1000;
        sizecount++;
    }

    float tmp;                       // round
    tmp = size*10;
    tmp += 0.5;
    tmp = int (tmp);
    tmp = float(tmp)/float(10);
    size = tmp;

    ostringstream out;

    out.setf (ios::fixed);
    out.precision(2);
    switch (sizecount) {
    case 1:
        out << size << i18n(" KBytes");
        break;
    case 2:
        out << size << i18n(" MBytes");
        break;
    case 3:
        out << size << i18n(" Gbytes");
        break;
    default:
        out << size << i18n(" Bytes");
        break;
    }

    return out.str();
}

string escape(const string &s)
{
    string out(s);
    string::size_type p;

    p=0;
    while ((p=out.find_first_of("\"\\",p))!=out.npos)
    {
        out.insert(p,"\\");
        p+=2;
    }

    p=0;
    while ((p=out.find_first_of("\r",p))!=out.npos)
    {
        out.replace(p,1,"\\r");
        p+=2;
    }

    p=0;
    while ((p=out.find_first_of("\n",p))!=out.npos)
    {
        out.replace(p,1,"\\n");
        p+=2;
    }

    out='"'+out+'"';

    return out;
}

string descape(const string &s, int startpos, int &endpos)
{
    string out;

    if (s.at(startpos) != '"')
        throw out_of_range("value not type escaped string");

    out=s.substr(startpos+1);
    string::size_type p=0;

    // search for the end of the string
    while((p=out.find("\"",p))!=out.npos)
    {
        int e=p-1;
        bool escaped=false;

        // the " might be escaped with a backslash
        while(e>=0 && out.at(e)=='\\')
        {
            if (escaped == false)
                escaped=true;
            else
                escaped=false;

            e--;
        }

        if (escaped==false)
            break;
        else
            p++;
    }

    // we now have the end of the string
    out=out.substr(0,p);

    // tell calling prog about the endposition
    endpos=startpos+p+1;

    // descape all \ stuff inside the string now
    p=0;
    while((p=out.find_first_of("\\",p))!=out.npos)
    {
        switch(out.at(p+1))
        {
        case 'r':
            out.replace(p,2,"\r");
            break;
        case 'n':
            out.replace(p,2,"\n");
            break;
        default:
            out.erase(p,1);
        }
        p++;
    }

    return out;
}

string escape_shellarg(const string &input)
{
    if (!input.size())
        return "";
    
    string output = "'";
    string::const_iterator it, it_end = input.end();
    for (it = input.begin(); it != it_end; it++) {
        if ((*it) == '\'')
            output += "'\\'";
        
        output += *it;
    }
    
    output += "'";
    return output;
}