---

String.cc

Go to the documentation of this file.

/*
    File:           String.cc

    Function:       Implements string class

    Author:         Andrew Willmott

    Notes:
*/


#include "cl/String.h"
#include "cl/CLConfig.h"

#include <stdio.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdarg.h>

String::String(StrConst s) : Array<Char>(s.Length() + 1)
{
    strcpy(item, s);
}

String &String::operator = (StrConst s)
{
    Assert(!s.IsNull(), "(String::=) Can't assign null to a String");
    
    SetSize(s.Length() + 1);
    strcpy(item, s);
    
    return(SELF);
}

String &String::operator = (const Char *s)
{
    Assert(s != 0, "(String::=) Can't assign null to a String");
    
    SetSize(strlen(s) + 1);
    strcpy(item, s);
    
    return(SELF);
}

String &String::Append(StrConst s)
{
    Int start = Length();
    Add(s.Length());
    strcpy(item + start, s);
    return(SELF);
}

String &String::Insert(StrConst s, Int position)
{
    Int len = s.Length();
    
    Array<Char>::Insert(position, len);
    memcpy(item + position, s, len);
    
    return(SELF);
}

String &String::Delete(Int start, Int length)
{
    Array<Char>::Delete(start, length);     
    return(SELF);
}

// --- StrConst class ---------------------------------------------------------------

Int StrConst::FindChar(Char c) const
{
    Char *s = strchr(theString, c);

    if (s)
        return((s - theString));
    else
        return(-1);
}

Int StrConst::FindCharLast(Char c) const
{
    Char *s = strrchr(theString, c);

    if (s)
        return((s - theString));
    else
        return(-1);
}

String StrConst::SubString(Int start, Int length)
{
    String  result;
    Int     strLength = Length();
    
    if (length > 0)
    {
        if (start < 0)
            start = Max(0, Length() + start);
        else
            start = Min(strLength, start);
    
        length = Min(length, strLength - start);

        result.SetSize(length + 1);
        memcpy(result.item, theString + start, length);
        result.item[length] = 0;
    }
        
    return(result);
}

String StrConst::Prefix(Int length)
{
    String  result;
    Int     strLength = Length();
    
    if (length < 0)
        length = Max(0, strLength + length);
    else
        length = Min(strLength, length);

    result.SetSize(length + 1);
    memcpy(result.item, theString, length);
    result.item[length] = 0;
    
    return(result);
}

String StrConst::Suffix(Int length)
{
    String  result;
    Int     strLength = Length(), offset;
        
    if (length < 0)
        offset = Min(strLength, -length);
    else
        offset = Max(0, strLength - length);

    result = (theString + offset);
    
    return(result);
}

istream &String::ReadString(istream &s)
{
    Char    c;
    
    //  Expected format: "... "
    
    while (isspace(s.peek()))           //  chomp white space
        s.get(c);
        
    if (s.peek() == '"')                        
    {
        s.get(c);
        Clear();
                
        while (s.peek() != '"')
        {           
            s.get(c);
            
            if (!s)
            {
                Expect(false, "Couldn't read array component");
                return(s);
            }
            else
                Array<Char>::Append(c);
        }           
        s.get(c);
    }
    else
    {
        s.clear(ios::failbit);
        Expect(false, "Error: Expected '\"' while reading string");
        return(s);
    }
    
    Array<Char>::Append(0);

    return(s);
}

istream &operator >> (istream &s, String &str)
{
    // We default to reading a string. Use the other Read... methods to
    // read/parse other types of data.

    str.ReadString(s);
    return(s);
}

istream &String::ReadWord(istream &s)
{
    Char    c;
    
    //  Expected format: "... "
    
    while (isspace(s.peek()))           //  chomp white space
        s.get(c);
        
    Clear();
                
    while (!isspace(s.peek()))
    {           
        s.get(c);
        
        if (!s)
        {
            Expect(false, "Couldn't read word");
            return(s);
        }
        else
            Array<Char>::Append(c);
    }           
    
    Array<Char>::Append(0);

    return(s);
}

int iseol(int c)
{
    return(c == 0x0a || c == 0x0d);
}

istream &String::ReadLine(istream &s)
{
    Char    c;
                
    Clear();
                
    while (1)
    {           
        s.get(c);
        
        if (!s || iseol(c))
            break;
        else
            Array<Char>::Append(c);
    }           
    
    Array<Char>::Append(0);

    return(s);
}


String &String::Printf(const Char *format, ...)
{
    static Char buffer[2048];
    Int         size;
    va_list     ap;
    
    va_start(ap, format);
#ifdef CL_HAS_VSNPRINTF
    size = vsnprintf(buffer, 2048, format, ap);
#else
    size = vsprintf(buffer, format, ap);
#endif

    if (size >= 0)
    {
        SetSize(size + 1);
        strcpy(item, buffer);
    }
    else
        SELF = "<string too large>";

    va_end(ap);

    return(SELF);
}

// --- String utilities -------------------------------------------


Bool IsEndOfLine(istream &s)
{
    char c;
    
    while (isspace(s.peek()) && !iseol(s.peek()))
        s.get(c);

    return(iseol(s.peek()));
}

Void ChompWhiteSpace(istream &s)
{
    char    c;
    
    while (isspace(s.peek()))               //  chomp white space
        s.get(c);
}

TempString SubstituteEnvVars(StrConst s)
{
    StrConst        varStart, varSub, oldVarStart;
    String          var;
    TempString      result;
    Int             vlen;
    
    varStart = s;
    
    while (varStart)
    {
        oldVarStart = varStart;
        varStart = strchr(varStart, '$');

        if (varStart)
        {
            result += oldVarStart.Prefix((varStart - oldVarStart));
            vlen = strcspn(varStart, "/- \t}.,;\"'");
            var = varStart.SubString(1, vlen - 1);
            
            varStart = varStart + vlen;
            if (var[0] == '{' && varStart[0] == '}')
            {
                varStart = varStart + 1;
                var = var.Suffix(-1);
            }
            varSub = getenv(var.CString());
            if (varSub)
                result += varSub;
            else
                result += "<" + var + ">";
        }       
    }
    
    result += oldVarStart;

    return(result);
}

Void Split(StrConst line, StrConstArray &a, StrConst sep)
// Splits 'line' into an array of tokens 'a', where each token is separated
// by the characters in "sep" (default is white space).
{
    static String   buffer;
    StrConst        s;

    buffer = line;
    a.Clear();
    s = strtok(buffer.CString(), sep);
    if (!s)
        return;
    a.Append(s);
    while (s = strtok(0, sep))
        a.Append(s);
}

#ifdef CL_TMPL_INST
template class Array<Char>;
#endif

---