source: trunk/third/sysinfo/strutil.c @ 12269

/* 
 * Copyright (c) 1992-1998 Michael A. Cooper. 
 * This software may be freely used and distributed provided it is not 
 * sold for profit or used in part or in whole for commercial gain 
 * without prior written agreement, and the author is credited 
 * appropriately. 
 */ 

#ifndef lint
static char *RCSid = "$Revision: 1.1.1.3 $";
#endif

/*
 * String utility functions
 */
#include "defs.h"
#include "strutil.h"

/*
 * Is What in List?
 */
int IsSep(What, List)
    int                         What;
    char                       *List;
{
    register char              *cp;

    for (cp = List; cp < &List[strlen(List)]; ++cp)
        if (What == *cp)
            return(1);

    return(0);
}

/*
 * Find the first seperator from List in String and
 * return a pointer.
 */
char *FindSep(String, List)
    char                       *String;
    char                       *List;
{
    register char              *cp;

    for (cp = String; cp < &String[strlen(String)]; ++cp)
        if (IsSep(*cp, List))
            return(cp);

    return((char *)NULL);
}

/*
 * Is What a quote character?  If so, return the ending quote char
 * which is the next char in QuoteChars.  QuoteChars may contain
 * multiple pairs of quote characters. e.g ""<>''`'
 */
int IsQuote(What, QuoteChars)
     int                        What;
     char                      *QuoteChars;
{
    int                         QuotePair;
    static int                  NumQuotes;
    static char                *LastQuoteChars;

    if (!QuoteChars)
        return(0);

    if (LastQuoteChars != QuoteChars || !NumQuotes)
        NumQuotes = strlen(QuoteChars);
    LastQuoteChars = QuoteChars;

    for (QuotePair = 0; QuotePair < NumQuotes; QuotePair += 2) {
        if (What == QuoteChars[QuotePair])
            return(QuoteChars[QuotePair+1]);
    }

    return(0);
}

/*
 * Parse a string into an argument vector.
 * List is the string to be parsed.
 * SepChars is the list of seperator characters which will be used to
 *              break apart List.
 * ArgvPtr is where the argument results will be stored.
 * QuoteChars is the list of characters which indicate single arguments.
 *              This is a list of pairs.  The first char indicated begining
 *              of quoted argument, the next char indicates end. e.g ""<>''`'
 */
extern int
StrToArgv(List, SepChars, ArgvPtr, QuoteChars, Flags)
    char                       *List;
    char                       *SepChars;
    char                     ***ArgvPtr;
    char                       *QuoteChars;
    int                         Flags;
{
    char                      **Argv = NULL;
    char                       *String;
    char                       *Ptr;
    char                       *Start;
    char                       *Next;
    char                       *End;
    int                         EndQuote;
    register char              *cp;
    register int                Count;
    register int                i;

    if (!List)
        return(0);

    String = List;
    for (Count = 0, Ptr = String; Ptr && *Ptr; ++Ptr) {
        if (EndQuote = IsQuote(*Ptr, QuoteChars))
            while (*(++Ptr) != EndQuote);
        if (IsSep(*Ptr, SepChars))
            ++Count;
        if (FLAGS_ON(Flags, STRTO_SKIPRP)) {
            /* Skip over rest of SepChars for now */
            while (Ptr && *Ptr && IsSep(*Ptr, SepChars))
                ++Ptr;
        }
    }

    /*
     * Watch for ending seperator
     */
    if (IsSep(*(Ptr-1), SepChars))
        --Count;

    /*
     * There's only one argument with no seperator?
     */
    if (Count == 0 && String && *String)
        ++Count;
    else if (!Count)
        return(0);
    else
        Count++;

    Argv = (char **) xcalloc(Count+1, sizeof(char *));

    /* 
     * We don't use strtok() because it doesn't like back-to-back
     * seperators.  e.g. "foo||bar" will skip the NULL argument.
     * strtok() also doesn't do QuoteChars like we do.
     */
    for (i = 0, Start = NULL, Ptr = String; i < Count; ++i) {
        Start = Ptr;
        if (!isspace(*SepChars))
            /* Skip leading white space */
            for ( ; Start && *Start && isspace(*Start); ++Start);
        if (EndQuote = IsQuote(*Start, QuoteChars))
            ++Start;
        /* Find end of word */
        for (End = Start; End && *End; ++End) {
            if (EndQuote) {
                if (*End == EndQuote)
                    break;
            } else if (IsSep(*End, SepChars))
                break;
        }
        /* Mark next field */
        Next = End;
        if (Next)
            ++Next;
        /* Remove trailing white space */
        if (!isspace(*SepChars) && isspace(*(End-1))) {
            while (--End > Start && *End && isspace(*End));
            ++End;
        }
        if (End > Start) {
            Argv[i] = (char *) xmalloc( (End - Start) + 1 );
            (void) strncpy(Argv[i], Start, End - Start);
            Argv[i][End - Start] = CNULL;
        }
        Ptr = Next;
        if (!Next)
            break;
        if (FLAGS_ON(Flags, STRTO_SKIPRP)) {
            /* Skip over rest of SepChars for now */
            while (Ptr && *Ptr && IsSep(*Ptr, SepChars))
                ++Ptr;
        }
    }

    *ArgvPtr = Argv;

    return(Count);
}

/*
 * Destroy an argument vector such as was created by StrToArgv().
 */
extern void
DestroyArgv(ArgvPtr, Argc)
    char                     ***ArgvPtr;
    int                         Argc;
{
    register int                i;
    char                      **Argv;

    if (Argc <= 0 || !ArgvPtr)
        return;

    Argv = *ArgvPtr;
    for (i = 0; i < Argc; ++i)
        if (Argv[i])
            (void) free(Argv[i]);

    (void) free(*ArgvPtr);
    *ArgvPtr = NULL;
}

/*
 * Make String all lower case.
 */
extern void strtolower(String)
    char                       *String;
{
    register char              *cp;

    for (cp = String; cp && *cp; ++cp)
        if (isupper(*cp))
            *cp = tolower(*cp);
}

/*
 * Return an all lower case version of String
 */
extern char *strlower(String)
    char                       *String;
{
    static char                *Buffer = NULL;
    register char              *cp;

    if (Buffer)
        free(Buffer);

    Buffer = strdup(String);

    for (cp = Buffer; cp && *cp; ++cp)
        if (isupper(*cp))
            *cp = tolower(*cp);

    return(Buffer);
}

/*
 * Return an all upper case version of String
 */
extern char *strupper(String)
    char                       *String;
{
    static char                *Buffer = NULL;
    register char              *cp;

    if (Buffer)
        free(Buffer);

    Buffer = strdup(String);

    for (cp = Buffer; cp && *cp; ++cp)
        if (islower(*cp))
            *cp = toupper(*cp);

    return(Buffer);
}