gecko-dev/lib/xp/xp_str.c

/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */


#include "xp.h"
#include "xp_str.h"
#include <ctype.h>
#include <stdarg.h>

#ifdef PROFILE
#pragma profile on
#endif

#if !defined(XP_WIN) && !defined(XP_OS2) /* keep this out of the winfe */
#if defined(DEBUG)

char *
NOT_NULL (const char * p)
{
	XP_ASSERT(p);
	return (char*) p;
}

#endif
#endif

#define TOLOWER_TABLE_SIZE 128

PRIVATE uint8 *
xp_get_tolower_table()
{
	static uint8 tolower_table[TOLOWER_TABLE_SIZE];
    static XP_Bool first_time = TRUE;

    if(first_time)
    {
        int i;
        first_time = FALSE;

        /* build the tolower_table */
        for(i=0; i < sizeof(tolower_table); i++)
        {
            tolower_table[i] = (uint8) tolower((char)i);
        }
    }

	return tolower_table;
}

PRIVATE uint8 *
xp_get_toupper_table()
{
	static uint8 toupper_table[TOLOWER_TABLE_SIZE];
    static XP_Bool first_time = TRUE;

    if(first_time)
    {
        int i;
        first_time = FALSE;

        /* build the tolower_table */
        for(i=0; i < sizeof(toupper_table); i++)
        {
            toupper_table[i] = (uint8) toupper((char)i);
        }
    }

	return toupper_table;
}

#define XP_STR_TOUPPER(c) (c < TOLOWER_TABLE_SIZE ? toupper_table[c] : c)
#define XP_STR_TOLOWER(c) (c < TOLOWER_TABLE_SIZE ? tolower_table[c] : c)

/* fast table driven tolower routine 
 *
 * We only deal with 7 bit ascii
 */
PUBLIC int
xp_tolower(int c)
{
	uint8 *tolower_table = xp_get_tolower_table();

	return XP_STR_TOLOWER(c);
}

/* fast table driven toupper routine 
 *
 * We only deal with 7 bit ascii
 */
PUBLIC int
xp_toupper(int c)
{
	uint8 *toupper_table = xp_get_toupper_table();

	return XP_STR_TOUPPER(c);
}

/* find a substring within a string with a case insensitive search
 */
PUBLIC char *
strcasestr (const char * str, const char * substr)
{
    register const char *pA;
    register const char *pB;
    register const char *pC;
	uint8 *toupper_table = xp_get_toupper_table();

	if(!str)
		return(NULL);
	
	for(pA=str; *pA; pA++)
	  {
		if(XP_STR_TOUPPER(*pA) == XP_STR_TOUPPER(*substr))
		  {
    		for(pB=pA, pC=substr; ; pB++, pC++)
              {
                if(!(*pC))
                    return((char *)pA);

				if(!(*pB))
					break;

				if(XP_STR_TOUPPER(*pB) != XP_STR_TOUPPER(*pC))
					break;
              }
		  }
	  }

	return(NULL);
}

/* find a char within a specified length string
 */
PUBLIC char *
strnchr (const char * str, const char single, int32 len)
{
	register int count=0;
    register const char *pA;

    if(!str)
        return(NULL);
   
    for(pA=str; count < len; pA++, count++)
      {
        if(*pA == single)
          {
             return((char *)pA);
          }

		if(!(*pA))
			return(NULL);
      }

    return(NULL);
}

/* find a substring within a specified length string with a case 
 * insensitive search
 */
PUBLIC char *
strncasestr (const char * str, const char * substr, int32 len)
{
	register int count=0;
	register int count2=0;
    register const char *pA;
    register const char *pB;
    register const char *pC;
	uint8 *toupper_table = xp_get_toupper_table();

    if(!str || !substr)
        return(NULL);
   
    for(pA=str; count < len; pA++, count++)
      {
        if(XP_STR_TOUPPER(*pA) == XP_STR_TOUPPER(*substr))
          {
            for(pB=pA, pC=substr, count2=count; count2<len; 
													count2++,pB++,pC++)
              {
                if(!(*pC))
                    return((char *)pA);

                if(!(*pB))
                    break;

                if(XP_TO_UPPER(*pB) != XP_TO_UPPER(*pC))
                    break;
              }
          }
      }

    return(NULL);
}


