src/stringutil.c

Go to the documentation of this file.

/*
 * stringutil.c -- string utilities 
 */

#include "copyright.h"
#include "config.h"

#include "mudconf.h"
#include "config.h"
#include "externs.h"
#include "alloc.h"
#include "ansi.h"

#ifdef __linux__
char *___strtok;

#endif

char *translate_string(const char *str, int type)
{
        char old[LBUF_SIZE];
        static char new[LBUF_SIZE];
        char *j, *c, *bp;
        int i;

        bp = new;
        StringCopy(old, str);

        for(j = old; *j != '\0'; j++) {
                switch (*j) {
                case ESC_CHAR:
                        c = strchr(j, 'm');
                        if(c) {
                                if(!type) {
                                        j = c;
                                        break;
                                }

                                *c = '\0';
                                i = atoi(j + 2);
                                switch (i) {
                                case 0:
                                        safe_str("%cn", new, &bp);
                                        break;
                                case 1:
                                        safe_str("%ch", new, &bp);
                                        break;
                                case 5:
                                        safe_str("%cf", new, &bp);
                                        break;
                                case 7:
                                        safe_str("%ci", new, &bp);
                                        break;
                                case 30:
                                        safe_str("%cx", new, &bp);
                                        break;
                                case 31:
                                        safe_str("%cr", new, &bp);
                                        break;
                                case 32:
                                        safe_str("%cg", new, &bp);
                                        break;
                                case 33:
                                        safe_str("%cy", new, &bp);
                                        break;
                                case 34:
                                        safe_str("%cb", new, &bp);
                                        break;
                                case 35:
                                        safe_str("%cm", new, &bp);
                                        break;
                                case 36:
                                        safe_str("%cc", new, &bp);
                                        break;
                                case 37:
                                        safe_str("%cw", new, &bp);
                                        break;
                                case 40:
                                        safe_str("%cX", new, &bp);
                                        break;
                                case 41:
                                        safe_str("%cR", new, &bp);
                                        break;
                                case 42:
                                        safe_str("%cG", new, &bp);
                                        break;
                                case 43:
                                        safe_str("%cY", new, &bp);
                                        break;
                                case 44:
                                        safe_str("%cB", new, &bp);
                                        break;
                                case 45:
                                        safe_str("%cM", new, &bp);
                                        break;
                                case 46:
                                        safe_str("%cC", new, &bp);
                                        break;
                                case 47:
                                        safe_str("%cW", new, &bp);
                                        break;
                                }
                                j = c;
                        } else {
                                safe_chr(*j, new, &bp);
                        }
                        break;
                case ' ':
                        if((*(j + 1) == ' ') && type)
                                safe_str("%b", new, &bp);
                        else
                                safe_chr(' ', new, &bp);
                        break;
                case '\\':
                        if(type)
                                safe_str("\\", new, &bp);
                        else
                                safe_chr('\\', new, &bp);
                        break;
                case '%':
                        if(type)
                                safe_str("%%", new, &bp);
                        else
                                safe_chr('%', new, &bp);
                        break;
                case '[':
                        if(type)
                                safe_str("%[", new, &bp);
                        else
                                safe_chr('[', new, &bp);
                        break;
                case ']':
                        if(type)
                                safe_str("%]", new, &bp);
                        else
                                safe_chr(']', new, &bp);
                        break;
                case '{':
                        if(type)
                                safe_str("%{", new, &bp);
                        else
                                safe_chr('{', new, &bp);
                        break;
                case '}':
                        if(type)
                                safe_str("%}", new, &bp);
                        else
                                safe_chr('}', new, &bp);
                        break;
                case '(':
                        if(type)
                                safe_str("%(", new, &bp);
                        else
                                safe_chr('(', new, &bp);
                        break;
                case ')':
                        if(type)
                                safe_str("%)", new, &bp);
                        else
                                safe_chr(')', new, &bp);
                        break;
                case '\r':
                        break;
                case '\n':
                        if(type)
                                safe_str("%r", new, &bp);
                        else
                                safe_chr(' ', new, &bp);
                        break;
                default:
                        safe_chr(*j, new, &bp);
                }
        }
        *bp = '\0';
        return new;
}

