base/libs/qdecoder/qString.c

Go to the documentation of this file.

/*
 * Copyright 2008 The qDecoder Project. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE QDECODER PROJECT ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE QDECODER PROJECT BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <stdarg.h>
#include <unistd.h>
#include <ctype.h>
#include <sys/types.h>
#include <sys/time.h>
#include "qDecoder.h"
#include "qInternal.h"

char *qStrTrim(char *str) {
    int i, j;

    if (str == NULL) return NULL;
    for (j = 0; str[j] == ' ' || str[j] == '\t' || str[j] == '\r' || str[j] == '\n'; j++);
    for (i = 0; str[j] != '\0'; i++, j++) str[i] = str[j];
    for (i--; (i >= 0) && (str[i] == ' ' || str[i] == '\t' || str[i] == '\r' || str[i] == '\n'); i--);
    str[i+1] = '\0';

    return str;
}

char *qStrTrimTail(char *str) {
    int i;

    if (str == NULL)return NULL;
    for (i = strlen(str) - 1; (i >= 0) && (str[i] == ' ' || str[i] == '\t' || str[i] == '\r' || str[i] == '\n'); i--);
    str[i+1] = '\0';

    return str;
}

char *qStrUnchar(char *str, char head, char tail) {
    if (str == NULL) return NULL;

    int len = strlen(str);
    if (len >= 2 && str[0] == head && str[len-1] == tail) {
        memmove(str, str + 1, len - 2);
        str[len - 2] = '\0';
    }

    return str;
}

char *qStrReplace(const char *mode, char *srcstr, const char *tokstr, const char *word) {
    if (mode == NULL || strlen(mode) != 2 || srcstr == NULL || tokstr == NULL || word == NULL) {
        DEBUG("Unknown mode \"%s\".", mode);
        return NULL;
    }

    char *newstr, *newp, *srcp, *tokenp, *retp;
    newstr = newp = srcp = tokenp = retp = NULL;

    char method = mode[0], memuse = mode[1];
    int maxstrlen, tokstrlen;

    /* Put replaced string into malloced 'newstr' */
    if (method == 't') { /* Token replace */
        maxstrlen = strlen(srcstr) * ( (strlen(word) > 0) ? strlen(word) : 1 );
        newstr = (char*)malloc(maxstrlen + 1);

        for (srcp = (char*)srcstr, newp = newstr; *srcp; srcp++) {
            for (tokenp = (char*)tokstr; *tokenp; tokenp++) {
                if (*srcp == *tokenp) {
                    char *wordp;
                    for (wordp = (char*)word; *wordp; wordp++) *newp++ = *wordp;
                    break;
                }
            }
            if (!*tokenp) *newp++ = *srcp;
        }
        *newp = '\0';
    } else if (method == 's') { /* String replace */
        if (strlen(word) > strlen(tokstr)) maxstrlen = ((strlen(srcstr) / strlen(tokstr)) * strlen(word)) + (strlen(srcstr) % strlen(tokstr));
        else maxstrlen = strlen(srcstr);
        newstr = (char*)malloc(maxstrlen + 1);
        tokstrlen = strlen(tokstr);

        for (srcp = srcstr, newp = newstr; *srcp; srcp++) {
            if (!strncmp(srcp, tokstr, tokstrlen)) {
                char *wordp;
                for (wordp = (char*)word; *wordp; wordp++) *newp++ = *wordp;
                srcp += tokstrlen - 1;
            } else *newp++ = *srcp;
        }
        *newp = '\0';
    } else {
        DEBUG("Unknown mode \"%s\".", mode);
        return NULL;
    }

    /* decide whether newing the memory or replacing into exist one */
    if (memuse == 'n') retp = newstr;
    else if (memuse == 'r') {
        strcpy(srcstr, newstr);
        free(newstr);
        retp = srcstr;
    } else {
        DEBUG("Unknown mode \"%s\".", mode);
        free(newstr);
        return NULL;
    }

    return retp;
}

char *qStrCpy(char *dst, size_t dstsize, const char *src, size_t nbytes) {
    if(dst == NULL || dstsize == 0 || src == NULL || nbytes == 0) return dst;

    if(nbytes >= dstsize) nbytes = dstsize - 1;
    strncpy(dst, src, nbytes);
    dst[nbytes] = '\0';

    return dst;
}

char *qStrUpper(char *str) {
    char *cp;

    if (!str) return NULL;
    for (cp = str; *cp; cp++) if (*cp >= 'a' && *cp <= 'z') *cp -= 32;
    return str;
}

char *qStrLower(char *str) {
    char *cp;

    if (!str) return NULL;
    for (cp = str; *cp; cp++) if (*cp >= 'A' && *cp <= 'Z') *cp += 32;
    return str;
}


