/*
 * The contents of this file are subject to the AOLserver Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://aolserver.lcs.mit.edu/.
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is AOLserver Code and related documentation
 * distributed by AOL.
 * 
 * The Initial Developer of the Original Code is America Online,
 * Inc. Portions created by AOL are Copyright (C) 1999 America Online,
 * Inc. All Rights Reserved.
 *
 * Alternatively, the contents of this file may be used under the terms
 * of the GNU General Public License (the "GPL"), in which case the
 * provisions of GPL are applicable instead of those above.  If you wish
 * to allow use of your version of this file only under the terms of the
 * GPL and not to allow others to use your version of this file under the
 * License, indicate your decision by deleting the provisions above and
 * replace them with the notice and other provisions required by the GPL.
 * If you do not delete the provisions above, a recipient may use your
 * version of this file under either the License or the GPL.
 */


/*
 * str.c --
 *
 *	Functions that deal with strings. 
 */

#include "nsd.h"

/*
 *==========================================================================
 * API functions
 *==========================================================================
 */


/*
 *----------------------------------------------------------------------
 *
 * Ns_StrTrim --
 *
 *	Trim leading and trailing white space from a string. 
 *
 * Results:
 *	A pointer to the trimmed string, which will be in the original 
 *	string. 
 *
 * Side effects:
 *	May modify passed-in string. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_StrTrim(char *string)
{
    return Ns_StrTrimLeft(Ns_StrTrimRight(string));
}



/*
 *----------------------------------------------------------------------
 *
 * Ns_StrTrimLeft --
 *
 *	Trim leading white space from a string. 
 *
 * Results:
 *	A pointer to the trimmed string, which will be in the 
 *	original string. 
 *
 * Side effects:
 *	None. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_StrTrimLeft(char *string)
{
    assert(string != 0);

    while (isspace(UCHAR(*string))) {
        ++string;
    }
    
    return string;
}



/*
 *----------------------------------------------------------------------
 *
 * Ns_StrTrimRight --
 *
 *	Trim trailing white space from a string. 
 *
 * Results:
 *	A pointer to the trimmed string, which will be in the 
 *	original string. 
 *
 * Side effects:
 *	The string will be modified. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_StrTrimRight(char *string)
{
    int len;

    assert(string != 0);

    len = strlen(string);
    while ((len-- >= 0) &&
	   (isspace(UCHAR(string[len])) ||
	    string[len] == '\n')) {
	
        string[len] = '\0';
    }
    
    return string;
}


/*
 *----------------------------------------------------------------------
 *
 * Ns_StrToLower --
 *
 *	All alph. chars in a string will be made to be lowercase. 
 *
 * Results:
 *	Same string as passed in. 
 *
 * Side effects:
 *	Will modify string. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_StrToLower(char *string)
{
    char *s;

    s = string;
    while (*s != '\0') {
        if (isupper(UCHAR(*s))) {
            *s = tolower(UCHAR(*s));
        }
        ++s;
    }
    
    return string;
}


/*
 *----------------------------------------------------------------------
 *
 * Ns_StrToUpper --
 *
 *	All alph. chars in a string will be made to be uppercase. 
 *
 * Results:
 *	Same string as pssed in. 
 *
 * Side effects:
 *	Will modify string. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_StrToUpper(char *string)
{
    char *s;

    s = string;
    while (*s != '\0') {
        if (islower(UCHAR(*s))) {
            *s = toupper(UCHAR(*s));
        }
        ++s;
    }
    
    return string;
}


/*
 *----------------------------------------------------------------------
 *
 * Ns_StrCaseFind --
 *
 *	A case-insensitive version of strstr. 
 *
 * Results:
 *	A pointer in s1 to where s2 begins. 
 *
 * Side effects:
 *	None. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_StrCaseFind(char *s1, char *s2)
{
    Ns_DString  ds1;
    Ns_DString  ds2;
    char       *p;

    Ns_DStringInit(&ds1);
    Ns_DStringInit(&ds2);
    Ns_DStringAppend(&ds1, s1);
    Ns_DStringAppend(&ds1, s2);
    Ns_StrToLower(ds1.string);
    Ns_StrToLower(ds2.string);
    p = strstr(ds1.string, ds2.string);
    if (p != NULL) {
        p = s1 + (p - ds1.string);
    }
    Ns_DStringFree(&ds1);
    Ns_DStringFree(&ds2);
    return p;
}


/*
 *----------------------------------------------------------------------
 *
 * Ns_Match --
 *
 *	Compare the beginnings of two strings, case insensitively. 
 *	The comparison stops when the end of the shorter string is 
 *	reached. 
 *
 * Results:
 *	NULL if no match, b if match. 
 *
 * Side effects:
 *	None. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_Match(char *a, char *b)
{
    if (a && b) {
        while (*a && *b) {
            char            c1, c2;

            c1 = islower(UCHAR(*a)) ? *a : tolower(UCHAR(*a));
            c2 = islower(UCHAR(*b)) ? *b : tolower(UCHAR(*b));
            if (c1 != c2) {
                return NULL;
            }
            a++;
            b++;
        }
    }
    return (char *) b;
}


/*
 *----------------------------------------------------------------------
 *
 * Ns_NextWord --
 *
 *	Return a pointer to first character of the next word in a 
 *	string; words are separated by white space. 
 *
 * Results:
 *	A string pointer in the original string. 
 *
 * Side effects:
 *	None. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_NextWord(char *line)
{
    while (*line != '\0' && !isspace(UCHAR(*line))) {
        ++line;
    }
    while (*line != '\0' && isspace(UCHAR(*line))) {
        ++line;
    }
    
    return line;
}


/*
 *----------------------------------------------------------------------
 *
 * Ns_StrNStr --
 *
 *	Search through pattern for expression, case insensitively. 
 *
 * Results:
 *	A pointer to where the match begins. 
 *
 * Side effects:
 *	None. 
 *
 *----------------------------------------------------------------------
 */

char *
Ns_StrNStr(char *pattern, char *expression)
{
    char *top;
    int   plen, elen, epos, ppos;
    
    plen = strlen(pattern);
    elen = strlen(expression);
    if (elen > plen) {
	/*
	 * Expression is longer than pattern, so no way there's a match
	 */
	return NULL;
    }

    epos=0;
    ppos=0;
    for (top=pattern; top <= pattern + plen - elen; top++) {
	while (epos < elen && toupper(UCHAR(top[ppos])) ==
	       toupper(UCHAR(expression[epos]))) {
	    ppos++;
	    epos++;
	}
	if (epos == elen) {
	    return top;
	}
	ppos=0;
	epos=0;
    }

    return NULL;
}