/*
 * capitalizes an entire string
 */

char *upcasestr(char *s)
{
        char *p;

        for(p = s; p && *p; p++)
                *p = ToUpper(*p);
        return s;
}

/*
 * returns a pointer to the non-space character in s, or a NULL if s == NULL
 * or *s == NULL or s has only spaces.
 */
char *skip_space(const char *s)
{
        char *cp;

        cp = (char *) s;
        while (cp && *cp && isspace(*cp))
                cp++;
        return (cp);
}

char *seek_char(const char *s, char c)
{
        char *cp;

        cp = (char *) s;
        while (cp && *cp && (*cp != c))
                cp++;
        return (cp);
}

char *munge_space(char *string)
{
        char *buffer, *p, *q;

        buffer = alloc_lbuf("munge_space");
        p = string;
        q = buffer;
        while (p && *p && isspace(*p))
                p++;                                    /*
                                                                 * remove inital spaces 
                                                                 */
        while (p && *p) {
                while (*p && !isspace(*p))
                        *q++ = *p++;
                while (*p && isspace(*++p));
                if(*p)
                        *q++ = ' ';
        }
        *q = '\0';                                      /*
                                                                 * remove terminal spaces and terminate * * * 
                                                                 * 
                                                                 * * string 
                                                                 */
        return (buffer);
}

char *trim_spaces(char *string)
{
        char *buffer, *p, *q;

        buffer = alloc_lbuf("trim_spaces");
        p = string;
        q = buffer;
        while (p && *p && isspace(*p))  /*
                                                                         * remove inital spaces 
                                                                         */
                p++;
        while (p && *p) {
                while (*p && !isspace(*p))      /*
                                                                         * copy nonspace chars 
                                                                         */
                        *q++ = *p++;
                while (*p && isspace(*p))       /*
                                                                         * compress spaces 
                                                                         */
                        p++;
                if(*p)
                        *q++ = ' ';                     /*
                                                                 * leave one space 
                                                                 */
        }
        *q = '\0';                                      /*
                                                                 * terminate string 
                                                                 */
        return (buffer);
}

char *grabto(char **str, char targ)
{
        char *savec, *cp;

        if(!str || !*str || !**str)
                return NULL;

        savec = cp = *str;
        while (*cp && *cp != targ)
                cp++;
        if(*cp)
                *cp++ = '\0';
        *str = cp;
        return savec;
}

int string_compare(const char *s1, const char *s2)
{
        if(!mudconf.space_compress) {
                while (*s1 && *s2 && ToLower(*s1) == ToLower(*s2))
                        s1++, s2++;

                return (ToLower(*s1) - ToLower(*s2));
        } else {
                while (isspace(*s1))
                        s1++;
                while (isspace(*s2))
                        s2++;
                while (*s1 && *s2 && ((ToLower(*s1) == ToLower(*s2)) ||
                                                          (isspace(*s1) && isspace(*s2)))) {
                        if(isspace(*s1) && isspace(*s2)) {      /*
                                                                                                 * skip all  
                                                                                                 * other
                                                                                                 * spaces 
                                                                                                 */
                                while (isspace(*s1))
                                        s1++;
                                while (isspace(*s2))
                                        s2++;
                        } else {
                                s1++;
                                s2++;
                        }
                }
                if((*s1) && (*s2))
                        return (1);
                if(isspace(*s1)) {
                        while (isspace(*s1))
                                s1++;
                        return (*s1);
                }
                if(isspace(*s2)) {
                        while (isspace(*s2))
                                s2++;
                        return (*s2);
                }
                if((*s1) || (*s2))
                        return (1);
                return (0);
        }
}

int string_prefix(const char *string, const char *prefix)
{
        int count = 0;

        while (*string && *prefix && ToLower(*string) == ToLower(*prefix))
                string++, prefix++, count++;
        if(*prefix == '\0')                     /*
                                                                 * Matched all of prefix 
                                                                 */
                return (count);
        else
                return (0);
}