char *qStrCaseStr(const char *s1, const char *s2) {
    if (s1 == NULL || s2 == NULL) return NULL;

    char *s1p = strdup(s1);
    char *s2p = strdup(s2);
    if (s1p == NULL || s2p == NULL) {
        if(s1p != NULL) free(s1p);
        if(s2p != NULL) free(s2p);
        return NULL;
    }

    qStrUpper(s1p);
    qStrUpper(s2p);

    char *sp = strstr(s1p, s2p);
    if (sp != NULL) sp = (char*)s1 + (sp - s1p);
    free(s1p);
    free(s2p);

    return sp;
}

char *qStrRev(char *str) {
    if (str == NULL) return str;

    char *p1, *p2;
    for (p1 = str, p2 = str + (strlen(str) - 1); p2 > p1; p1++, p2--) {
        char t = *p1;
        *p1 = *p2;
        *p2 = t;
    }

    return str;
}

char *qStrTok(char *str, const char *delimiters, char *retstop) {
    static char *tokenep;
    char *tokensp;
    int i, j;

    if (str != NULL) tokensp = tokenep = str;
    else tokensp = tokenep;

    for (i = strlen(delimiters); *tokenep; tokenep++) {
        for (j = 0; j < i; j++) {
            if (*tokenep == delimiters[j]) {
                if (retstop != NULL) *retstop = delimiters[j];
                *tokenep = '\0';
                tokenep++;
                return tokensp;
            }
        }
    }

    if (retstop != NULL) *retstop = '\0';
    if (tokensp != tokenep) return tokensp;
    return NULL;
}

Q_ENTRY *qStrTokenizer(char *str, const char *delimiters) {
    Q_ENTRY *entry = qEntryInit();
    char *token;
    int i;
    for(i = 1, token = qStrTok(str, delimiters, NULL); token != NULL; token = qStrTok(NULL, delimiters, NULL), i++) {
        char key[10+1];
        sprintf(key, "%d", i);
        qEntryPutStr(entry, key, token, false);
    }

    return entry;
}

char *qStrCommaNumber(int number) {
    char *str, *strp;

    str = strp = (char*)malloc(sizeof(char) * (14+1));
    if(str == NULL) return NULL;

    char buf[10+1], *bufp;
    snprintf(buf, sizeof(buf), "%d", abs(number));

    if (number < 0) *strp++ = '-';
    for (bufp = buf; *bufp != '\0'; strp++, bufp++) {
        *strp = *bufp;
        if ((strlen(bufp)) % 3 == 1 && *(bufp + 1) != '\0') *(++strp) = ',';
    }
    *strp = '\0';

    return str;
}

char *qStrCatf(char *str, const char *format, ...) {
    char buf[MAX_LINEBUF];
    va_list arglist;

    va_start(arglist, format);
    vsnprintf(buf, sizeof(buf), format, arglist);
    va_end(arglist);

    return strcat(str, buf);
}

char *qStrDupBetween(const char *str, const char *start, const char *end) {
    char *s;
    if ((s = strstr(str, start)) == NULL) return NULL;
    s += strlen(start);

    char *e;
    if ((e = strstr(s, end)) == NULL) return NULL;

    int len = e - s;

    char *buf = (char*)malloc(sizeof(char) * (len + 1));
    qStrCpy(buf, len + 1, s, len);

    return buf;
}

char *qStrUnique(const char *seed) {
    static int count = 0;

    if(count == 0) {
            srandom(time(NULL));
        }
    count++;

    long int usec;
#ifdef _WIN32
    usec = 0;
#else
    struct timeval tv;
    gettimeofday(&tv, NULL);
    usec = tv.tv_usec;
#endif

    char szSeed[128];
    snprintf(szSeed, sizeof(szSeed), "%u%d%ld%lu%ld%s", getpid(), count, random(), (unsigned long int)time(NULL), usec, (seed!=NULL?seed:""));
    return qHashMd5Str(szSeed, strlen(szSeed));
}

bool qStrIsAlnum(const char *str) {
        for (; *str; str++) {
                if(isalnum(*str) == 0) return false;
        }
        return true;
}

#ifdef __linux__
#include <iconv.h>
#endif

char *qStrConvEncoding(const char *str, const char *fromcode, const char *tocode, float mag) {
#ifdef __linux__
    if(str == NULL) return NULL;

    char *fromstr = (char*)str;
    size_t fromsize = strlen(fromstr) + 1;

    size_t tosize = sizeof(char) * ((mag * (fromsize - 1)) + 1);
    char *tostr = (char *)malloc(tosize);
    if(tostr == NULL) return NULL;
    char *tostr1 = tostr;

    iconv_t it = iconv_open(tocode, fromcode);
    if(it < 0) {
        DEBUG("iconv_open() failed.");
        return NULL;
    }

    int ret = iconv(it, &fromstr, &fromsize, &tostr, &tosize);
    iconv_close(it);

    if(ret < 0) {
        DEBUG("iconv() failed.");
        free(tostr1);
        return NULL;
    }

    return tostr1;
#else
    return NULL;
#endif
}

---