URI.cpp

Go to the documentation of this file.

 
#include <ctype.h>
#include <string.h>
 
#include <dcl/Object.h>
 
#if __DCL_HAVE_ALLOC_DEBUG
#undef __DCL_ALLOC_LEVEL
#define __DCL_ALLOC_LEVEL   __DCL_ALLOC_INTERNAL
#endif
 
#include <dcl/Regex.h>
#include <dcl/Numeric.h>
#include <dcl/Charset.h>
 
#include <dcl/URI.h>
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t* __THIS_FILE__ = __T("dcl/URI.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
static int hextoi(const char* _s)
{
    __DCL_ASSERT(_s != NULL);
 
    __DCL_ASSERT(_s[0] != '\0');
    int c = _s[0];
    if (isupper(c))
        c = tolower(c);
 
    int r = (('0' <= c && c <= '9') ? c - '0' : c - 'a' + 10) * 16;
 
    __DCL_ASSERT(_s[1] != '\0');
    c = _s[1];
    if (isupper(c))
        c = tolower(c);
 
    r += ('0' <= c && c <= '9') ? c - '0' : c - 'a' + 10;
 
    return r;
}
 
ByteString URLDecoder::decode(const char* _begin, const char* _end)
{
    ByteStringBuilder r;
    while (_begin < _end) {
        if (*_begin == '+')
            r += ' ';
        else if (
            *_begin == '%'
            && (_begin + 2) < _end
            && isxdigit(*(_begin +1))
            && isxdigit(*(_begin + 2))
        ) {
            r += (char)hextoi(_begin + 1);
            _begin += 2;
        }
        else
            r += *_begin;
        _begin++;
    }
    return r;
}
 
ByteString URLDecoder::decode(const ByteString& _str)
{
    return URLDecoder::decode(_str, _str.data() + _str.length());
}
 
String URLDecoder::decode(const String& _str)
{
    return UTF8Decoder::decode(
        URLDecoder::decode(
            UTF8Encoder::encode(_str)
        )
    );
}
 
ByteString URLEncoder::encode(const ByteString& _str)
{
    static unsigned char hexchars[] = "0123456789ABCDEF";
 
    ByteStringBuilder r;
 
    const char* psz = _str.data();
    for (; *psz; psz++) {
        unsigned char c = (unsigned char)*psz;
        if (c == ' ')
            r += '+';
        else if ((c < '0' && c != '-' && c != '.')
            || (c < 'A' && c > '9')
            || (c > 'Z' && c < 'a' && c != '_')
            || (c > 'z')
        ) {
            r += '%';
            r += (char)hexchars[c >> 4];
            r += (char)hexchars[c & 15];
        }
        else
            r += (char)c;
    }
    return r;
}
 
String URLEncoder::encode(const String& _str)
{
    return AsciiDecoder::decode(
        URLEncoder::encode(
            UTF8Encoder::encode(_str)
        )
    );
}
 
IMPLEMENT_CLASSINFO(URI, Object)
 
URI::URI(const wchar_t* _uri)
    __DCL_THROWS1(URISyntaxException*)
{
    __port = -1;
    parse(_uri);
}
 
URI::URI(const wchar_t* _scheme,
    const wchar_t* _schemeSpecificPart,
    const wchar_t* _fragment
) __DCL_THROWS1(URISyntaxException*)
{
    __port = -1;
    assign(
        _scheme,
        _schemeSpecificPart,
        NULL,
        -1,
        NULL,
        NULL,
        _fragment
    );
}
 
URI::URI(const wchar_t* _scheme,
    const wchar_t* _userInfo,
    const wchar_t* _host,
    int _port,
    const wchar_t* _path,
    const wchar_t* _query,
    const wchar_t* _fragment
) __DCL_THROWS1(URISyntaxException*)
{
    __port = -1;
    assign(
        _scheme,
        _userInfo,
        _host,
        _port,
        _path,
        _query,
        _fragment
    );
}
 
URI::URI(const wchar_t* _scheme,
    const wchar_t* _host,
    const wchar_t* _path,
    const wchar_t* _fragment
) __DCL_THROWS1(URISyntaxException*)
{
    __port = -1;
    assign(
        _scheme,
        NULL,
        _host,
        -1,
        _path,
        NULL,
        _fragment
    );
}
 
URI::URI(const wchar_t* _scheme,
    const wchar_t* _authority,
    const wchar_t* _path,
    const wchar_t* _query,
    const wchar_t* _fragment
) __DCL_THROWS1(URISyntaxException*)
{
    __port = -1;
    assign(
        _scheme,
        _authority,
        NULL,
        -1,
        _path,
        _query,
        _fragment
    );
}
 
void URI::assign(
    const wchar_t* _scheme,
    const wchar_t* _userInfo,
    const wchar_t* _host,
    int _port,
    const wchar_t* _path,
    const wchar_t* _query,
    const wchar_t* _fragment
) __DCL_THROWS1(URISyntaxException*)
{
    StringBuilder r;
    if (_scheme) {
        r = _scheme;
        r += __T(":");
    }
 
    if (_userInfo || _host || _port > -1)
        r += __T("//");
 
    if (_userInfo) {
        r += _userInfo;
        r += __T("@");
    }
 
    if (_host)
        r += _host;
 
    if (_port > -1) {
        r +=__T( ":");
        r += Integer::toString(_port);
    }
 
    if (_path)
        r += _path;
 
    if (_query) {
        r += __T("?");
        r += _query;
    }
 
    if (_fragment) {
        r += __T("#");
        r += _fragment;
    }
 
    parse(r);
}
 
static const wchar_t* const __REGEXP_URI = 
    __T("^(([^:/?#]+):)?((//([^/?#]*))?([^?#]*)(\\?([^#]*))?)?(#(.*))?");
 
static const wchar_t* const __REGEXP_AUTHORITY = 
    __T("^(([^?#]*)@)?([^?#:]*)(:([^?#]*))?");
 
#define SCHEME_GROUP                2
#define SCHEME_SPEC_PART_GROUP      3
#define AUTHORITY_GROUP             5
#define PATH_GROUP                  6
#define QUERY_GROUP                 8
#define FRAGMENT_GROUP              10
 
#define AUTHORITY_USERINFO_GROUP    2
#define AUTHORITY_HOST_GROUP        3
#define AUTHORITY_PORT_GROUP        5
 
void URI::parse(const wchar_t* _uri)
    __DCL_THROWS1(URISyntaxException*)
{
    __DCL_ASSERT(_uri && *_uri);
 
    Regex re(__REGEXP_URI);
    {
        Regex::MatchResults m;   // aMatch[11];
        if (!re.match(_uri, m)) {
            throw new URISyntaxException(
                __T("doesn't match URI regular expression"),
                _uri
            );
        }
 
#define __MATCH_STR(m, index) m[index].first, m[index].second
 
        __scheme.assign(__MATCH_STR(m, SCHEME_GROUP));
        __schemeSpecificPart.assign(__MATCH_STR(m, SCHEME_SPEC_PART_GROUP));
        __authority.assign(__MATCH_STR(m, AUTHORITY_GROUP));
        __path.assign(__MATCH_STR(m, PATH_GROUP));
        __query.assign(__MATCH_STR(m, QUERY_GROUP));
        __fragment.assign(__MATCH_STR(m, FRAGMENT_GROUP));
    }
 
    if (__authority.isEmpty())
        return;
 
    re.compile(__REGEXP_AUTHORITY);
    {
        Regex::MatchResults m;
        if (re.match(__authority, m)) {
            __userInfo.assign(__MATCH_STR(m, AUTHORITY_USERINFO_GROUP));
            __host.assign(__MATCH_STR(m, AUTHORITY_HOST_GROUP));
            String port(__MATCH_STR(m, AUTHORITY_PORT_GROUP));
            __port = Integer::parse(port, 10, __port);
        }
    }
    __uri = _uri;
}
 
IMPLEMENT_CLASSINFO(URISyntaxException, Exception)
 
URISyntaxException::URISyntaxException(
    const String& _reason,
    const String& _source
) : Exception(NULL)
{
    __message = _reason + __T(": ") + _source;
}
 
String URISyntaxException::toString() const
{
    return __message;
}
 
__DCL_END_NAMESPACE