/*	compare strings in a case insensitive manner
*/
PUBLIC int 
strcasecomp (const char* one, const char *two)
{
	const char *pA;
	const char *pB;
	uint8 *toupper_table = xp_get_toupper_table();

	for(pA=one, pB=two; *pA && *pB; pA++, pB++) 
	  {
	    register int tmp = XP_STR_TOUPPER(*pA) - XP_STR_TOUPPER(*pB);
	    if (tmp) 
			return tmp;
	  }

	if (*pA) 
		return 1;	
	if (*pB) 
		return -1;
	return 0;	
}


/*	compare strings in a case insensitive manner with a length limit
*/
PUBLIC int 
strncasecomp (const char* one, const char * two, int n)
{
	const char *pA;
	const char *pB;
	uint8 *toupper_table = xp_get_toupper_table();
	
	for(pA=one, pB=two;; pA++, pB++) 
	  {
	    int tmp;
	    if (pA == one+n) 
			return 0;	
	    if (!(*pA && *pB)) 
			return *pA - *pB;
	    tmp = XP_STR_TOUPPER(*pA) - XP_STR_TOUPPER(*pB);
	    if (tmp) 
			return tmp;
	  }
}

/************************************************************************
 * These are "safe" versions of the runtime library routines. The RTL
 * versions do not null-terminate dest IFF strlen(src) >= destLength.
 * These versions always null-terminate, which is why they're safe.
 */

char *XP_STRNCAT_SAFE (char *dest, const char *src, size_t maxToCat)
{
	int destLen; 
	char *result; 

	destLen = XP_STRLEN (dest);
	result = strncat (dest, src, --maxToCat);
	dest[destLen + maxToCat] = '\0';
	return result;
}

char *XP_STRNCPY_SAFE (char *dest, const char *src, size_t destLength)
{
	char *result = strncpy (dest, src, --destLength);
	dest[destLength] = '\0';
	return result;
}

/*************************************************
   The following functions are used to implement
   a thread safe strtok
 *************************************************/
/*
 * Get next token from string *stringp, where tokens are (possibly empty)
 * strings separated by characters from delim.  Tokens are separated
 * by exactly one delimiter iff the skip parameter is false; otherwise
 * they are separated by runs of characters from delim, because we
 * skip over any initial `delim' characters.
 *
 * Writes NULs into the string at *stringp to end tokens.
 * delim will usually, but need not, remain CONSTant from call to call.
 * On return, *stringp points past the last NUL written (if there might
 * be further tokens), or is NULL (if there are definitely no more tokens).
 *
 * If *stringp is NULL, strtoken returns NULL.
 */
static 
char *strtoken_r(char ** stringp, const char *delim, int skip)
{
	char *s;
	const char *spanp;
	int c, sc;
	char *tok;

	if ((s = *stringp) == NULL)
		return (NULL);

	if (skip) {
		/*
		 * Skip (span) leading delimiters (s += strspn(s, delim)).
		 */
	cont:
		c = *s;
		for (spanp = delim; (sc = *spanp++) != 0;) {
			if (c == sc) {
				s++;
				goto cont;
			}
		}
		if (c == 0) {		/* no token found */
			*stringp = NULL;
			return (NULL);
		}
	}

	/*
	 * Scan token (scan for delimiters: s += strcspn(s, delim), sort of).
	 * Note that delim must have one NUL; we stop if we see that, too.
	 */
	for (tok = s;;) {
		c = *s++;
		spanp = delim;
		do {
			if ((sc = *spanp++) == c) {
				if (c == 0)
					s = NULL;
				else
					s[-1] = 0;
				*stringp = s;
				return( (char *) tok );
			}
		} while (sc != 0);
	}
	/* NOTREACHED */
}


char *XP_STRTOK_R(char *s1, const char *s2, char **lasts)
{
	if (s1)
		*lasts = s1;
	return (strtoken_r(lasts, s2, 1));
}


#ifdef PROFILE
#pragma profile off
#endif