const char *string_match(const char *src, const char *sub)
{
        if((*sub != '\0') && (src)) {
                while (*src) {
                        if(string_prefix(src, sub))
                                return src;
                        /*
                         * else scan to beginning of next word 
                         */
                        while (*src && isalnum(*src))
                                src++;
                        while (*src && !isalnum(*src))
                                src++;
                }
        }
        return 0;
}

char *replace_string(const char *old, const char *new, const char *string)
{
        char *result, *r, *s;
        int olen;

        if(string == NULL)
                return NULL;
        s = (char *) string;
        olen = strlen(old);
        r = result = alloc_lbuf("replace_string");
        while (*s) {

                /*
                 * Copy up to the next occurrence of the first char of OLD 
                 */

                while (*s && *s != *old) {
                        safe_chr(*s, result, &r);
                        s++;
                }

                /*
                 * If we are really at an OLD, append NEW to the result and * 
                 * 
                 * *  * *  * * bump the input string past the occurrence of
                 * OLD. *  * * * Otherwise, copy the char and try again. 
                 */

                if(*s) {
                        if(!strncmp(old, s, olen)) {
                                safe_str((char *) new, result, &r);
                                s += olen;
                        } else {
                                safe_chr(*s, result, &r);
                                s++;
                        }
                }
        }
        *r = '\0';
        return result;
}

char *replace_string_inplace(const char *old, const char *new, char *string)
{
        char *s;

        s = replace_string(old, new, string);
        StringCopy(string, s);
        free_lbuf(s);
        return string;
}

int count_chars(const char *str, const char c)
{
        int out = 0;
        const char *p = str;

        if(p)
                while (*p != '\0')
                        if(*p++ == c)
                                out++;
        return out;
}

int prefix_match(const char *s1, const char *s2)
{
        int count = 0;

        while (*s1 && *s2 && (ToLower(*s1) == ToLower(*s2)))
                s1++, s2++, count++;
        /*
         * If the whole string matched, count the null.  (Yes really.) 
         */
        if(!*s1 && !*s2)
                count++;
        return count;
}

int minmatch(char *str, char *target, int min)
{
        while (*str && *target && (ToLower(*str) == ToLower(*target))) {
                str++;
                target++;
                min--;
        }
        if(*str)
                return 0;
        if(!*target)
                return 1;
        return ((min <= 0) ? 1 : 0);
}

char *strsave(const char *s)
{
        char *p;
        p = (char *) XMALLOC(sizeof(char) * (strlen(s) + 1), "strsave");

        if(p)
                StringCopy(p, s);
        return p;
}

int safe_copy_str(char *src, char *buff, char **bufp, int max)
{
        char *tp;

        tp = *bufp;
        if(src == NULL)
                return 0;
        while (*src && ((tp - buff) < max))
                *tp++ = *src++;
        *bufp = tp;
        return strlen(src);
}

int safe_copy_chr(char src, char *buff, char **bufp, int max)
{
        char *tp;
        int retval;

        tp = *bufp;
        retval = 0;
        if((tp - buff) < max) {
                *tp++ = src;
        } else {
                retval = 1;
        }
        *bufp = tp;
        return retval;
}

int matches_exit_from_list(char *str, char *pattern)
{
        char *s;

        while (*pattern) {
                for(s = str;                    /*
                                                                 * check out this one 
                                                                 */
                        (*s && (ToLower(*s) == ToLower(*pattern)) && *pattern &&
                         (*pattern != EXIT_DELIMITER)); s++, pattern++);

                /*
                 * Did we match it all? 
                 */

                if(*s == '\0') {

                        /*
                         * Make sure nothing afterwards 
                         */

                        while (*pattern && isspace(*pattern))
                                pattern++;

                        /*
                         * Did we get it? 
                         */

                        if(!*pattern || (*pattern == EXIT_DELIMITER))
                                return 1;
                }
                /*
                 * We didn't get it, find next string to test 
                 */

                while (*pattern && *pattern++ != EXIT_DELIMITER);
                while (isspace(*pattern))
                        pattern++;
        }
        return 0;
}

---